Вы находитесь на странице: 1из 74

Target Tracking in Mobile Sensor Network

ABSTRACT

The project “Distributed Mobilty Management for target tracking in mobile


sensor Network” is designed using Microsoft Visual
Studio.Net 2005 as front end and Microsoft SQL Server 2000 as backend which works
in .Net framework version 2.0. The coding language used is VB .Net.

Mobility management is a major challenge in mobile ad hoc networks due


in part to the dynamically changing network topologies. For mobile sensor networks that
are deployed for surveillance applications, it is important to use a mobility management
scheme that can empower nodes to make better decisions regarding their positions such
that strategic tasks such as target tracking can benefit from node movement. In this paper,
we describe a distributed mobility management scheme for mobile sensor networks.
We focus on the mobility management problem for mobile sensor networks in this
paper. Mobility management in sensor networks is different from that in mobile ad hoc
networks because the movement of sensor nodes here is not random; rather, the
movement of sensor nodes is purposeful, e.g., to actively and better track an intruder. In
such scenarios, it is important to have an efficient mobility management scheme to ensure
that sensor node mobility is exploited in the best possible way, e.g., to improve the
quality of target tracking. At the same time, the mobility management strategy should
avoid inefficient usage of scarce resources, such as energy and network bandwidth.
Furthermore, the mobility management scheme should also take into account the
potential negative consequences of node movement, e.g., loss of area coverage, loss of
connectivity, and degradation of network performance. In addition, node movement also
involves locomotion energy and routing overhead, especially the need to reestablish
routes. Therefore, a practical mobility management scheme should empower a node with
the ability to determine whether it should move and where it should move to such that the
movement can enhance tracking quality without depleting scarce resources or
significantly compromising coverage and network connectivity. Note that, for wireless
sensor networks with scarce energy resources, it is not always favorable for nodes to
move during field operation because the energy required for locomotion energy is often
much higher than that for sensing and communication. when nodes can afford the energy
cost associated with mobility, it is important to have a network management scheme that
can make effective use of mobility to facilitate application objectives. For example,
multiple mobile robots can be deployed in a battlefield for target tracking without human
intervention . These mobile robots can form an ad hoc sensor network for monitoring the
region of interest. To ensure better tracking quality for a moving target, it is beneficial to
dynamically move nodes to advantageous locations. In this paper, we present an efficient
mobility management scheme that can be implemented in a fully distributed manner. The
proposed mobility management scheme is a general framework that incorporates both the
positive and negative consequences of node movement; it allows a node to autonomously
decide whether it should move and where it should move to. It is based on concepts taken
from Bayesian estimation theory.
TABLE OF CONTENTS

CHAPTER NO TITLE PAGE NO

ABSTRACT
LIST OF TABLES
LIST OF FIGURES
LIST OF ABBREVIATIONS

1. INTRODUCTION
1.1 ABOUT THE ORGANIZATION
1.2 PROJECT DESCRIPTION

2. SYSTEM STUDY
2.1 FEASABILITY STUDY
2.2 EXISTING SYSTEM
2.3 PROPOSED SYSTEM
3 SYSTEM SPECIFICATION
3.1 SOFTWARE REQUIREMENTS
3.2 HARDWARE REQUIREMENTS
4 LANGUAGE SPECIFICATION
4.1 FEATURES OF ASP .NET
4.2 FEATURES OF MS-ACCESS 2000
5 SYSTEM DESIGN
5.1 INPUT DESIGN
5.2 OUTPUT DESIGN
5.3 DATABASE DESIGN
5.4 DATA FLOW DIAGRAM
6 SYSTEM TESTING AND MAINTENANCE
6.1 UNIT TESTING
6.2 INTEGRATION TESTING
6.3 VALIDATION TESTING

7 SYSTEM IMPLEMENTATION
7.1 SCOPE FOR FUTURE DEVELOPMENT

8 CONCLUSION
9 BIBLIOGRAPHY
APPENDIX
• SCREEN SHOT
• DATA TABLE STRUCTURE
• SAMPLE CODING

LIST OF ABBREVIATIONS
HTML : Hyper Text Markup Language
DHTML : Dynamic Hyper Text Markup Language
CGI : Common Gateway Interface
ASP : Active Server Pages
CTS : Common Type System
CLR : Common Language Runtime
XML : Extended Markup Language
SQL : Structured Query Language
CLS : Common Language Specification
IL : Intermediate Language
ADO : ActiveX Data Object
COM : Component Object Model
IIS : Internet Information Server
URL : Uniform Resource Locator
JSP : Java Server Package

1. INTRODUCTION
1.1 ABOUT THE ORGANISATION

COMPANY PROFILE
.

1.2 PROJECT DESCRIPTION

In this Distributed Mobility Management for target tracking in mobile


sensor network is used to track the Mobile user’s location with the help of Distributed
database management and Bayesian Estimation.

List of Modules
1. MU Details (Mobile user)
2. DB Management
3. Mobile Node management (hlr,vlr)
4. Path Details (locations)
5. Tracking

1. MU Details (Mobile user)

Mobile user contains managing user details Profiles, PTN (Personal


telecommunication number) and Registration details,
1. Profile
2. Indexing
2. DB Management

Database management contains Distributed server details, the distributed


database management contains multiple architectures, DB0, DB1, DB2

Distributed database management architecture

ORGANIZATION OF DB0:

The DB0 consists of an index file and a data file. With the
location-independent numbering plan being adopted, every subscriber in the whole
mobile system has an entry in the index file. If the direct file is used, each index entry
only contains a pointer. When a user is residing in the current DS area, the pointer is
pointing to the user’s service profile stored in the data file. The user service profile
contains a pointer to the DB1 where the user is visiting. When the user is staying in
another DS, the pointer in the user’s index entry points to the DB0 associated with that
DS.

All entries in the index file are allocated the same size of
storage and stored in increasing order of the users’ PTNs so that direct addressing can be
used to retrieve a record from the index file. Note that the PTN does not need to be stored
in the index entry. On the other hand, the T-tree or the B -tree needs to include the PTN
in each index entry and store other index management information, thus requiring more
memory capacity than the direct file. Therefore, the direct file is the best choice for the
index file of the DB0. In the data file, each user residing in the current DS area is
allocated a record to store the user’s service profile.

Note that the access time of the DB0 is independent of the


database size when the direct file technique is employed (but the access time is affected
by the access frequency of the DB0). This scalability feature is very useful for future
mobility applications since the number of subscribers is expected to increase steadily.

ORGANIZATION OF DB1:

Each DB1 consists only of one part: the index file, in which
each user currently residing in the DB1 area has a data item. Each data item in the index
file consists of two fields: the user’s PTN and a pointer to the DB2 the user is currently
visiting. No other user information is stored in the DB1. Results from Section V reveal
that the T-tree is a preferable technique for the index file of DB1.

ORGANIZATION OF DB2:
Each of the database DB2s consists of two parts: the index file
and the data file. Each user currently residing in the DB2 area has an entry in the index.
Each entry in the index consists of two fields: the user’s PTN and a pointer to the user
record in the data file that stores the service profiles for each user currently visiting this
DB2 area.
3.Mobile Node management (hlr,vlr)

Managing the mobile node address and movement of the mobile node based on
the loss of energy. And when the user will move, join or leave the information will
exchange the server.

4.Path Details (locations)

The path details contain store the detail about tower reaching areas and directions,
location details. It is used to very easily find out the particular user locations.

5.Tracking

How the predicted sensor measurement at candidate locations is


used to obtain the predicted target estimate on the basis of Bayesian
estimation, calculate the target estimate
based on the predicted sensor measurements. The node can
then make a decision on where to move.
2. SYSTEM STUDY
2.1 FEASIBILTY STUDY
The work of actuaries is typically concerned with the projection of asset
and liability cash flows for insurance companies, pension funds and social security
systems. But these asset and liability cash flows cannot be projected with absolute
certainty; there is an inherent element of uncertainty associated with any actuarial
projection. In Principles Underlying Asset Liability Management [vide: reference {1}] the
Society of Actuaries Task Force on Asset Liability Management Principles identified the
dynamic environments in which these institutional entities operate, as well as the effects
of pure randomness, as factors that create uncertainties in the measures of cash flows and,
hence, in the true future risk exposures of the entity. Risk varies as the underlying risk
factors, such as interest rates and mortality, change in a dynamic manner over time, with
either positive or negative financial implications, and as the original estimated future
expected cash flows are replaced by the results emerging from the actual cash flows that
are experienced. This process, reflecting how cash flows react to factor changes will
often result, over time, in revisions being made to future risk factor assumptions. The
management and oversight of the financial condition of Social Security systems will
require the use of models to project the systems’ future uncertain cash flows. In many
cases, simple deterministic models are used and the management and oversight activities
are based on one single projection of expected future cash flows. In other cases, such as
when future cash flows are expected to depend on future economic conditions, more
complex stochastic models (or multiple sets of deterministic scenarios) may be required
to understand the interaction of the various factors that affect future cash flows.
Stochastic models are often used to simulate future expected cash flows under various
scenarios to help identify the associated risk exposures. These models produce statistical
distributions of potential results and, as a consequence, different management strategies
and policy options can be evaluated by studying the range of results produced from
modeling these cash flow projections. Modeling can also be used to construct many
possible futures or scenarios, and then, results across all the scenarios can be used to
measure risks inherent in the system. There are also certain risks associated with the use
of a particular model; model risk is created when the model does not adequately represent
the underlying process or reality. There are two general classes of model risk; the risk of
model misspecification or oversimplification, and the risk of a changing environment not
anticipated in the model. Using a particular model with a too simple characterization of
the distribution of an economic variable may not disclose the inherent risk to the system.
Model risk would, for example, exist in circumstances where an inappropriate model is
used with too few extreme value sample points to adequately assess the risk for extreme
events that have a low incidence but significant financial impact. In addition, the
volatility of certain economic factors may vary over time and this may not be accurately
captured in the model. Communicating the nature of uncertainty requires particular care
and skill to ensure that the intended users of actuarial projections adequately comprehend
the implications of reliance on single-scenario or multi-scenario deterministic projections.
Even greater care and skill is required in communicating the uncertainties and the degree
of credibility associated with stochastic projections.

2.2 EXISTING SYSTEM

Existing System is: MANET

A MANET generally has the following characteristics

• Difficult to invoke the mobile users Location.


• We can’t implement Dynamic Changing topology in Mobile Adhoc
Network.
• Loss of network Connectivity in Adhoc Network. [Error in Network
Connection]
• Difficult to Identify the Node Movement (Mobile Users Movement) in
Mobile Adhoc Network.

2.3 PROPOSED SYSTEM

1. Distributed Database:
Collections of data (e.g.. in a database) can be distributed across
multiple physical locations. A distributed database is distributed into separate
partitions/fragments. Each partition/fragment of a distributed database may be
replicated.

2. Mobile Sensor Network:


It Will Work in any environment. So no Problem about Dynamic changing
topology.

3. Bayesian Estimation:

Bayesian means Prediction. Predict Mobile Users Movement in our project


with the help of Bayesian estimation.

The proposed scheme considers node movement decisions as part of a distributed


optimization problem which integrates mobility-enhanced improvement in the quality of
target tracking data with the associated negative consequences of increased energy
consumption due to locomotion, potential loss of network connectivity, and loss of
sensing coverage.
3. SYSTEM CONFIGURATION

3.1 HARDWARE CONFIGURATION

The hardware used for the development of the project is:

PROCESSOR : PENTIUM III 766 MHz


RAM : 128 MD SD RAM
MONITOR : 15” COLOR
HARD DISK : 20 GB
FLOPPY DRIVE : 1.44 MB
CDDRIVE : LG 52X
KEYBOARD : STANDARD 102 KEYS
MOUSE : 3 BUTTONS

3.2 SOFTWARE CONFIGURATION

The software used for the development of the project is:

OPERATING SYSTEM : Windows 2000 Professional


LANGUAGE : VB.NET
WEB SERVER : Internet Information Server 5.0
BACK END : sql 2000
4. LANGUAGE SPECIFICATION

4.1FEATURES OF VISUAL BASIC .NET

THE .NET FRAMEWORK


The .NET Framework is a new computing platform that simplifies application
development in the highly distributed environment of the Internet.

OBJECTIVES OF .NET FRAMEWORK:

1. To provide a consistent object-oriented programming environment whether


object codes is stored and executed locally on Internet-distributed, or executed remotely.
2. To provide a code-execution environment to minimizes software deployment
and guarantees safe execution of code.
3. Eliminates the performance problems.
There are different types of application, such as Windows-based applications and
Web-based applications. To make communication on distributed environment to ensure
that code be accessed by the .NET Framework can integrate with any other code.

COMPONENTS OF . NET FRAMEWORK


1. THE COMMON LANGUAGE RUNTIME (CLR):
The common language runtime is the foundation of the .NET Framework. It
manages code at execution time, providing important services such as memory
management, thread management, and remoting and also ensures more security and
robustness. The concept of code management is a fundamental principle of the runtime.
Code that targets the runtime is known as managed code, while code that does not target
the runtime is known as unmanaged code.
THE .NET FRAME WORK CLASS LIBRARY:
It is a comprehensive, object-oriented collection of reusable
types used to develop applications ranging from traditional command-line or graphical
user interface (GUI) applications to applications based on the latest innovations provided
by ASP.NET, such as Web Forms and XML Web services.

The .NET Framework can be hosted by unmanaged components


that load the common language runtime into their processes and initiate the execution of
managed code, thereby creating a software environment that can exploit both managed
and unmanaged features. The .NET Framework not only provides several runtime hosts,
but also supports the development of third-party runtime hosts.

Internet Explorer is an example of an unmanaged application that


hosts the runtime (in the form of a MIME type extension). Using Internet Explorer to host
the runtime to enables embeds managed components or Windows Forms controls in
HTML documents.

FEATURES OF THE COMMON LANGUAGE RUNTIME:

The common language runtime manages memory; thread


execution, code execution, code safety verification, compilation, and other system
services these are all run on CLR.
• Security.
• Robustness.
• Productivity.
• Performance.
SECURITY
The runtime enforces code access security. The security features of
the runtime thus enable legitimate Internet-deployed software to be exceptionally feature
rich. With regards to security, managed components are awarded varying degrees of trust,
depending on a number of factors that include their origin to perform file-access
operations, registry-access operations, or other sensitive functions.

ROBUSTNESS:
The runtime also enforces code robustness by implementing a strict
type- and code-verification infrastructure called the common type system(CTS). The CTS
ensures that all managed code is self-describing. The managed environment of the
runtime eliminates many common software issues.

PRODUCTIVITY:
The runtime also accelerates developer productivity. For example,
programmers can write applications in their development language of choice, yet take full
advantage of the runtime, the class library, and components written in other languages by
other developers.

PERFORMANCE:
The runtime is designed to enhance performance. Although the common
language runtime provides many standard runtime services, managed code is never
interpreted. A feature called just-in-time (JIT) compiling enables all managed code to run
in the native machine language of the system on which it is executing. Finally, the
runtime can be hosted by high-performance, server-side applications, such as Microsoft®
SQL Server™ and Internet Information Services (IIS).
ASP.NET
ASP.NET is the next version of Active Server Pages (ASP); it is a unified
Web development platform that provides the services necessary for developers to build
enterprise-class Web applications. While ASP.NET is largely syntax compatible, it also
provides a new programming model and infrastructure for more secure, scalable, and
stable applications.

ASP.NET is a compiled, NET-based environment, we can author


applications in any .NET compatible language, including Visual Basic .NET, C#, and
JScript .NET. Additionally, the entire .NET Framework is available to any ASP.NET
application. Developers can easily access the benefits of these technologies, which
include the managed common language runtime environment (CLR), type safety,
inheritance, and so on.

ASP.NET has been designed to work seamlessly with WYSIWYG HTML


editors and other programming tools, including Microsoft Visual Studio .NET. Not only
does this make Web development easier, but it also provides all the benefits that these
tools have to offer, including a GUI that developers can use to drop server controls onto a
Web page and fully integrated debugging support.

Developers can choose from the following two features when creating an
ASP.NET application. Web Forms and Web services, or combine these in any way they
see fit. Each is supported by the same infrastructure that allows you to use authentication
schemes, cache frequently used data, or customize your application's configuration, to
name only a few possibilities.

Web Forms allows us to build powerful forms-based Web pages. When


building these pages, we can use ASP.NET server controls to create common UI
elements, and program them for common tasks. These controls allow we to rapidly build
a Web Form out of reusable built-in or custom components, simplifying the code of a
page.

An XML Web service provides the means to access server functionality


remotely. Using Web services, businesses can expose programmatic interfaces to their
data or business logic, which in turn can be obtained and manipulated by client and server
applications. XML Web services enable the exchange of data in client-server or server-
server scenarios, using standards like HTTP and XML messaging to move data across
firewalls. XML Web services are not tied to a particular component technology or object-
calling convention. As a result, programs written in any language, using any component
model, and running on any operating system can access XML Web services

Each of these models can take full advantage of all ASP.NET features,
as well as the power of the .NET Framework and .NET Framework common language
runtime.
Accessing databases from ASP.NET applications is an often-used
technique for displaying data to Web site visitors. ASP.NET makes it easier than ever to
access databases for this purpose. It also allows us to manage the database from your
code .

ASP.NET provides a simple model that enables Web developers to


write logic that runs at the application level. Developers can write this code in the
global.aspx text file or in a compiled class deployed as an assembly. This logic can
include application-level events, but developers can easily extend this model to suit the
needs of their Web application.

ASP.NET provides easy-to-use application and session-state facilities


that are familiar to ASP developers and are readily compatible with all other .NET
Framework APIs.
ASP.NET offers the IHttpHandler and IHttpModule interfaces.
Implementing the IHttpHandler interface gives you a means of interacting with the low-
level request and response services of the IIS Web server and provides functionality
much like ISAPI extensions, but with a simpler programming model. Implementing the
IHttpModule interface allows you to include custom events that participate in every
request made to your application.

ASP.NET takes advantage of performance enhancements found in


the .NET Framework and common language runtime. Additionally, it has been designed
to offer significant performance improvements over ASP and other Web development
platforms. All ASP.NET code is compiled, rather than interpreted, which allows early
binding, strong typing, and just-in-time (JIT) compilation to native code, to name only a
few of its benefits. ASP.NET is also easily factorable, meaning that developers can
remove modules (a session module, for instance) that are not relevant to the application
they are developing.

ASP.NET provides extensive caching services (both built-in services and


caching APIs). ASP.NET also ships with performance counters that developers and
system administrators can monitor to test new applications and gather metrics on existing
applications.

Writing custom debug statements to your Web page can help immensely
in troubleshooting your application's code. However, it can cause embarrassment if it is
not removed. The problem is that removing the debug statements from your pages when
your application is ready to be ported to a production server can require significant effort.

ASP.NET offers the TraceContext class, which allows us to write custom


debug statements to our pages as we develop them. They appear only when you have
enabled tracing for a page or entire application. Enabling tracing also appends details
about a request to the page, or, if you so specify, to a custom trace viewer that is stored in
the root directory of your application.
The .NET Framework and ASP.NET provide default authorization and
authentication schemes for Web applications. we can easily remove, add to, or replace
these schemes, depending upon the needs of our application .

ASP.NET configuration settings are stored in XML-based files, which are


human readable and writable. Each of our applications can have a distinct configuration
file and we can extend the configuration scheme to suit our requirements.

DATA ACCESS WITH ADO.NET

As you develop applications using ADO.NET, you will have different


requirements for working with data. You might never need to directly edit an XML file
containing data - but it is very useful to understand the data architecture in ADO.NET.

ADO.NET offers several advantages over previous versions of ADO:


Interoperability
Maintainability
Programmability
Performance Scalability

INTEROPERABILITY:

ADO.NET applications can take advantage of the flexibility and broad


acceptance of XML. Because XML is the format for transmitting datasets across the
network, any component that can read the XML format can process data. The receiving
component need not be an ADO.NET component.

The transmitting component can simply transmit the dataset to its


destination without regard to how the receiving component is implemented. The
destination component might be a Visual Studio application or any other application
implemented with any tool whatsoever.

The only requirement is that the receiving component be able to read XML.
SO, XML was designed with exactly this kind of interoperability in mind.

MAINTAINABILITY:

In the life of a deployed system, modest changes are possible, but


substantial, Architectural changes are rarely attempted because they are so difficult. As
the performance load on a deployed application server grows, system resources can
become scarce and response time or throughput can suffer. Faced with this problem,
software architects can choose to divide the server's business-logic processing and user-
interface processing onto separate tiers on separate machines.

In effect, the application server tier is replaced with two tiers, alleviating
the shortage of system resources. If the original application is implemented in ADO.NET
using datasets, this transformation is made easier.

ADO.NET data components in Visual Studio encapsulate data access


functionality in various ways that help you program more quickly and with fewer
mistakes.

PERFORMANCE:

ADO.NET datasets offer performance advantages over ADO disconnected


record sets. In ADO.NET data-type conversion is not necessary.

SCALABILITY:
ADO.NET accommodates scalability by encouraging programmers to
conserve limited resources. Any ADO.NET application employs disconnected access to
data; it does not retain database locks or active database connections for long durations.
VISUAL STUDIO .NET

Visual Studio .NET is a complete set of development tools for building


ASP Web applications, XML Web services, desktop applications, and mobile
applications In addition to building high-performing desktop applications, you can use
Visual Studio's powerful component-based development tools and other technologies to
simplify team-based design, development, and deployment of Enterprise solutions.

Visual Basic .NET, Visual C++ .NET, and Visual C# .NET all use the
same integrated development environment (IDE), which allows them to share tools and
facilitates in the creation of mixed-language solutions. In addition, these languages
leverage the functionality of the .NET Framework and simplify the development of ASP
Web applications and XML Web services.

Visual Studio supports the .NET Framework, which provides a common


language runtime and unified programming classes; ASP.NET uses these components to
create ASP Web applications and XML Web services. Also it includes MSDN Library,
which contains all the documentation for these development tools.

XML WEB SERVICES

XML Web services are applications that can receive the requested data
using XML over HTTP. XML Web services are not tied to a particular component
technology or object-calling convention but it can be accessed by any language,
component model, or operating system. In Visual Studio .NET, you can quickly create
and include XML Web services using Visual Basic, Visual C#, JScript, Managed
Extensions for C++, or ATL Server.
XML SUPPORT:
Extensible Markup Language (XML) provides a method for describing
structured data. XML is a subset of SGML that is optimized for delivery over the
Web. The World Wide Web Consortium (W3C) defines XML standards so that
structured data will be uniform and independent of applications. Visual Studio .NET
fully supports XML, providing the XML Designer to make it easier to edit XML and
create XML schemas.

VISUAL BASIC .NET


Visual Basic. NET, the latest version of visual basic, includes many new
features. The Visual Basic supports interfaces but not implementation inheritance.

Visual basic.net supports implementation inheritance, interfaces and


overloading. In addition, Visual Basic .NET supports multithreading concept.

COMMON LANGUAGE SPECIFICATION (CLS):

Visual Basic.NET is also compliant with CLS (Common Language


Specification) and supports structured exception handling. CLS is set of rules and
constructs that are supported by the CLR (Common Language Runtime). CLR is the
runtime environment provided by the .NET Framework; it manages the execution of the
code and also makes the development process easier by providing services.

Visual Basic.NET is a CLS-compliant language. Any objects, classes, or


components that created in Visual Basic.NET can be used in any other CLS-compliant
language. In addition, we can use objects, classes, and components created in other CLS-
compliant languages in Visual Basic.NET .The use of CLS ensures complete
interoperability among applications, regardless of the languages used to create the
application.

IMPLEMENTATION INHERITANCE:

Visual Basic.NET supports implementation inheritance. This means that,


while creating applications in Visual Basic.NET, we can drive from another class, which
is know as the base class that derived class inherits all the methods and properties of the
base class. In the derived class, we can either use the existing code of the base class or
override the existing code. Therefore, with help of the implementation inheritance, code
can be reused.

CONSTRUCTORS AND DESTRUCTORS:

Constructors are used to initialize objects, whereas destructors are used to


destroy them. In other words, destructors are used to release the resources allocated to the
object. In Visual Basic.NET the sub finalize procedure is available. The sub finalize
procedure is used to complete the tasks that must be performed when an object is
destroyed. The sub finalize procedure is called automatically when an object is destroyed.
In addition, the sub finalize procedure can be called only from the class it belongs to or
from derived classes.

GARBAGE COLLECTION:

Garbage Collection is another new feature in Visual Basic.NET. The .NET


Framework monitors allocated resources, such as objects and variables. In addition,
the .NET Framework automatically releases memory for reuse by destroying objects that
are no longer in use. In Visual Basic.NET, the garbage collector checks for the objects
that are not currently in use by applications. When the garbage collector comes across an
object that is marked for garbage collection, it releases the memory occupied by the
object.

OVERLOADING:

Overloading is another feature in Visual Basic.NET. Overloading enables


us to define multiple procedures with the same name, where each procedure has a
different set of arguments. Besides using overloading for procedures, we can use it for
constructors and properties in a class.

MULTITHREADING:

Visual Basic.NET also supports multithreading. An application that


supports multithreading can handle multiple tasks simultaneously, we can use
multithreading to decrease the time taken by an application to respond to user interaction.
To decrease the time taken by an application to respond to user interaction, we must
ensure that a separate thread in the application handles user interaction.

STRUCTURED EXCEPTION HANDLING:

Visual Basic.NET supports structured handling, which enables us to detect


and remove errors at runtime. In Visual Basic.NET, we need to use Try…Catch…Finally
statements to create exception handlers. Using Try…Catch…Finally statements, we can
create robust and effective exception handlers to improve the performance of our
application.

4.2 FEATURES OF SQL-SERVER


The OLAP Services feature available in SQL Server version 7.0 is now
called SQL Server 2000 Analysis Services. The term OLAP Services has been replaced
with the term Analysis Services. Analysis Services also includes a new data mining
component. The Repository component available in SQL Server version 7.0 is now called
Microsoft SQL Server 2000 Meta Data Services. References to the component now use
the term Meta Data Services. The term repository is used only in reference to the
repository engine within Meta Data Services
SQL-SERVER database consist of six type of objects,
They are,
1. TABLE
2. QUERY
3. FORM
4. REPORT
5. MACRO
TABLE:
A database is a collection of data about a specific topic.
VIEWS OF TABLE:
We can work with a table in two types,
1. Design View
2. Datasheet View
Design View
To build or modify the structure of a table we work in the table
design view. We can specify what kind of data will be hold.
Datasheet View
To add, edit or analyses the data itself we work in tables datasheet
view mode.

QUERY:
A query is a question that has to be asked the data. Access gathers
data that answers the question from one or more table. The data that make up the answer
is either dynaset (if you edit it) or a snapshot(it cannot be edited).Each time we run query,
we get latest information in the dynaset.Access either displays the dynaset or snapshot for
us to view or perform an action on it ,such as deleting or updating.
FORMS:
A form is used to view and edit information in the database record
by record .A form displays only the information we want to see in the way we want to see
it. Forms use the familiar controls such as textboxes and checkboxes. This makes viewing
and entering data easy.

Views of Form:
We can work with forms in several primarily there are two views,
They are,
1. Design View
2. Form View
Design View
To build or modify the structure of a form, we work in forms design
view. We can add control to the form that are bound to fields in a table or query, includes
textboxes, option buttons, graphs and pictures.
Form View
The form view which display the whole design of the form.
REPORT:
A report is used to vies and print information from the database. The
report can ground records into many levels and compute totals and average by checking
values from many records at once. Also the report is attractive and distinctive because we
have control over the size and appearance of it.
MACRO:
A macro is a set of actions. Each action in macros does something. Such
as opening a form or printing a report .We write macros to automate the common tasks
the work easy and save the time.
MODULE:
Modules are units of code written in access basic language. We can
write and use module to automate and customize the database in very sophisticated ways.
5. SYSTEM DESIGN

Design is multi-step process that focuses on data structure software architecture,


procedural details, (algorithms etc.) and interface between modules. The design process
also translates the requirements into the presentation of software that can be accessed for
quality before coding begins.

Computer software design changes continuously as new methods; better analysis


and broader understanding evolved. Software Design is at relatively early stage in its
revolution.

Therefore, Software Design methodology lacks the depth, flexibility and


quantitative nature that are normally associated with more classical engineering
disciplines. However techniques for software designs do exist, criteria for design qualities
are available and design notation can be applied.

5.1 INPUT DESIGN

Input design is the process of converting user-originated inputs to a computer-


based format. Input design is one of the most expensive phases of the operation of
computerized system and is often the major problem of a system.
In the project, the input design is made in various window forms with
various methods.
• Member Details
• Distributed Database Management
• Tracking Details
• Path Details
• Call Details

5.2 OUTPUT DESIGN

Output design generally refers to the results and information that are
generated by the system for many end-users; output is the main reason for developing the
system and the basis on which they evaluate the usefulness of the application. In any
system, the output design determines the input to be given to the application.

5.3 DATABASE DESIGN

The database design is a must for any application developed


especially more for the data store projects. Since the chatting method involves storing the
message in the table and produced to the sender and receiver, proper handling of the table
is a must.
In the project, admin table is designed to be unique in accepting the username and
the length of the username and password should be greater than zero.
5.4 Data Flow Diagram:

Level-0:

Server

Start Server

ServerInterface
Inter
Admin Login
Premium ViewDB1 Detail

ViewDB2 Detail

ViewMemberDetail

Call List Details

LocationRegistration
Details

View
Tracking
Info
Level-I:

Connect
Client Server

Member Register

Calling

New DB1

New DB2

Level II:

Distributed
Database Track Mobile
PTN Users Location

DB0,DB1,DB2

Output in
Google Map
6. SYSTEM TESTING AND MAINTENANCE

6.1 UNIT TESTING:

The procedure level testing is made first. By giving improper inputs, the
errors occurred are noted and eliminated. Then the web form level testing is made. For
example storage of data to the table in the correct manner.

In the company as well as seeker registration form, the zero length username and
password are given and checked. Also the duplicate username is given and checked. In
the job and question entry, the button will send data to the server only if the client side
validations are made.

The dates are entered in wrong manner and checked. Wrong email-id and
web site URL (Universal Resource Locator) is given and checked.

6.2 INTEGRATION TESTING:

Testing is done for each module. After testing all the modules, the modules are
integrated and testing of the final system is done with the test data, specially designed to
show that the system will operate successfully in all its aspects conditions. Thus the
system testing is a confirmation that all is correct and an opportunity to show the user that
the system works.
6.3 VALIDATION TESTING:

The final step involves Validation testing, which determines whether the software
function as the user expected. The end-user rather than the system developer conduct this
test most software developers as a process called “Alpha and Beta Testing” to uncover
that only the end user seems able to find.

The compilation of the entire project is based on the full


satisfaction of the end users. In the project, validation testing is made in various forms. In
question entry form, the correct answer only will be accepted in the answer box. The
answers other than the four given choices will not be accepted.

MAINTENANCE:

The objectives of this maintenance work are to make sure that the system
gets into work all time without any bug. Provision must be for environmental changes
which may affect the computer or software system. This is called the maintenance of the
system. Nowadays there is the rapid change in the software world. Due to this rapid
change, the system should be capable of adapting these changes. In our project the
process can be added without affecting other parts of the system.

Maintenance plays a vital role. The system liable to accept any


modification after its implementation. This system has been designed to favour all new
changes. Doing this will not affect the system’s performance or its accuracy.

In the project system testing is made as follows:

The procedure level testing is made first. By giving improper inputs, the
errors occurred are noted and eliminated. Then the web form level testing is made. For
example storage of data to the table in the correct manner.
In the form, the zero length username and password are given and
checked. Also the duplicate username is given and checked. The client side validations
are made.

The dates are entered in wrong manner and checked. Wrong email-id is
given and checked.

This is the final step in system life cycle. Here we implement the tested
error-free system into real-life environment and make necessary changes, which runs in
an online fashion. Here system maintenance is done every months or year based on
company policies, and is checked for errors like runtime errors, long run errors and other
maintenances like table verification and reports.

Implementation is the stage of the project when the theoretical design is


turned out into a working system. Thus it can be considered to be the most critical stage
in achieving a successful new system and in giving the user, confidence that the new
system will work and be effective.

The implementation stage involves careful planning, investigation of the


existing system and it’s constraints on implementation, designing of methods to achieve
changeover and evaluation of changeover methods.

Implementation is the process of converting a new system design into


operation. It is the phase that focuses on user training, site preparation and file conversion
for installing a candidate system. The important factor that should be considered here is
that the conversion should not disrupt the functioning of the organization.

The application is implemented in the Internet Information Services 5.0


web server under the Windows 2000 Professional and accessed from various clients.
7. SYSTEM IMPLEMENTATION

Implementation is the most crucial stage in achieving a successful


system and giving the user’s confidence that the new system is workable and effective.
Implementation of a modified application to replace an existing one. This type of
conversation is relatively easy to handle, provide there are no major changes in the
system.
Each program is tested individually at the time of development using
the data and has verified that this program linked together in the way specified in the
programs specification, the computer system and its environment is tested to the
satisfaction of the user. The system that has been developed is accepted and proved to be
satisfactory for the user. And so the system is going to be implemented very soon. A
simple operating procedure is included so that the user can understand the different
functions clearly and quickly.
Initially as a first step the executable form of the application is to be
created and loaded in the common server machine which is accessible to all the user and
the server is to be connected to a network. The final stage is to document the entire
system which provides components and the operating procedures of the system.

7.1 SCOPE FOR FUTURE DEVELOPMENT

Every application has its own merits and demerits. The project has covered
almost all the requirements. Further requirements and improvements can easily be done
since the coding is mainly structured or modular in nature. Changing the existing
modules or adding new modules can append improvements. Further enhancements can be
made to the application, so that the web site functions very attractive and useful manner
than the present one.

8. CONCLUSION

It is concluded that the application works well and satisfy the users. The
application is tested very well and errors are properly debugged. The site is
simultaneously accessed from more than one system. Simultaneous login from more than
one place is tested.

The site works according to the restrictions provided in their respective


browsers. Further enhancements can be made to the application, so that the web site
functions very attractive and useful manner than the present one. The speed of the
transactions become more enough now.
9. BIBLIOGRAPHY

 I.F. AKYILDIZ, W. SU, Y. SANKARASUBRAMANIAM, AND E. CAYIRCI,


“A SURVEY ON SENSOR NETWORKS,” IEEE COMM.
MAGAZINE, PP. 102-114, AUG. 2002.

 M.S. ARULAMPALAM, S. MASKELL, N. GORDON, AND T. CLAPP, “A


TUTORIAL ON PARTICLE FILTERS FOR ONLINE NONLINEAR/NON-
GAUSSIAN BAYESIAN TRACKING,” IEEE TRANS. SIGNAL
PROCESSING, VOL. 50, PP. 174-188, 2002.

 F. BAKER, “AN OUTSIDER’S VIEW OF MANET,” IETF INTERNET


DRAFT, WORK IN PROGRESS, JUNE 2006.

 Y. BAR-SHALOM, MULTITARGET/MULTISENSOR TRACKING:


APPLICATIONS AND ADVANCES-VOLUME III. ARTECH HOUSE, 2000.

 D. BRAGINSKY AND D. ESTRIN, “RUMOR ROUTING FOR SENSOR


NETWORKS,” PROC. ACM INT’L WORKSHOP WIRELESS SENSOR
NETWORKS AND APPLICATIONS, PP. 22-31, 2002.
APPENDIX
SCREEN SHOTS
Server:
Client:
Table Design:

Members Table:

DB2 Table:

DB1 Table:
Sample coding:

Server Module:

Imports System.Runtime.Remoting.Messaging
Imports System.Net
Imports System.Runtime.Remoting
Imports System.Runtime.Remoting.Channels
Imports System.Runtime.Remoting.Channels.tcp
Imports System.Data.SqlClient

Module ServerModule
Public server As ServerInterface.ServerInterface

Public dbpath As String = System.Windows.Forms.Application.StartupPath


Public connection As New
SqlConnection("Server=.;Database=keyagrement;UID=sa;Pwd=;")

Public Sub Serverstart()


Try
Dim ServiceChannel As IChannel
Dim serverProv As BinaryServerFormatterSinkProvider = New
BinaryServerFormatterSinkProvider
Dim clientProv As BinaryClientFormatterSinkProvider = New
BinaryClientFormatterSinkProvider
Dim Props As IDictionary = New Hashtable
Dim IpInjProvider As New IpInjectorSinkProvider
serverProv.TypeFilterLevel =
System.Runtime.Serialization.Formatters.TypeFilterLevel.Full
Props("port") = "8000"
Props("name") = "Server"
serverProv.Next = IpInjProvider

ServiceChannel = New TcpChannel(Props, clientProv, serverProv)


'---------------------------------------------

ChannelServices.RegisterChannel(ServiceChannel)

RemotingConfiguration.RegisterWellKnownServiceType( _
GetType(ServerImplementaion.ServerImplementation), _
"Server", WellKnownObjectMode.Singleton)

Dim wkemtries() As WellKnownServiceTypeEntry


Dim entry As WellKnownServiceTypeEntry

wkemtries =
RemotingConfiguration.GetRegisteredWellKnownServiceTypes

For Each entry In wkemtries

Next

Dim channels() As IChannel


Dim chn As IChannel
channels = ChannelServices.RegisteredChannels
Init()

Catch ex As Exception

End Try

End Sub

Private Sub Init()

Dim Channel1 As System.Runtime.Remoting.Channels.tcp.TcpChannel

Dim serverProv As BinaryServerFormatterSinkProvider = New


BinaryServerFormatterSinkProvider
Dim clientProv As BinaryClientFormatterSinkProvider = New
BinaryClientFormatterSinkProvider
Dim Props As IDictionary = New Hashtable
serverProv.TypeFilterLevel =
System.Runtime.Serialization.Formatters.TypeFilterLevel.Full

Props("port") = 0

Channel1 = New
System.Runtime.Remoting.Channels.tcp.TcpChannel(Props, clientProv, serverProv)
ChannelServices.RegisterChannel(Channel1)

Try
server =
CType(Activator.GetObject(GetType(ServerInterface.ServerInterface), "tcp://" &
servername & ":8000/Server"), ServerInterface.ServerInterface)

If server Is Nothing Then

End If
Catch ex As Exception
Debug.WriteLine(ex.Message)
End Try

End Sub
Public Function GetClientIP() As String
Dim ContextIP As IPAddress = CallContext.GetData("ClientIP") 'this value
was injected by my sinks.
Return ContextIP.ToString
End Function
Public Function insert1(ByVal str As String) As Integer
Try
Dim cmd As New SqlCommand
If connection.State = ConnectionState.Closed Then
connection.Open()
End If
cmd.Connection = connection
cmd.CommandType = CommandType.Text
cmd.CommandText = str
Dim returnvalue As Integer = -1
returnvalue = cmd.ExecuteNonQuery()
If connection.State = ConnectionState.Open Then
connection.Close()
End If

Catch e1 As Exception
MsgBox(e1.ToString())
End Try

End Function
'Public Function getvalue(ByVal str As String) As Integer
' Try
' Dim cmd As New SqlCommand

' If connection.State = ConnectionState.Closed Then


' connection.Open()
' End If
' cmd.Connection = connection
' cmd.CommandType = CommandType.Text
' cmd.CommandText = str
' Dim obj As Object = ""
' obj = cmd.ExecuteScalar()
' If connection.State = ConnectionState.Open Then
' connection.Close()
' End If

' If IsDBNull(obj) Then


' Return 1
' Else
' Return Convert.ToInt32(obj)
' End If
' Catch e1 As Exception
' MsgBox(e1.ToString())
' End Try
'End Function

'Public Function deleteuser(ByVal table As String)


' Dim cmd As New SqlCommand

' If connection.State = ConnectionState.Closed Then


' connection.Open()
' End If
' cmd.Connection = connection
' cmd.CommandType = CommandType.Text
' cmd.CommandText = "delete from " & table & ""
' cmd.ExecuteNonQuery()
' If connection.State = ConnectionState.Open Then

' If connection.State = ConnectionState.Open Then


' connection.Close()
' End If

' End If

'End Function
'Public Function autonumber(ByVal id As String, ByVal table As String) As
Integer

' Dim str As String


' str = " select max(" & id & ") from " & table & ""
' Try
' Dim cmd As New SqlCommand

' If connection.State = ConnectionState.Closed Then


' connection.Open()
' End If

' cmd.Connection = connection


' cmd.CommandType = CommandType.Text
' cmd.CommandText = str
' Dim obj As Object = 0
' obj = cmd.ExecuteScalar()
' If connection.State = ConnectionState.Open Then
' connection.Close()
' End If

' If IsDBNull(obj) Then


' Return 0
' Else
' Return (Convert.ToInt32(obj) + 1)
' End If
' Catch e1 As Exception
' MsgBox(e1.ToString())
' End Try
'End Function
'Public Function selectid(ByVal uname As String) As Integer
' Dim str As String
' str = " select uid from userdb where username='" & uname & "'"
' Try
' Dim cmd As New SqlCommand
' If connection.State = ConnectionState.Closed Then
' connection.Open()
' End If
' cmd.Connection = connection
' cmd.CommandType = CommandType.Text
' cmd.CommandText = str
' Dim obj As Object = 0
' obj = cmd.ExecuteScalar()
' If connection.State = ConnectionState.Open Then
' connection.Close()
' End If
' If IsDBNull(obj) Then

' Return 1
' Else
' Return Convert.ToInt32(obj)
' End If
' Catch e1 As Exception
' MsgBox(e1.ToString())
' End Try

'End Function
'Public Function load(ByVal table As String) As DataTable
' Dim cmdtxt As String = "select * from " & table & ""
' Dim cmd As New SqlCommand
' Dim da As New SqlDataAdapter
' Dim dt As New DataTable
' Try
' If connection.State = ConnectionState.Closed Then
' connection.Open()
' End If
' cmd.Connection = connection
' cmd.CommandType = CommandType.Text
' cmd.CommandText = cmdtxt
' da.SelectCommand = cmd
' da.Fill(dt)
' If connection.State = ConnectionState.Open Then
' connection.Close()
' End If

' Catch e1 As Exception


' MsgBox(e1.ToString())
' End Try
' Return dt

'End Function
'Public Function readdb() As String()
' Dim str(50) As String
' Dim cmd As New SqlCommand
' Dim cmd1 As New SqlCommand
' If connection.State = ConnectionState.Closed Then
' connection.Open()
' End If
' cmd.Connection = connection
' cmd.CommandType = CommandType.Text
' cmd.CommandText = "select * from userdb"

' Dim obj, obj1 As SqlDataReader


' Dim i As Integer = 0
' Dim count As Integer = 0
' obj = cmd.ExecuteReader()
' While obj.Read
' count = count + 1
' End While
' If connection.State = ConnectionState.Open Then
' connection.Close()
' End If

' If connection.State = ConnectionState.Closed Then


' connection.Open()
' End If
' cmd1.Connection = connection
' cmd1.CommandType = CommandType.Text
' cmd1.CommandText = "select * from userdb"
' str(0) = Convert.ToString(count)
' obj1 = cmd1.ExecuteReader()
' While obj1.Read
' i=i+1
' str(i) = obj1(0)
' str(i + count) = obj1(1)
' str(i + (count * 2)) = obj1(2)
' str(i + (count * 3)) = obj1(3)
' End While
' If connection.State = ConnectionState.Open Then
' connection.Close()
' End If
' Return str
'End Function
'Public Function countfield(ByVal value As String, ByVal table As String,
ByVal conditionfield As String) As Integer()
' Dim v1(50) As Integer
' Dim v2(50) As Integer
' Dim v3(50) As Integer
' Dim qry As String
' Dim cnt As Integer = 0
' qry = " select nodeid,lid,rid from " & table & " where " & conditionfield &
" = " & value & " "
' Try
' Dim cmd As New SqlCommand

' If connection.State = ConnectionState.Closed Then


' connection.Open()
' End If
' cmd.Connection = connection
' cmd.CommandType = CommandType.Text
' cmd.CommandText = qry
' Dim reader As SqlDataReader
' reader = cmd.ExecuteReader
' While reader.Read
' cnt = cnt + 1
' v1(cnt) = reader(0)
' v2(cnt) = reader(1)
' v3(cnt) = reader(2)
' End While
' v1(0) = cnt
' Dim ij As Integer
' For ij = 1 To cnt
' v1(cnt + ij) = v2(ij)
' v1((cnt * 2) + ij) = v3(ij)
' Next
' If connection.State = ConnectionState.Open Then
' connection.Close()
' End If
' Return v1
' Catch e1 As Exception
' MsgBox(e1.ToString)
' End Try
'End Function
'Public Function selectid1(ByVal uid As String) As Integer
' Dim str As String
' str = " select pkey from userdb1 where uid=" & uid & ""
' Try
' Dim cmd As New SqlCommand
' If connection.State = ConnectionState.Closed Then
' connection.Open()
' End If
' cmd.Connection = connection
' cmd.CommandType = CommandType.Text
' cmd.CommandText = str
' Dim obj As Object = 0
' obj = cmd.ExecuteScalar()
' If connection.State = ConnectionState.Open Then
' connection.Close()
' End If
' If IsDBNull(obj) Then
' Return 0
' Else
' Return Convert.ToInt32(obj)
' End If
' Catch e1 As Exception
' MsgBox(e1.ToString())
' End Try

'End Function
'Public Function readdb1() As String()
' Dim str(50) As String
' Dim cmd As New SqlCommand
' Dim cmd1 As New SqlCommand
' If connection.State = ConnectionState.Closed Then
' connection.Open()
' End If

' cmd.Connection = connection


' cmd.CommandType = CommandType.Text
' cmd.CommandText = "select * from userdb"

' Dim obj, obj1 As SqlDataReader


' Dim i As Integer = 0
' Dim count As Integer = 0
' obj = cmd.ExecuteReader()
' While obj.Read
' count = count + 1
' End While
' If connection.State = ConnectionState.Open Then
' connection.Close()
' End If
' If connection.State = ConnectionState.Closed Then
' connection.Open()
' End If

' cmd1.Connection = connection


' cmd1.CommandType = CommandType.Text
' cmd1.CommandText = "select * from userdb"
' str(0) = Convert.ToString(count)
' obj1 = cmd1.ExecuteReader()
' While obj1.Read
' i=i+1
' str(i) = obj1(0)
' str(i + count) = obj1(1)
' str(i + (count * 2)) = obj1(2)
' str(i + (count * 3)) = obj1(3)
' End While
' If connection.State = ConnectionState.Open Then
' connection.Close()
' End If
' Return str
'End Function
'Public Function readstring(ByVal q As String) As String()
' Dim str(50) As String
' Dim cmd As New SqlCommand
' Dim obj As SqlDataReader
' Dim i As Integer = 0
' Dim count As Integer = 0
' If connection.State = ConnectionState.Closed Then
' connection.Open()
' End If
' cmd.Connection = connection
' cmd.CommandType = CommandType.Text
' cmd.CommandText = q
' obj = cmd.ExecuteReader()
' While obj.Read
' i=i+1
' str(i) = obj(0)
' End While
' str(0) = Convert.ToString(i)
' If connection.State = ConnectionState.Open Then
' connection.Close()
' End If
' Return str
'End Function
End Module

Client Module:

Imports System.Runtime.Remoting
Imports System.Runtime.Remoting.Channels.Tcp
Imports System.Runtime.Remoting.Channels
Module ClientModule
Public server As ServerInterface.ServerInterface
Private Channel3 As System.Runtime.Remoting.Channels.tcp.TcpChannel
'New System.Runtime.Remoting.Channels.tcp.TcpChannel(0)
Private serverProv As BinaryServerFormatterSinkProvider
Private clientProv As BinaryClientFormatterSinkProvider
Private props As IDictionary = New Hashtable
Private Sub SetChannel()
serverProv = New BinaryServerFormatterSinkProvider
clientProv = New BinaryClientFormatterSinkProvider
serverProv.TypeFilterLevel =
System.Runtime.Serialization.Formatters.TypeFilterLevel.Full
props("port") = 0
Channel3 = New TcpChannel(props, clientProv, serverProv)
End Sub
Public Sub Init()
flag = True
SetChannel()
Try
server =
CType(Activator.GetObject(GetType(ServerInterface.ServerInterface), "tcp://" &
servername & ":8000/Server"), ServerInterface.ServerInterface)
If server Is Nothing Then
MsgBox("Server Error")
End If
Catch ex As Exception
MsgBox(ex.ToString)
End Try
End Sub
Public Sub dispose()
ChannelServices.UnregisterChannel(Channel3)
server = Nothing
Channel3 = Nothing
serverProv = Nothing
clientProv = Nothing
End Sub
End Module

Client: New Member

Public Class NewMember


Inherits System.Windows.Forms.Form

#Region " Windows Form Designer generated code "

Public Sub New()


MyBase.New()

'This call is required by the Windows Form Designer.


InitializeComponent()
'Add any initialization after the InitializeComponent() call

End Sub

'Form overrides dispose to clean up the component list.


Protected Overloads Overrides Sub Dispose(ByVal disposing As Boolean)
If disposing Then
If Not (components Is Nothing) Then
components.Dispose()
End If
End If
MyBase.Dispose(disposing)
End Sub

'Required by the Windows Form Designer


Private components As System.ComponentModel.IContainer

'NOTE: The following procedure is required by the Windows Form Designer


'It can be modified using the Windows Form Designer.
'Do not modify it using the code editor.
Friend WithEvents Label1 As System.Windows.Forms.Label
Friend WithEvents Label2 As System.Windows.Forms.Label
Friend WithEvents Label3 As System.Windows.Forms.Label
Friend WithEvents Label4 As System.Windows.Forms.Label
Friend WithEvents Label5 As System.Windows.Forms.Label
Friend WithEvents Label6 As System.Windows.Forms.Label
Friend WithEvents Label7 As System.Windows.Forms.Label
Friend WithEvents Button1 As System.Windows.Forms.Button
Friend WithEvents TextBox1 As System.Windows.Forms.TextBox
Friend WithEvents TextBox2 As System.Windows.Forms.TextBox
Friend WithEvents TextBox3 As System.Windows.Forms.TextBox
Friend WithEvents TextBox4 As System.Windows.Forms.TextBox
Friend WithEvents TextBox5 As System.Windows.Forms.TextBox
Friend WithEvents TextBox6 As System.Windows.Forms.TextBox
Friend WithEvents TextBox7 As System.Windows.Forms.TextBox
Friend WithEvents Label8 As System.Windows.Forms.Label
Friend WithEvents Label9 As System.Windows.Forms.Label
Friend WithEvents Label10 As System.Windows.Forms.Label
Friend WithEvents TextBox8 As System.Windows.Forms.TextBox
Friend WithEvents ComboBox1 As System.Windows.Forms.ComboBox
Friend WithEvents ComboBox2 As System.Windows.Forms.ComboBox
Friend WithEvents SqlConnection1 As System.Data.SqlClient.SqlConnection
<System.Diagnostics.DebuggerStepThrough()> Private Sub
InitializeComponent()
Me.Label1 = New System.Windows.Forms.Label
Me.Label2 = New System.Windows.Forms.Label
Me.Label3 = New System.Windows.Forms.Label
Me.Label4 = New System.Windows.Forms.Label
Me.Label5 = New System.Windows.Forms.Label
Me.Label6 = New System.Windows.Forms.Label
Me.Label7 = New System.Windows.Forms.Label
Me.Button1 = New System.Windows.Forms.Button
Me.TextBox1 = New System.Windows.Forms.TextBox
Me.TextBox2 = New System.Windows.Forms.TextBox
Me.TextBox3 = New System.Windows.Forms.TextBox
Me.TextBox4 = New System.Windows.Forms.TextBox
Me.TextBox5 = New System.Windows.Forms.TextBox
Me.TextBox6 = New System.Windows.Forms.TextBox
Me.TextBox7 = New System.Windows.Forms.TextBox
Me.Label8 = New System.Windows.Forms.Label
Me.Label9 = New System.Windows.Forms.Label
Me.Label10 = New System.Windows.Forms.Label
Me.TextBox8 = New System.Windows.Forms.TextBox
Me.ComboBox1 = New System.Windows.Forms.ComboBox
Me.ComboBox2 = New System.Windows.Forms.ComboBox
Me.SqlConnection1 = New System.Data.SqlClient.SqlConnection
Me.SuspendLayout()
'
'Label1
'
Me.Label1.ForeColor = System.Drawing.Color.Maroon
Me.Label1.Location = New System.Drawing.Point(40, 72)
Me.Label1.Name = "Label1"
Me.Label1.TabIndex = 0
Me.Label1.Text = "Name"
'
'Label2
'
Me.Label2.ForeColor = System.Drawing.Color.Maroon
Me.Label2.Location = New System.Drawing.Point(40, 112)
Me.Label2.Name = "Label2"
Me.Label2.TabIndex = 1
Me.Label2.Text = "Address"
'
'Label3
'
Me.Label3.ForeColor = System.Drawing.Color.Maroon
Me.Label3.Location = New System.Drawing.Point(40, 32)
Me.Label3.Name = "Label3"
Me.Label3.TabIndex = 2
Me.Label3.Text = "PTN"
'
'Label4
'
Me.Label4.ForeColor = System.Drawing.Color.Maroon
Me.Label4.Location = New System.Drawing.Point(40, 224)
Me.Label4.Name = "Label4"
Me.Label4.TabIndex = 3
Me.Label4.Text = "Pin"
'
'Label5
'
Me.Label5.ForeColor = System.Drawing.Color.Maroon
Me.Label5.Location = New System.Drawing.Point(40, 256)
Me.Label5.Name = "Label5"
Me.Label5.TabIndex = 4
Me.Label5.Text = "Email"
'
'Label6
'
Me.Label6.ForeColor = System.Drawing.Color.Maroon
Me.Label6.Location = New System.Drawing.Point(40, 152)
Me.Label6.Name = "Label6"
Me.Label6.TabIndex = 5
Me.Label6.Text = "City"
'
'Label7
'
Me.Label7.ForeColor = System.Drawing.Color.Maroon
Me.Label7.Location = New System.Drawing.Point(40, 192)
Me.Label7.Name = "Label7"
Me.Label7.TabIndex = 6
Me.Label7.Text = "Country"
'
'Button1
'
Me.Button1.BackColor = System.Drawing.SystemColors.Desktop
Me.Button1.Font = New System.Drawing.Font("Microsoft Sans Serif",
8.25!, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, CType(0,
Byte))
Me.Button1.ForeColor = System.Drawing.SystemColors.ActiveCaptionText
Me.Button1.Location = New System.Drawing.Point(96, 400)
Me.Button1.Name = "Button1"
Me.Button1.Size = New System.Drawing.Size(96, 32)
Me.Button1.TabIndex = 7
Me.Button1.Text = "Submit"
'
'TextBox1
'
Me.TextBox1.Location = New System.Drawing.Point(160, 32)
Me.TextBox1.Name = "TextBox1"
Me.TextBox1.TabIndex = 8
Me.TextBox1.Text = ""
'
'TextBox2
'
Me.TextBox2.Location = New System.Drawing.Point(160, 72)
Me.TextBox2.Name = "TextBox2"
Me.TextBox2.TabIndex = 9
Me.TextBox2.Text = ""
'
'TextBox3
'
Me.TextBox3.Location = New System.Drawing.Point(160, 120)
Me.TextBox3.Name = "TextBox3"
Me.TextBox3.TabIndex = 10
Me.TextBox3.Text = ""
'
'TextBox4
'
Me.TextBox4.Location = New System.Drawing.Point(160, 152)
Me.TextBox4.Name = "TextBox4"
Me.TextBox4.TabIndex = 11
Me.TextBox4.Text = ""
'
'TextBox5
'
Me.TextBox5.Location = New System.Drawing.Point(160, 192)
Me.TextBox5.Name = "TextBox5"
Me.TextBox5.TabIndex = 12
Me.TextBox5.Text = ""
'
'TextBox6
'
Me.TextBox6.Location = New System.Drawing.Point(160, 224)
Me.TextBox6.Name = "TextBox6"
Me.TextBox6.TabIndex = 13
Me.TextBox6.Text = ""
'
'TextBox7
'
Me.TextBox7.Location = New System.Drawing.Point(160, 256)
Me.TextBox7.Name = "TextBox7"
Me.TextBox7.TabIndex = 14
Me.TextBox7.Text = ""
'
'Label8
'
Me.Label8.ForeColor = System.Drawing.Color.Maroon
Me.Label8.Location = New System.Drawing.Point(40, 296)
Me.Label8.Name = "Label8"
Me.Label8.Size = New System.Drawing.Size(80, 24)
Me.Label8.TabIndex = 15
Me.Label8.Text = "DB1Add"
'
'Label9
'
Me.Label9.ForeColor = System.Drawing.Color.Maroon
Me.Label9.Location = New System.Drawing.Point(40, 328)
Me.Label9.Name = "Label9"
Me.Label9.Size = New System.Drawing.Size(88, 24)
Me.Label9.TabIndex = 16
Me.Label9.Text = "DB2Add"
'
'Label10
'
Me.Label10.ForeColor = System.Drawing.Color.Maroon
Me.Label10.Location = New System.Drawing.Point(40, 360)
Me.Label10.Name = "Label10"
Me.Label10.Size = New System.Drawing.Size(88, 24)
Me.Label10.TabIndex = 17
Me.Label10.Text = "Hname"
'
'TextBox8
'
Me.TextBox8.Location = New System.Drawing.Point(160, 360)
Me.TextBox8.Name = "TextBox8"
Me.TextBox8.Size = New System.Drawing.Size(104, 20)
Me.TextBox8.TabIndex = 18
Me.TextBox8.Text = ""
'
'ComboBox1
'
Me.ComboBox1.Location = New System.Drawing.Point(160, 288)
Me.ComboBox1.Name = "ComboBox1"
Me.ComboBox1.Size = New System.Drawing.Size(96, 21)
Me.ComboBox1.TabIndex = 19
'
'ComboBox2
'
Me.ComboBox2.Location = New System.Drawing.Point(160, 320)
Me.ComboBox2.Name = "ComboBox2"
Me.ComboBox2.Size = New System.Drawing.Size(96, 21)
Me.ComboBox2.TabIndex = 20
'
'SqlConnection1
'
Me.SqlConnection1.ConnectionString = "workstation id=PHOENIX6;packet
size=4096;integrated security=SSPI;data source=PHO" & _
"ENIX6;persist security info=False;initial catalog=TR_C"
'
'NewMember
'
Me.AutoScaleBaseSize = New System.Drawing.Size(5, 13)
Me.BackColor = System.Drawing.SystemColors.InactiveCaption
Me.ClientSize = New System.Drawing.Size(296, 446)
Me.Controls.Add(Me.ComboBox2)
Me.Controls.Add(Me.ComboBox1)
Me.Controls.Add(Me.TextBox8)
Me.Controls.Add(Me.Label10)
Me.Controls.Add(Me.Label9)
Me.Controls.Add(Me.Label8)
Me.Controls.Add(Me.TextBox7)
Me.Controls.Add(Me.TextBox6)
Me.Controls.Add(Me.TextBox5)
Me.Controls.Add(Me.TextBox4)
Me.Controls.Add(Me.TextBox3)
Me.Controls.Add(Me.TextBox2)
Me.Controls.Add(Me.TextBox1)
Me.Controls.Add(Me.Button1)
Me.Controls.Add(Me.Label7)
Me.Controls.Add(Me.Label6)
Me.Controls.Add(Me.Label5)
Me.Controls.Add(Me.Label4)
Me.Controls.Add(Me.Label3)
Me.Controls.Add(Me.Label2)
Me.Controls.Add(Me.Label1)
Me.Name = "NewMember"
Me.Text = "Member Registration"
Me.ResumeLayout(False)

End Sub

#End Region
Private Sub NewMember_Load(ByVal sender As System.Object, ByVal e As
System.EventArgs) Handles MyBase.Load
TextBox8.Text = Environment.MachineName

End Sub

Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As


System.EventArgs) Handles Button1.Click
ptn = TextBox1.Text
Nam = TextBox2.Text
Addr = TextBox3.Text
city = TextBox4.Text
cntry = TextBox5.Text
pin = TextBox6.Text
email = TextBox7.Text
db2add = ComboBox1.Text
db1add = ComboBox2.Text
cname = Environment.MachineName
Me.DialogResult = DialogResult.OK
End Sub
End Class