final report (parking project).pdf

College of Engineering
Department of Electrical Engineering
Fall 2012-2013
Learning Outcome Assessment III/EE
EEEN 4311/Section 106
Course Instructor
Dr. Samir Elnakla
Final Product Report
Parking Monitoring Control System
Group:
Ali Al Misbah #200600302
Muneer Al-Hashim #200600086
Salman Al-Belaihi #200801405
Mustafa Al-Qurain #200800565

of 148
Abstract
Not finding a parking space for you sometimes is indeed a critical issue. An
important appointment might be missed. Time will be wasted and more money will be
spent. Criticism and inconvenience are more likely to happen. So, parking monitoring
is an important solution. It has many practical advantages. It can arrange the passage
of vehicles inside the parking area in addition to avoiding contention. It can reduce
the suffering of sick and disabled people looking for a parking space. It is a good
denote to such part of the society. It is like providing them with the smile and hope
that helps them to overcome their disability. This project can provide information
about the future need to make more parking spaces, also has many uses such as
security issues and data base.The project consists of four mainsubsystems, the first
subsystem is designing the power supply, in addition, the sensor subsystem circuit
which includes RFID and IR sensor.The third subsystem is the LED matrix to display
the free parking lots, authorized, and unauthorized personnel. Moreover, the received
signal by RFID will be processed using Arduino controller subsystem. Furthermore,
the output of the controller will be processed by PC to handle data base using C#
software.

of 148
1 Table of Contents
Chapter 1: Introduction & Product Development..........................................................7
1.1 Introduction ..........................................................................................................7
1.1.1 Project Definition...........................................................................................7
1.1.2 Project Objectives ..........................................................................................7
1.1.3 Project Specifications.....................................................................................7
1.1.4 Product Flowchart and Connection................................................................8
1.1.5 Product Prototype.........................................................................................10
1.1.6 Background or Problem ...............................................................................10
1.2: Product Development........................................................................................13
1.2.1 Product planning ..........................................................................................13
1.2.2 Customer Needs and Product Specifications ...............................................13
1.2.3 Concept Generation......................................................................................14
1.2.4 Concept Selection.........................................................................................14
1.2.5 Features of the product:................................................................................15
1.2.6 Product Functional Diagram: .......................................................................16
2 Chapter 2: Arduino Controller, RFID Reader, RFID Tag, and IR Sensor............17
2.1 Arduino Microcontroller.....................................................................................17
2.1.1 Microcontroller Definition, Option, and Selection ......................................17
2.1.2 Introduction about Microcontrollers ............................................................17
2.1.3 Arduino Properties, Schematic Diagram, and Power...................................19
2.1.4Arduino Software, and Controller Chip........................................................22
2.1.5Configuring the Arduino Software................................................................26
2.1.6Introduction about Coding of IDE Arduino Software...................................24
2.1.7Atmega328 Controller...................................................................................26
2.2: (RFID Reader, RFID Tag, and IR Sensor)........................................................27
2.2.1 Sensor Definition..........................................................................................27
2.2.2Sensor Options, and Selections.....................................................................27
2.2.3RFID Sensor Operation:................................................................................27
2.2.4RFID Reader and RFID Tag Properties:.......................................................29
2.2.5Sensor Placement and Alignment .................................................................30
2.2.6RFID Reader Circuit .....................................................................................30
2.2.7Designing the RFID reader to Operate at 125 KHZ......................................31
2.2.8RFID Tag Principle of Operation..................................................................31
2.2.9RFID Tag Properties .....................................................................................31
2.2.10 RFID Reader Setup and Arduino Interface................................................33

of 148
2.2.11RFID Reader and Arduino Interface ...........................................................33
2.3 : ( IR Sensor)....................................................................................................33
2.3.1 Introduction about IR Sensors......................................................................33
2.3.2 Sharp IR Sensors Type (GP2Y0A21YK0F) ................................................33
2.3.3 Features of Sharp IR Sensor.........................................................................34
2.3.4 Elimination of the effect of the stray IR light ..............................................34
2.3.5 Calibration of Sharp IR ................................................................................34
2.3.6 Sharp IR Connection....................................................................................35
2.3.7 IR and Arduino Interface.............................................................................35
Chapter 3: Display Circuit, Servo Motor and Power Supply.......................................35
3.1: Display Circuit..................................................................................................36
3.1.1 Display Definition.......................................................................................36
3..1.2Display Options, and Selections...................................................................36
3.1.3 LED Matrix Properties.................................................................................37
3.1.4 Schematics of LED Matrix:..........................................................................38
3.1.5 Introduction about 16X24 LED Matrixes: ...................................................38
3.1.6 Wiring of LED Matrix: ................................................................................38
3.2 (Servo Motor) ....................................................................................................40
3.2.1 Motor Options, and Selections.....................................................................40
3.2.2 Introduction about Servo Motor...................................................................41
3.2.3 Servo Motor Type Hitec Model (HS-5485HB)............................................41
3.2.4 Features of Servo Motor...............................................................................42
3.2.5 Controlling Servo Motor..............................................................................42
3.2.6 Servo Motor Connection..............................................................................42
3.2.7 Servo Motor and Arduino Interface .............................................................43
3.3 Electrical Power Supply ....................................................................................43
3.3.1 DC power supply block diagram..................................................................44
3.3.2 Component Definitions ................................................................................45
3.3.3 Components of Power Supply......................................................................45
3.3.4Components Selection:..................................................................................45
3.3.5 Operation of Power Supply Circuit..............................................................45
Chapter 4: Database System ........................................................................................47
4.1 C# features: .....................................................................................................47
4.2 C# program general structure..........................................................................47
4.3 C# selection in Parking Monitoring and Control System: ..............................48
Chapter 5: Cellular Shield with SM5100B..................................................................52
5.1 Description ......................................................................................................52
5.2 About to GSM/GPRS Module - SM5100B.....................................................52

of 148
5.3 Main Components of Cellular Shield:.............................................................53
5.4 Schematic Diagram of Cellular Shield............................................................53
5.6 SM5100B-D GSM/GPRS Module Specification (Preliminary) .....................54
5.7 Power Consumption........................................................................................54
5.8 Connection with Arduino Mega 2560.............................................................54
Chapter 6: Set up, Testing and Results ........................................................................55
6.1 Setup and Connection.........................................................................................55
6.1.1 RFID readers ................................................................................................55
6.1.2 LED Display.................................................................................................56
6.1.3 Servo Motor..................................................................................................57
6.1.4 Sharp IR Sensor............................................................................................58
6.2 Results of Testing of RFID Readers Circuit.......................................................59
6.3C#, Testing of Interfacing with microcontroller.....................................................61
Chapter 7: Difficulties, Refinement, and Conclusion64Error! Bookmark not defined.
7.1 Difficulties and Obstacles ...............................................................................64
7.2 Product Refinement.........................................................................................64
7.3 Conclusions.....................................................................................................64
Chapter 8: Real Implementation (Future Work).........................................................66
Bibliography ................................................................................................................67
Appendix A: Code of Arduino Software .....................................................................68
Appendix B: Code of C # (Sharp) Data Base ..............................................................69
Appendix D: Bill of Materials .....................................................................................70
Appendix E: Datasheets…………………………………………………………........82

of 148
Table of Figures Page
1. Figure 1.2: Product Flowchart 8
2. Figure 1.2: CircuitConnection 9
3. Figure 1.3:
4. Figure 1.4: Dynamic Message Sign 10
5. Figure 1.5: OmnyPark OP-511 Ultrasonic Parking Sensor 11
6. Figure 1.6: Variable Messgae Sign VMS 12
7. Figure 1.7: Functional Diagram 16
8. Figure 2.1:Arduino Mega 2560 (components) 20
9. Figure 2.2:Arduino Mega 2560 Schematic 21
10. Figure 2.3:Arduino USB Cable and Power Adapter 21
11. Figure 2.4: Arduino IDE Software 22
12. Figure 2.5: Communication between Arduino and PC 23
13. Figure 2.6: Arduino Serial Monitor 23
14. Figure 2.7: Detecting and displaying the RFID tag by Serial Monitor 23
15. Figure 2.8: Selecting Arduino Chip 25
16. Figure 2.9 Selecting Arduino Com Port 25
17. Figure 2.10: Setup of Com Port Baud rate 25
18. Figure 2.11: Arduino Software 25
19. Figure 2.12 Defined Number 26
20. Figure 2.13: RFID Sensor Operation 29
21. Figure 2.14: RFID Reader 29
22. Figure 2.15: RFID Tag 29
23. Figure 2.16: Transmitter Sensor Circuit (for RFID reader) 30
24. Figure 2.17: Start and End Sequence of Magnetic Timing 31
25. Figure 2.18: RFID Tag Circuit 31
26. Figure 2.19: RFID ID-12 Breakout 32
27. Figure 2.20: RFID Reader 32
28. Figure 2.21: RFID Final Setup 32
29. Figure 2.22: RFID ID-12 Reader and Arduino 33
30. Figure 2.23: Internal Circuit of Sharp IR Sensor 34
31. Figure 2.24: Configuring IR Detection range 35
32. Figure 2.25:IR and Arduino Connection 35
33. Figure 3.1 :16X24 LED Matrix 37
34. Figure 3.2 : Connecting Two LED Matrix 37
35. Figure 3.3:Schematic of LED Matrix 38
36. Figure 3.4:Connecting LED Matrix to Arduino 39
37. Figure 3.5:Connection between LED Matrix and Arduino 40
38. Figure 3.6:Servo Motor type (HS-5485HB) 41
39. Figure 3.7:Controlling Servo Motor 42
40. Figure 3.8: Servo Motor and Arduino connection 43
41. Figure 3.9:Power Supply Block Diagram 44
42. Figure-3.10: Power Supply Circuit Diagram 45
43. Figure-4.1: C#, General Structure of the Program 47
44. Figure-4.2: Tag Form (Screen) 49
45. Figure-4.3: Control Form (Screen) 50
46. Figure-4.4: LOG Form (Screen) 51
47. Figure-4.5: Option Form (Screen) 51
48. Figure-5.1: Schematic Diagram of Cellular Shield 53
49. Figure-5.2: Cellular ShieldConnection with Arduino Mega 2560 55

of 148
Chapter 1: Introduction & Product Development
1.1Introduction
1.1.1Project Definition
Design a project of parking monitoring and control system to count the number of
automobiles entering and leaving a parking, open the gate for authorized personnel, provide
information about free parking spaces, create data base to provide statistics about people
entering and leaving the parking space in addition to using this system for security issues
such as preventing violating people to enter the parking space. This system uses efficient
sensors and display circuits to withstand the surrounding environment.The system will be
powered form power utility available to supply the system components with required supply
for sensors, display, Arduino, door motors, and data base computer.
1.1.2Project Objectives
• Design an efficient parking system to provide statistical information and enhance the
security of utility.
• Saving people‘s time in finding parking lots.
• Learn about energy impact on environment and our role as engineers to offer
solutions;saving energy of automobiles which in turns reduces CO2 emissions and
other harmful gases; hence better green environment.
1.1.3Project Specifications
Main marketing features or specifications are:
• Low power consumption.
• High quality sensor and long life LED.
• Very clear display and efficient controller.
• Easy to install and maintain.
• Easily designed system to minimize the cost.
• The operating temperature of the whole system shall not exceed 70 degrees Celsius.

of 148
1.1.4Product Flowchart and Connection
At the entry (see figure 1.1)
If the person is authorized to enter the parking space, the RFID reader will read the tag and
send its data to the Arduino. Arduino will check if this ID is authorized or not. If no, The
LED display will show not Authorized. If yes the gate will open and close after the car enters
the parking. At the same time, the counter will decrement and the LED display will show the
number of free parking spaces. Also, Arduino will send the information to C# data base. In
case of visitors, there will be pushbutton to open the gate, make decrement for the display,
and close the gate after the car gets in.
At the exit (see figure 1.1)
The RFID reader will read the tag and send its data to the Arduino. The gate will open and
close after the car leaves the parking. At the same time, the counter will increment and the
LED display will show the number of free parking spaces. Also, Arduino will send the
information to C# data base. In case of visitors, there will be pushbutton to open the gate,
make increment for the display, and close the gate after the car gets out.
Initialize all Hardware:
Computer, RFID, IR, bush
button, motor
Signal
from
bush
button
1
Signal
from
RFID1
Signal
from
RFID2
Read tag and
save serial
Yes
No
Count
< max
Send serial to
Computer
Is serial
in
Database
Yes
Display
“No
Space”
No
No
Open Door
Yes
Yes
IR High
and low
No
Close door
decrease count
and update in
database
Display
“Refused”
No
Read tag
Yes
IR High
and low
No
No
Close door
increase count
and update
database
Yes
Yes
Signal
from
bush
button
2
Open Door
No
Yes
Figure-1.1: Flowchart

of 148
At the entry: (see figure 1.2)
Pin 1, 7 are connected to the ground at the Arduino
Pin 2, 11 are connected to the +5V DC at the Arduino
Pin 9 is the serial communication connected to the configured RX3 at the Arduino
At the exit: (see figure 1.2)
Connection of LED matrix with Arduino (see figure 1.2)
VCC (red) to the +5Vat Arduino Board
Ground (black) to ground at the Arduino
DATA(orange) to the digital pin 2 (As configured in the program)
WRITE (yellow) to the digital pin 3 (As configured in the program)
CS0 (white) to the digital pin 4 (As configured in the program
External power supplycircuit toexternal power supply socket
Figure-1.2: circuit Connection

of 148
1.1.5Product Prototype
Figure-1.3: Product Prototype
1.1.6Background or Problem
Making a parking monitoring system especially at Saudi Arabia will be significantly useful
due to the increasing usage of parking lot as
population and buildings increase more and more
which indicates that there is really lack of
parking and a large amount of traffic that look
for free parking spaces. However, this would be
time consuming for people to keep searching and

of 148
also there is an environmental issue since the automobiles is emitting CO2 which is a major
factor in affecting environment. In order to deal with the problems of the metropolitan areas,
there is a need to develop advanced solutions for efficient parking space management
especially at airports, malls, universities, and any large parking lots that are used heavily.
There are a number of companies that provide parking management solutions such as
Siemens, Nortech and Omnitech.a brief introduction about each is described below but
Omnitech was focused on due to the available information they provided regarding used
technology.
Siemens provides several parking management services including: intelligent parking
guidance systems, convenient pay-and-display machines, and modern car park technology. It
uses Sitraffic Guide: parking guidance system which uses dynamic message signs to provide
information to the driver on the current occupancy levels of individual parking areas and
guide people along the shortest route to final parking destination which will dramatically
reduce traffic volumes and environmental pollution. (See figure 1.4)
Nortech uses group of products that provides
methods of counting vehicles entering or leaving a car park or depot and keeping track of
available spaces. it uses what they call it NorParc Level Counting and Guidance System
which offers real-time on-screen information feedback, alarms and report generation. It can
manage both small, single level car parks and large multi-storey car parks with signs showing
available space on each level.
Omnitech uses modern parking management systems which consists of entrance and exit gate
barrier units, parking guidance, car parking control and garage payment system, and parking
counting systems in all various types which are all connected from manual to automatic pay
stations and a car park management center. The main services that are relevant and related to
this context is parking guidance system and parking counting system.One type of sensor is
the OmnyPark OP-511 which is an ultrasonic parking sensor that is used for garage parking
guidance system designed with an ultrasonic detector use as one of the main part of the
parking guidance and management system solution. Parking sensor makes use of ultrasonic
detecting the vehicle parking space to get message and transfer to Zone Control Unit or other
equipment through the RS485 connection. One parking space needs one Ultrasonic Detector
which is installed in the middle of the car park space.
Figure-1.4: Dynamic message sign

of 148
Specification of OmnyPark OP-511 Ultrasonic Parking Sensor( See figure 1.5)
Operating Voltage:DC 12～24V
Operating Current: 10mA （no indicator）, 28mA （with indicator
Operating Temperature:-20＋～80℃
Detecting Distance: 0.1～3.5m
Detecting Area 3.5m: 0.4 sq.m
Size: 100X23mm
Weight: 113g
Communication: RS-485
Communication distance: ≤1000m
Serial port setting: 4800bps，N, 8, 1
Also, there are several techniques and technologies used for counting and displaying
functions as shown in the figure 1.6.
Specification;
1. Electrical supply Voltage: 9 to 24V DC
2. Current Requirement: 250mA @ 12
volts
3. Physical Display: 20 x 7 LED matrix
giving 4 character display (choice of
yellow or red)
4. Viewing angle: 20o each side of
centre
5. Housing: Black powder coated Zintec
6. Dimensions (mm): 380 x 205 x 120 (W x H x D)
7. Display adjustments: 4 brightness levels selectable via NCT200 module
8. Mounting: Options for mounting directly on a flat surface or by using brackets
(included) to enable tilt adjustment for wall mounting and both tilt and pan adjustment
for pole mounting (3‖ diameter)
9. Cable Termination: Plug-in screw terminal blocks
10. Operation Counting capacity: -999 to 9999
11. Inputs Count Bus: RS485 bus from an NCT200 counting module delivering up to 8
count values.
The count value that is displayed is controlled by the node setting on DIP switches.
Figure-1.5: OmnyPark OP-511 Ultrasonic Parking Sensor
Figure-1.6: Variable Messgae Sign VMS

of 148
However, our product would not follow the technique used as shown above which is
installing one detector at each parking lot since this would require lots of wiring and conduits
and these types are for parking lots with roofs. Our product will have same the flexibility to
be working effectively in shielded parking, non-shielded regardless of the size of the parking
since the idea is to install sensors in the entry and exit of each parking lot zone and count up
and count down the display according to the automobiles entering and exiting the parking lot
zone.
1.2: Product Development
1.2.1 Productplanning
This product, like any product shall be made, need a feasibility study to ensure that this
product can be made in terms of the availability of components, cost, implementation,
professional technical skills required, safety requirements and most importantly its need by
the customers.
Our product's components were checked in the local market and found them available
relatively not costly. However, there are some challenges that would play roles on the
progressing of the product designing.One of them is that theteam was not sure about whether
the team can go to the level of programming a microcontroller due to the lack of knowledge
and experience of dealing with it in terms of theoretical or practical experience. Also, the
controller circuit requires good skills and experience in programming and interfacing the
microcontroller with the sensors, display, and data base computer which might impede the
product development process and success.Another challenging factor is time management
since all of team members are full of tasks other than project which would impede as well the
progress of the product development.
1.2.2 Customer Needs and Product Specifications
The need for such a product is in fact interests several customers. So, contacting the target
customers was really an essential step to study the needs and specifications required by
customers. Therefore, this was done by collecting data from field through conducting surveys
on the targeted parking to have a clear idea of what the customers need. Also, meeting or
interviewing the targeted managers of the targeted location to emphasize the advantages of
the product and how that product will increase their income by gaining more satisfaction
from their customers.

of 148
A security officer of Prince Mohamed University was asked for the need of such monitoring
system and how it would be beneficial to them. He said that it would be very beneficial since
in the morning there are 3 security officers work in the parking area trying just to guide
students and close the entrances of those filled parking spaces. In fact, they highly appreciate
such a system to be implemented in Prince Mohamed University according to PMU Security
officer. Also, ordinary people were asked about parking lots in malls and airports and similar
responses we received. Another step is to analyze such data to know how it can be
implemented cost effectively and efficiently in line with the features preferred by customers.
Then, the gathered information were analyzed to define the product specifications that match
needs and requirements taking into consideration any safety issues or standards.
According to customer needs, all what they have in common is to find free parking spaces
easily without detailed and specific technology to be used. However, some prefer a display to
show the number of free parking spaces in addition to an indication of a particular zone is full
or not.
1.2.3 Concept Generation
Many ideas can be generated by considering the different ways and technologies to
implement each subsystem. The below ideas were generated from all group members.
Energy: (1) normal grid, (2) solar (3) battery banks (4) multiple DC output supply to
accommodate the different rating for devices used in the control system.
Counting elements: (1) ultrasonic sensor,(2) motion sensors, and (3) IR sensors (4) Optical
sensors. (5) Magnetic sensor
Processing: : (1) controller, (2) data base computer.
Communication and connection: all units interconnected using wires and cable tray
systems.
Display and Action: (1) indoor/outdoor LED display, (2) Mech. Closing bar (3) Servo motor
(4) DC motor
All of these alternatives will result in different ideas for the design implementation so a
careful selection is highly required to select the best idea for each subsystem or component in
order to fit the main objective of the product design.

of 148
1.2.4 Concept Selection
Selecting the best alternative among several options is mainly dependent on the availability
of components, cost, reliability, implementation, professional technical skills required, safety
requirements and most importantly its need by the customers.
Therefore, studying the alternatives, in terms of all essential design steps in order to select the
best one, requires right decision making. Then testing the selected option against several
factors such as customer preferences and needs, national standards if it shall be recommended
by government law, availability of material, estimated material costs, financial budget,
feasibility as well as efficiency of which all will determine the final selection of the design.
1.2.5Features of the product:
1- One parking zone for employee and others (students or visitors). They will be
provided with RFID tag to allow them passing from the gate.
2- All the customers‘ mobile numbers will be attached with the serial number of their
tags to be used for send and receiving SMS from the system and send the violation to
their mobile number with the number of days that will not be authorized to use the
parking lot.
3- ArduinoUno and Mega 2560 instead of microcontroller because it is more stable and
easier to deal with and it will be used as the brain to control our system by sending
and receiving instructions from inputs and output devices as follows:
a. Input devices:
i. RFID reader ID-12 with built in antenna one in the entrance and one in
the exit which will detect the unique serial number of the tag and send
to Arduino to take the appropriate action (allow or denied).
ii. IR distance sensor in the entrance and exit to make sure that the car has
passed the gate and it will send a signal to allow closing the gate.
iii. Push button to open and close the gates incase of RFID reader failure.
b. Output devices:
i. Open and close gate by using stepper motor one in the entrance and
exit.
ii. 16x24 Red LED Matrix Panel to display the number of available parks
and it will display the word ―Full‖ when no parking available.

of 148
c. Input and output device:
i. Laptop will be used to add new customer or delete unwanted one and it
will be used to display the customer‘s information.
ii. Cellular Shield with SM5100B will be used to send the number of
available park by SMS and it will receive an SMS to reserve park.
4- The system will have the ability to reject specific cars that has violation or security
issue.
5- The system will use C # as logging Data for security in a database and showing:
a. Name, ID and Plate number.
b. Time in and time out.
6- Monthly statistics showing how many visitors and violations per month.
1.2.6Product Functional Diagram:
The block diagram shown in figure 1.7 identifies how the Arduino connected with others
devices.
Figure-1.7: Functional Diagram
The following components were selected depending on cost and efficiency:-

of 148
Power Supply: 110/220 VAC to 9VDC to power Arduino and 5 VDC with supply
current of 2A to power cellar shield.
Sensors:RFID sensor and IR sensor.
RFID reader: RFID reader type ID-12 with built in antenna.
RFID tag: Passive RFID tags type sparkfun.
IR Sensor: Sharp IR sensor typeGP2Y0A21YK0F
Microcontroller:Microchip Arduino mega 2560 that receives input from sensor
subsystem and sends output to display subsystem and data base.
Display: 16*24 LED matrix type PID555
Motors:Servo motor type HS-5485HB
Chapter 2:ArduinoController, RFID Reader, RFID Tag, and IR
Sensor
2.1 Arduino Microcontroller
It's an open-source physical computing platform based on a simple microcontroller board,
and a development environment for writing software for the board. Arduino can be used to
develop interactive objects, taking inputs from a variety of switches or sensors, and
controlling a variety of lights, motors, and other physical outputs.
2.1.1 Microcontroller Definition, Option, and Selection
A microcontroller (sometimes abbreviated µC, uC or MCU) is defined as a small computer
on a single integrated circuit containing a processor core, memory, and programmable I/O
peripherals. Program memory in the form of NOR flash or OTP ROM is also often included
on chip, as well as a typically small amount of RAM Microcontrollers are designed for
embedded applications.
2.1.2 Introduction about Microcontrollers
The controller is the core system of the project or any electrical circuit since it acts like the
brain that takes decisions and receives and sends output accordingly. The controlling function
in this project shall use the microcontroller rather than digital IC's. In fact, it is really a good
chance to learn about microcontroller and how to program and design microcontroller based
circuits since almost all controlling functions in electronic devices are made
usingmicrocontrollers.Also, it gave flexibility in changing programs or modify or enhance the
functionality easily since all it requires changing the program and downloading it to chip

of 148
whereas in digital IC's we have to change the physical hardware configuration to meet the
required result which will be time consuming in addition to complexity.
However, there are several types of microcontrollers in the market. The selection of the
microcontroller was based in how common it is in market and availability. Also, it depended
on the size of the program memory, RAM and the clock frequency (speed), how many I/O it
can accommodate as well as interrupts.
Basically, a microcontroller is a device which integrates a number of the components of a
microprocessor system onto a single microchip and optimized to interact with the outside
world through on-board interfaces. So, it is in fact a little gadget that houses a
microprocessor, ROM (Read Only Memory), RAM (Random Access Memory), I/O (Input
Output functions), and various other specialized circuits all in one package.
On the other hand, a microprocessor is normally optimized to co-ordinate the flow of
information between separate memory and peripheral devices which are located outside it.
Connections to a microprocessor include address, control and data busses that allow it to
select one of its peripherals and send to or retrieve data from it. Because a microcontroller‘s
processor and peripherals are built on the same silicon, the devices are self-contained and
rarely have any bus structures extending outside their packages.
Microcontrollers Options, and Selections
The common used microcontrollers which are suitable for our project are:
1. Arduino: An Arduino is a tiny computer that you can program to process inputs and
outputs going to and from the chip. It is connected to PC using the USB cable. It is an
open source electronics prototyping platform based on flexible, easy to use hardware
and software. It‘s intended for artists, designers, hobbyist and engineers. Arduino can
sense the environment by receiving input from a variety of sensors and can affect its
surroundings by controlling lights, motor and other actuators. The microcontroller on
the board is programmed using the Arduino programming language.
2. PIC16F84A: It has a Watchdog Timer which can be shut off only through
configuration bits. It runs off its own RC oscillator for added reliability. There are two
timers that offer necessary delays on power-up. One is the Oscillator Start-up Timer
(OST), intended to keep the chip in reset until the crystal oscillator is stable. The other

of 148
is the Power-up Timer (PWRT), which provides a fixed delay of 72 ms (nominal) on
power-up only. This design keeps the device in reset while the power supply
stabilizes. With these two timers on-chip, most applications need no external reset
circuitry. SLEEP mode offers a very low current power-down mode. The user can
wake-up from SLEEP through external reset, Watchdog Timer time-out or through an
interrupt. Several oscillator options are provided to allow the part to fit the
application. The RC oscillator option saves system cost while the LP (Low Frequency
Power)crystal option saves power. A set of configuration bits are used to select the
various options.
The type selected is Arduino Mega 2560 which belongs to the most well-known company
that produces friendly microcontrollers.New to the product line is the new Arduino Mega
with increased memory and number of I/O pins.This was chosen because of its availability of
resources such as tutorials and books.
2.1.3ArduinoProperties, Schematic Diagram, and Power
The Arduino Mega 2560 is a microcontroller board based on the ATmega2560. It has 54
digital input/output pins (of which 14 can be used as PWM outputs), 16 analog inputs, 4
UARTs (hardware serial ports), a 16 MHz crystal oscillator, a USB connection, a power jack,
an ICSP header, and a reset button.
 Specifications and Features of Arduino Mega 2560
Some of the detailed technical specification is mentioned below:-
• Operating voltage of 5 V.
• 16 MHz clock speed.
• The number of digital I/O's pins is 54.
• The number of analog input pins is 16.
• 4 hardware serial ports.
• Flash Memory: 32 KB
• SRAM: 2 KB
• EPROM: 1 KB
• Clock Speed: 16 MHZ

of 148
What sets a microcontroller apart from other processors are special circuits to deal with the
needs of real time applications. There is an important feature of Arduino which is Software
Serial library that allows for serial communication on any of the Mega‘s digital pins. The
Arduino 2560 has a host of such features intended to maximize system reliability, minimize
cost through elimination of external components, provide power saving operating modes and
offer code protection. These features as illustrated in figure 2.1 next pageare:
• Reset button
• Digital I/O
• Power pins
• Analog inputs
• Voltage regulator
• In-circuit serial programming
• FTDI USB chip and USB jack
• Power jack
• ICSP header
Figure-2.1: Arduino Mega 2560 (components)
The Arduino can be used to develop stand-alone interactive objects or it can be connected to
a computer to retrieve or send data to the Arduino and then act on that data. The Arduino is
an amazing device. Users can us to make many things from interactive works of art to robots.
With a little enthusiasm to learn how to program the Arduino and make it interact with other
components a well as a bit of imagination.Users can build many things.TheArduino can be
connected to LED Matrix displays, RFID readers, buttons, switches,motors, temperature
sensors, pressure sensors, distance sensors, webcams, printers, GPS receivers, and Ethernet
modules. The Arduino board is made of an Atmel AVR Microprocessor, a crystal or

of 148
oscillator (basically a crude clock that sends time pulses to the microcontroller to enable it to
operate at the correct speed) and a 5-volt linear regulator. USB connector is used to connect
to a PC or Mac to upload or retrieve data. The board exposes the microcontroller I/O
(Input/Output) pins to enable you to connect those pins to other circuits or to sensors, etc.
ArduinoSchematic Diagram (see figure 2.2)
Figure-2.2: Arduino Mega 2560 Schematic
Powering the Arduino Mega 2560
The most common way to power the Arduinois to plug one end of the USB cable into the
Arduino and the other end into a computer. The computer will then power the Arduino. (See
figures 2.3 next page)

of 148
Figure-2.3: Arduino USB Cable and Power Adapter
Another way to power up the Arduino is to plug in a battery or wall adapter into the DC jack.
The rating should be 9V DC 100-500mA power adapter, with a 2.1mm barrel plug and
positive tip. Right next to the USB jack, there is a jumper with 3 pins. If the jumper is on the
two pins nearest USB jack that means you are planning to power the Arduino via the USB
cable. If it's on the two pins nearer the DC Jack then it means you are planning to power the
Arduino using a 9V battery or wall adapter.
2.1.4 Arduino Software, and Controller Chip
IDE Software to program the Arduino
The Arduino has his own application software thatenables the programmer to download and
upload programs and other functionalities such as debugging. Download the Arduino IDE
(The software name) from the Arduino download page. This software uses C language as the
programming language for theArduino as shown in figure 2.4.

of 148
Figure-2.4: Arduino IDE Software
The communication between Arduino and PC is accomplished using USB cable to transfer
data serially as shown figure 2.5
Figure-2.5: Communication between Arduino and PC
Seeing serial data requires a monitor, which like your display monitor will show us what data
is being transferred as shown in figure 2.6

of 148
Figure-2.6: Arduino Serial Monitor
We can also send serial data back to the Arduino using the Serial Monitor.The Baud Rate:
default setting is 9600 baud for serial monitor as shown in figure 2.7.
Figure-2.7: Detecting and displaying the RFID tag by Serial Monitor
2.1.5 Configuring the Arduino Software
After downloading and installing the Arduino software, the first step is to configure the
Arduino software for the correct chip. Look for the chip on the Arduino that looks like as
shown in figure 2.8.
Figure-2.8: Selecting Arduino Chip

of 148
Next, is to configure the Serial Port: (See figure 2.9).
Figure-2.9: Selecting Arduino Com Port
Set the PC communication baud rate to 9600 pits per second as shown figure 2.10next page
Figure-2.10: Setup of Com Port Baud rate
As shown in the figure 2.11 below, the code can be written in this window:

of 148
Figure-2.11: Arduino Software
After verifying the code, it can be sent to Arduino by pressing upload button
2.1.6 Introduction about Coding of IDE Arduino Software
There are two main sections in this software. Below are some of main functions that are used
in programming the Arduino and essential to learn for even simple programs:
The setup () function is called when a sketch starts. It is used to initialize variables, pin
modes, start using libraries, etc. The setup function will only run once, after each power up or
reset of the Arduino board.
After creating a setup () function, which initializes and sets the initial values, the loop ()
function does precisely what its name suggests, and loops consecutively, allowing your
program to change and respond. It is used it to actively control the Arduino board.

of 148
#define is a useful C component that allows the programmer to give a name to a constant
value before the program is compiled. Defined constants in Arduino do not take up any
program memory space on the chip. The compiler will replace references to these constants
with the defined value at compile time.
This can have some unwanted side effects though, if for example, a constant name that had
been #defined is included in some other constant or variable name. In that case the text would
be replaced by the #defined number (or text). See figure 2.12
2.1.7 Atmega328 Controller
The Arduino uses atmega328 microcontroller which uses 2 KB of SRAM. Memory is part of
the microcontroller whose function is to store data. Two important concepts are brought to
us: addressing and memory location. Memory consists of all memory locations, and
addressing is nothing but selecting one of them. This means that we need to select the desired
memory location on one hand, and on the other hand we need to wait for the contents of that
location. Also, the main operation that occurs is the read/wirte operation. This is done by
supplying an additional line called control line. This line is designated as R/W (read/write).
This control line is used to control which operation CPU shall execute whether it is read or
write operation. So, if R/W is logic 1 then it is a read operation and if it is 0 then it is a write
operation.
Figure-2.12: Defined Number

of 148
2.2: (RFID Reader, RFID Tag, and IR Sensor)
2.2.1Sensor Definition
A sensor (also called detectors) is a device that measures a measurable attribute and converts
it into a signal which can be read by an observer or by an instrument.
2.2.2Sensor Options, and Selections
The common used sensors which are suitable for our project are:
3 RFID Sensor: RFID is a form of automatic identification that uses electric or magnetic
fields at radio frequencies to transmit information. Every RFID system includes a radio
frequency (RF) subsystem, which is composed of tags and readers. This technology has
been described as a major enabling technology for automated, contactless, and wireless
data collection.
4 Passive infrared sensors: Looks for body heat. No energy is emitted from the sensor.
The passive infrared (PIR) sensor has the ability to detect movements at distances up to
6-45 m. Power supply input: 5-20 VDC. Cost range is $6.9.
5 Active Infrared Sensor: Active infrared sensors illuminate detection zones withlow
power infrared energy supplied by laser diodes operating in the near infrared region of
the electromagnetic spectrum. Power supply input: 3-20 VDC. Cost range is $1.9.
6 Ultrasonic (active): Sends out pulses of ultrasonic waves and measures the reflection
off a moving object. The range of frequency: above 40-50 KHZ. Firstly, it is inaudible
to humans and therefore undetectable by the user. Secondly, ultrasound waves can be
produced with high directivity. Thirdly, they are a compression vibration of matter
(usually air). Finally, they have a lower propagation speed than light or radio
waves.Power supply input: 5-20 VDC. Cost range is $2.9.
7 Sensors that combine passive infrared presence detection with ultrasound or Doppler
radar. The passive infrared-ultrasonic combination provides enhanced accuracy for
presence and queue detection, vehicle counting, and height and distance discrimination.
8 Microwave (active): Sensor sends out microwave pulses and measures the reflection
off a moving object. Microwave sensors utilize electromagnetic fields and devices

of 148
internally operating at frequencies starting from ~300 MHz up to the terahertz range.
Since it is using electromagnetic waves that can affect health of human beings, more
research can be conducted to make sure about its effects.
9 Passive Acoustic Array Sensors: Acoustic sensors measure vehicle passage, presence,
and speed by detecting acoustic energy or audible sounds produced by vehicular traffic
from a variety of sources within each vehicle and from the interaction of a vehicle s
tires with the road.
In conclusion, the most common used sensors are RFID sensor, infrared sensors, and
ultrasonic sensors. By comparing these types of sensors according to the accuracy, simplicity,
security, reliability, health, and cost, it is recommended touse both RFID sensor and infrared
sensors.
2.2.3RFID Sensor Operation:
RFID readers are devices that wirelessly communicate with tags to identify the item
connected to each tag and possibly associate the tagged item with related data. In other
words, readers send electromagnetic signal to the tag and read its response. They generally
transmit their observations to a controller and a computer system running RFID software.
The antenna of the RFID reader emits radio signals to activate the tag. When an RFID tag
passes through the electromagnetic zone, it detects the reader's activation signal. The reader
decodes the data encoded in the tag's integrated circuit (silicon chip) and the data is passed to
the host computer for processing. See figure 2.13
2.2.4 RFID Readerand RFID Tag Properties:
 The ID-12 comes with internal antennas.
 RFID-12 has read range of 12 cm.
 RFID reader needs 5 VDC power.
Figure-2.13: RFID Sensor Operation

of 148
 RFID-12 sends 125 KHZ signal to power tags.
 Each tag sends back a unique 12 digit hex serial number.
 Passive RFID tag is cheaper, smaller, and it does not need battery.
 Passive RFID tags lasts for longer time than active tags.
 RFID technology does not require a line of sight.
 RFID tags can stand in a harsh environment.
Figure-2.15: RFID Tag
2.2.5 Sensor Placement and Alignment
The RFID readers at the entry and exit of the parking lot should be placed at minimum
distance of 10 cm from each other. In order to get accurate results, we needed to place and
align the sensors properly. That was achieved by following the instructions to have a
minimum distance of 10 Cm between them as well as installing them at the same level and
angle.
2.2.6 RFID Reader Circuit
Our RFID reader works on 5 VDC power supply to produce a resonant frequency of 125 KHz
to power RFID tags. Our design circuit is shown in figure 2.16 below.
Figure-2.14: RFID Reader

of 148
Figure-2.16: Transmitter Sensor Circuit
2.2.7 Designing the RFID reader to Operate at 125 KHZ
Radio frequency identification technology is based on resonant frequency principle where the
inductive reactance is equal to capacitive reactance. That means:
ωL = 1/ωC
As per the data sheet of RFID reader type ID-12, the inductance of the reader L= 1.08 mH,
and the capacitance C= 1.5nF.
By substituting these values in this formula:
We achieve the 125 KHz resonant frequency.
Figure 2.17 shows start and end sequence of magnetic timing in the RFID reader

of 148
Figure-2.17: Start and End Sequence of Magnetic Timing
2.2.8 RFID Tag Principle of Operation
RFID tag consists of microchip which stores the ID number and antenna. When the RFID tag
is powered by the 125 KHz frequency signal, the data which are stored in the microchip will
be sent through the magnetic signal to the reader. See figure 2.18
Figure-2.18: RFID Tag Circuit
2.2.9 RFID Tag Properties
Sparkfun RFID tag is a passive tag and not reprogrammable (read only) type.That is because
the Data is stored in ROM memory. So, we cannot change, delete, or add to the information
stored in the microchip of the RFID tag.
2.2.10 RFID Reader Setup and Arduino Interface
RFID Reader connection Setup
For suitable use, the breakout board was soldered with the RFID-12 reader using soldering
iron in order to be connected to the Arduino in a safe and professional way as shown in the
figures below:

of 148
1. RFID Breakout
Figure-2.19 : RFID ID-12 Breakout
2. RFID-12 Reader
Figure-2.20 : RFID ID-12 Reader
3. Final Appearance
Figure-2.21: RFID Final Setup
2.2.11RFID Reader and Arduino Interface
The ID-12 RFID reader requires +5V (pin 2, 11), ground (pin 1, 7), and serial communication
(pin 9) to send The ID to the Arduino. Refer to figure 2.22

of 148
Figure-2.22 : RFID ID-12 Reader and Arduino
2.3 :( IR Sensor)
2.3.1 Introduction about IR Sensors
Infrared sensors are a type of light sensors. They function in the infrared part of the frequency
spectrum. They can be used for the same purposes:
1. Detecting the presence of an object
2. Measuring the distance to a nearby object (clever electronics required)
2.3.2 Sharp IR Sensors Type (GP2Y0A21YK0F)
It is an analog output type sensor because it detects infrared light between 10-80 cm.
Inside the tin can, there is anIR detector, transmitter, and a demodulator. Refer to figure 2.23
for Sharp IR Sensors Type (GP2Y0A21YK0F) internal circuit.

of 148
Figure-2.23 : Internal Circuit of Sharp IR Sensor
2.3.3 Features of Sharp IR Sensor
 Measures distance in range from 10-80cm.
 Designed to interface to small micro-controllers.
 Less influence on the colors of the reflected objects and their reflectivity.
 Typical current consumption 30 mA.
 3.1V at 10cm to 0.4V at 80cm.
 Operating temperature -40-70°C.
2.3.4 Elimination of the effect of the stray IR light
To eliminate the effect of the stray IR light, the IR emitters are modulated and the output of
the IR Detectors is demodulated to look for specific range of detection.
2.3.5 Calibration of Sharp IR
The sensor was adjusted to make detection between 20cm and 30 cm. The 30 cm is the free
space between the position of IR sensor and beyond the entranceas shown figure 2.24.

of 148
Figure-2.24 : Configuring IR Detection range
That was achieved by setting the free distance (20-30 cm) in the IR code, measuring a
distance of 30 cm from the IR and comparing the actual measurement with the measurement
in the serial monitor of Arduino. So, if there is a car isin a range greater than 20 cm and less
than 30 cm in addition to a valid RFID tag, the gate will open. If the car is not within this
distance, that means it gets in and the gate will close.
2.3.6 Sharp IR Connection
This type of sensors has three wires:
 Red is VCC the power supply.
 Black is the ground.
 Yellow is the IR analog pulse.
2.3.7 IR and Arduino Interface
Connecting of IR sensor with arduino is indicated in the figure 2.25
 Red wire can be connected to +5V in Arduino
 Black wire is connected to ground in Arduino
 Yellow wire is the analog pulse which can be connected to analog inputs in Arduino.
Figure-2.25 : IR and Arduino Connection

of 148
Chapter 3: Display Circuit, Servo Motor and Power Supply
3.1:Display Circuit
3.1.1 Display Definition
A display device is an output device for presentation of information in visual. Some displays
can show only digits or alphanumeric characters. They are called segment displays, because
they are composed of several segments that switch on and off to give appearance of desired
output. The segments are usually single LEDs or liquid crystals. They are mostly used in
digital watches and pocket calculators.
3.1.2 Display Options, and Selections
There are three outdoor displays that can be used in parking system:
1. LED or light-emitting diode (LED) is a semiconductor light sourceLEDs are used as
indicator lamps in many devices and are increasingly used for other lightingLight-
emitting diodes are used in applications as diverse as aviation lighting, automotive
lighting, advertising, general lighting, and traffic signals.
2. LCD or liquid crystal display is a flat panel display, electronic visual display, or video
display that uses the light modulating properties of liquid crystals (LCs). LCsdo not
emit light directly.LCDs are used in a wide range of applications, including computer
monitors, television, instrument panels, aircraft cockpit displays, signage, etc. They
are common in consumer devices such as video players, gaming devices, clocks,
watches, calculators, and telephones.
3. Seven- Segments: seven-segment display (SSD), or seven-segment indicator, is a
form of electronic display device for displaying decimal numerals that is an
alternative to the more complex dot-matrix displays. Seven-segment displays are
widely used in digital clocks, electronic meters, and other electronic devices for
displaying numerical information.

of 148
Our selection was on16 X 24 LED matrix display because it is clear, has low power
consumption, cheap, and easy to configure it with Arduinomicrocontroller. See figure
3.1
Figure-3.1 : 16X24 LED Matrix
6.2 16X24 LED matrix Operation, Properties, Placement, and Alignment
3.1.3 LED Matrix Properties
 Low Power Consumption (60mW).
 Clear display.
 Easy to program.
 It is designed to be 'chainable‗ up to 8 panels together to make an extra-long display
as shown in the figure 3.2 below.
Figure-3.2 : Connecting Two LED Matrix

of 148
3.1.4 Schematics of LED Matrix:
Figure-3.3 : Schematic of LED Matrix
3.1.5 Introduction about 16X24 LED Matrixes:
These LED panels take care of all the work of making a big matrix display. Each panel has
six 8x8 red matrix modules, for a 16x24 matrix. The panel has a HT1632C chip on the back
which does all the multiplexing work and has a 3-pin SPI (Serial Peripheral Interface) -like
serial interface to talk to it and set LEDs on or off. There are a few extras as well, such as
being able to change the brightness of the entire display, or blink the entire display at 1 Hz.
The Arduinohas a fulllibrary for this type of LED matrix that not only takes care of
controlling the display but also intelligently handles chained displays, so that they appear to
be one long matrix. The library has functions for drawing pixels, lines, rectangles, circles and
text.
3.1.6 Wiring of LED Matrix:
Wiring is thankfully fairly simple, much easier than trying to actually wire up 6 x 8x8
matrices. The HT1632C driver chip requires only 3 data pins - data, write, and chip select
(cs).

of 148
Begin by plugging in a 2X5 pin IDC cable into the top left socket. See figure 3.4
Figure-3.4 : Connecting LED Matrix to Arduino
Next, you will need a few wires, the following convention can be used: a Red wire for VCC
(+5V), a Black wire for Ground, a White wire for CS0 (chip select #0), an orange wire for
Data and a yellow wire for Write.
So, the connection between LED matrix and Arduino is as shown in the table below and
figure 3.5 in next page.
From Pin # at LED Matrix To pin # at Arduino Board
VCC (red) +5V
Ground (black) Ground
DATA(orange) digital pin 2 (As configured in the program)
WRITE (yellow digital pin 3 (As configured in the program)
and CS0 (white) digital pin 4 (As configured in the program)

of 148
Figure-3.5 : Connection between LED Matrix and Arduino
3.2 (Servo Motor)
3.2.1 Motor Options, and Selections
The common actuators which are suitable for the project are:
1. DC Motor: A DC motor is a mechanically commutated electric motor powered from
direct current (DC). A DC motor has a two wire connection. All drive power is
supplied over these two wires—think of a light bulb. When you turn on a DC motor, it
just starts spinning round and round. Most DC motors are pretty fast, about 5000 rpm
(revolutions per minute).With the DC motor, its speed (or more accurately, its power
level) is controlled using a technique named pulse width modulation, or simply PWM.
2. Servo Motor: A servomotor is a rotary actuator that allows for precise control of
angular position.A servo motor is an entirely different story. The servo motor is
actually an assembly of four things: a normal DC motor, a gear reduction unit, a
position-sensing device (usually a potentiometer—a volume control knob), and a
control circuit. The servo has a 3 wire connection: power, ground, and control. The

of 148
power source must be constantly applied; the servo has its own drive electronics that
draw current from the power lead to drive the motor. Refer to figure 3.6
Figure-3.6 : Servo Motor type (HS-5485HB)
In conclusion, we selected servo motor because it is easy to deal with, more reliable, and
easy to configure with Arduino. Unlike DC motor, it does not require external circuits
such as switches or H-bridge components.
3.2.2Introduction about Servo Motor
A servomotor is a rotary actuator that allows for precise control of angular position. It
consists of a motor coupled to a sensor for position feedback, through a reduction gearbox.
Italso requires a relatively sophisticated controller, often a dedicated module designed
specifically for use with servomotors.
Servomotors are used in applications such as robotics, CNC machinery or automated
manufacturing.
3.2.3 Servo Motor TypeHitecModel (HS-5485HB)
The HS-5485HB is Hitec‘s second digital standard servo world. This servo can be
programmed using our hand-held servo programmer such as Arduino software. It can be
configured to travel from 0° up to 180°.
Servo speed is stated in seconds. Just as a car has a 0-60 mph time, a servo has a 0-60 degree
time. The lower the 60 degree time, the faster the servo operates. Its speed can be adjusted to
be slow or fast using software such as Arduino software.

of 148
3.2.4 Features of Servo Motor
 Designed to interface to small micro-controllers.
 Required Pulse: 3-5 Volt Peak to Peak Square Wave
 Operating Voltage: 4.8-6.0 Volts
 Operating Temperature Range: -20 to +60 Degree C
 Current Drain (4.8V): 8.8mA/idle and 400mA no load operating
 Current Drain (6.0V): 9.1mA/idle and 500mA no load operating
3.2.5 Controlling Servo Motor
Servos are controlled by sending them a pulse of variable width. The control wire is used to
send this pulse. The parameters for this pulse are that it has a minimum pulse, a maximum
pulse, and a repetition rate. Given the rotation constraints of the servo, neutral is defined to be
the position where the servo has exactly the same amount of potential rotation in the
clockwise direction as it does in the counter clockwise direction and that position is always
around 1.5 milliseconds (ms). See figure 3.7.
Figure-3.7 : Controlling Servo Motor
The angle is determined by the duration of a pulse that is applied to the control wire. This is
called Pulse width Modulation. The servo expects to see a pulse every 20 ms. The length of
the pulse will determine how far the motor turns. For example, a 1.5 ms pulse will make the
motor turn to the 90 degree position (neutral position).
3.2.6 Servo Motor Connection
All of our Hitec servos come with the ―S‖ or universal connector. This connector works with
any brand of receiver, servo controller or servo extension.
This type of Motors has three wires:

of 148
 Red is VCC the power supply.
 Black is the ground.
 Yellow is for the digital pulse that controls the rotation of the motor.
3.2.7 Servo Motor and Arduino Interface
Red wire can be connected to +5V in Arduino
Black wire is connected to ground in Arduino
Yellow wire is the digital pulse which can be connected to digital output in Arduino.
See figure 3.8 for connection between between servo and Arduino
Figure-3.8 : Servo Motor and Arduino connection
3.3Electrical Power Supply
A power supply is a device that supplies electric power to one or more electric loads. A
regulated power supply is one that controls the output voltage or current to a specific value;
the controlled value is held nearly constant despite variations in either load current or the
voltage supplied by the power supply's energy source.

of 148
3.3.1DC power supply block diagram
Regulated DC power supply is done by many steps: AC current is rectified and then filtered
by capacitor to obtain rippled current and after that regulated by voltage regulator to obtain
DC regulated power supply. See figure3.9.
Figure-3.9: Power Supply Block Diagram
3.3.2 Component Definitions
Rectifier
All DC power supplies have a rectifier, consisting of a set of diodes that changes the
reversing flow of AC to one-way DC. While the rectifier prevents the current from reversing
direction, the DC it produces carries a lot of electrical noise. You can charge batteries with it,
but any electronic device, such as a stereo, would pick up a loud, low-frequency hum. To
eliminate the noise, the power supply has filter circuits that smooth the DC output. So the
rectifier will remove positive or negative cycle as it is designed to produce DC.
Filter
Other than the issues of low power and limited life, a battery is an ideal DC source. It delivers
steady current virtually free of electrical noise. Rectified DC, on the other hand, needs filter
circuits to remove noise or minimize ripple voltage. Usually, these filters are simple,
consisting of large electrolytic capacitors. Though the DC coming from the filter has less
noise, the voltage can wander unpredictably, causing reliability issues with sensitive
electronics. To solve that problem, the power supply uses a voltage regulator.
Regulator
A voltage regulator "locks" the power supply's voltage to a fixed value. A circuit's power
demands can vary over time; unless the power supply has a regulator, a greater current
demand can reduce the supply's voltage. With the regulator, the voltage remains steady. The
regulator also removes some of the power supply's remaining noise.

of 148
Circuit of DC power supply is simple as indicated in figure 3.10
Figure-3.10: Power Supply Circuit Diagram
3.3.3Components of Power Supply
1. D1, D2 = SCHOTTKY RECTIFIER 5Amp
2. L1 = center tap Step down transformer with input of 120 V AC 60 Hz and output of
(13.8V AC 60Hz)
3. C1 = 3300uf capacitor
4. C2 = 10 ufcapacitor
5. IC1 : =L78S09 for +9V DC with 2A output (for microcontroller circuit ) and
LM323T5V with 3A output (cellular shield ).
3.3.4 Components Selection:
1. Diode Schoriky rectifier, PIV (peak inverse Voltage<BV
VS Max=VO Max+VD= 13V +0.7V=13.7
PIV=2Vs (Max)-VD=2*13.8-.7=20.6V <80 (140 RMS reverse V)
2. Capacitor V min;
V P secondary-VD-Vr (ripple) =13.8V-0.7-.5=12.6 DCV
3. Capacitance1 ; C= Vm/(2fRVr)=3300uf
3.3.5 Operation of Power Supply Circuit
120V 60Hz AC power is stepped down to 13.8V 60Hz. After that, positive power cycle from
transformer secondary will go through diode rectifier D1 and continue to positive side of
capacitor filter C1.also the negative power cycle from transformer secondary through rectifier
diode D2 to positive side of capacitor filter C1. The ripple in the voltages after rectifier

of 148
diodes is reduced by the filter to the desired one. Then the rippled voltage goes though the IC
L78S09 to get regulated 9 DC V which is the supply of the 9 DC V microcontroller circuits.
The LM323T is then connected in parallel with L78S09 to get 5V that supplies the cellular
shield.

of 148
Chapter 4: Database System
C# is a general purpose programming object oriented language invented around 1999 or 2000
by Anders Hejlsberg at Microsoft. It is very similar to Java in its syntax with a major
difference being that all variable types are descended from a common ancestor class.
C# is intended to be a simple, modern, general-purpose, object-oriented programming
language:
1. Unsafe operations such as direct memory manipulation are not allowed.
2. C# has been based according to the current trend and is very powerful and simple for
building, scalable, applications.
3. Object Oriented Programming (OOP) is a method of developing software that models
the real world using objeject. For example a driving simulation might have road
objects, vehicle objects and possibly human objects.
So, the purpose of C# is to precisely define a series of operations that a computer can perform
to accomplish a task. Most of these operations involve manipulating numbers and text, but
anything that the computer can physically do can be programmed in C#.
What is C# used for?
It can be used for all sorts of applications such as computer games, and operation system.
There are also web based applications running on the asp.net platform.
4.1 C# features:
1. C# is built in C++, so it behaves much like language. In fact, it is just that C# is so
much friendlier than C++.it is much easier to build data base using C# than using C++
even though that C# built in C++.
2. You can also interoperate with other languages
3. It can be used to save a database of customers.
4.2 C# program general structure
C# programs can consist of one or more files. Each file can contain zero or more namespaces.
A namespace can contain types such as classes, methods, and eventhandlers. (Refer to
figure 4.1.
Figure-4.1: C#, General Structure of the Program

of 148
Namespace: is keyword used to declare a scope. This namespace scope lets you organize
code and gives you a way to create globally unique types. They are used especially to provide
the C# compiler a context for all the named information in your program, such as variable
names
Class: All code and data in C# must be enclosed in a class. A class is a construct that enables
you to create your own custom types by grouping together variables of other types, methods
and events. A class is like a blueprint. It defines the data and behavior of a type.
Methods:A method is a code block that contains a series of statements. A program causes the
statements to be executed by calling the method and specifying any required method
arguments. In C#, every executed instruction is performed in the context of a method. The
Main method is the entry point for every C# application and it is called by the common
language runtime (CLR) when the program is started.
Methods are declared in a class by specifying the access level such as public or private,
optional modifiers such as abstract or sealed, the return value, the name of the method, and
any method parameters. These parts together are the signature of the method.
Event handler: is a method that contains the code that gets executed in response to a specific
event that occurs in an application
Event handlers are used in graphical user interface (GUI) applications to handle events such
as button clicks and menu selections, raised by controls in the user interface. A single event
handler can be used to process events raised by multiple controls
4.3 C# selection in Parking Monitoring and Control System:
1. We can create a Windows Forms Application (screens)
2. Connect to multiple data sources, including Access and SQL Server
3. Add, edit, and update data in a database we choose and design
4. Enable users to choose their data source at runtime
5. Communicate with microcontroller.
6. It will help in having the control automated.
7. Develop database in C# is much better than in Excel or Access. Although Excel and
Access can interface with inputs from devices but in fact the interface is only from
side: they can read only and to have an action based in certain information in the
database another program is needed.
8. C# advantage over visual basic:C# is a more efficient language than VB (meaning
you can do the same work in less code), which translates into faster development

of 148
time. Both business and technical reasons are welcome. Also, In C# you can
document the code you write using XML. C# is the only programming language in
Visual Studio .NET with this feature.
9. C# is better than Java in that:
A- It has dynamic variables, if you want them.
B- It allows you to define new value (or non-reference) types
C- It's deeply integration with Windows, in case it is needed
The C# program has been developed for the Parking Monitoring and Control
Systemdone by Windows Form Application and all user interfaces (main form/screen)
work and design has been done by the tool box and manipulation the properties that
allows the programmer to add buttons, tab control, serial port in order to interface with
devices such as the controller, list view, labels, text and combo boxes. However, working
inside the user interface or the screen has been done by certain commands and codes.
The parking monitoring program in the C# consists of four screens (forms):
1- Tags screen where it can be access from tab tag control button. Adding new tags No,
customer name, customer mobile name and expiration date of a tag and photo of the
customer as well. See figure 4.2
Tag information can be edited and an assigned tag for a customer can be deleted
from database from the tag screen-database.
The list view –white screen in the middle will show data base we have
Figure-4.2: Tag Form (Screen)

of 148
2- Control screen that can be access from tab control button. Most of functionally of
communication with the controller will happen here: Gates can be opened and closed in
case a customer has a valid tag miss or forgot his tag. Gate can also be selected for this
action. See figure 4.3
The textbox inside (dark one) will display to the program user action taken such as
sending opening or closing command and whether communication port is open or close
to communicate.
The total parking spaces can be set here to allow counting for the free parking spaces.
Displaying text will allow the user to display on the led matrix through the controller.
In the control screen we can write and read from the microcontroller
Start listening function will allow opening the serial port to read to whatever command
sent by the controller and stop listening will stop the C# from reading the controller.
Figure-4.3: Control Form (Screen)

of 148
3-The log screen will make historical data (time in/ out) for the customers have defined
tags and indicate the gates as well. See figure 4.4 below
Figure-4.4: LOG Form (Screen)
4-Option screen; will allow user to select communication port so that controller can
interface with C# program. See figure 4.5 below.
Option screen will also allow the user of the program to select Buad Rate- data
transmission rate (bits/second) for modems.
It will also allow user send notification of limited days valid in his account to used tags.The
option screen will user set validation of the tag: tag is used only by only one car at a
time.
Figure-4.5: Option Form (Screen)

of 148
CH 5: Cellular Shield with SM5100B
5.1 Description: The Cellular Shield for Arduino includes all the parts needed to interface
theArduino with an SM5100B cellular module. This allows addingSMS, GSM
functionalities to theArduino-based project. In order for the cellular shield to send SMS, SIM
card and an antenna are neededas well as sending texts.
5.2 About to GSM/GPRS Module - SM5100B, The SM5100B is a miniature, quad-band
GSM 850/EGSM 900/DCS 1800/PCS 1900 module, which can be integrated into a great
number of wireless projects. It can be used to accomplish almost anything a normal cell
phone can – such as SMS text messages.
This module features two UARTS, an SPI interface (Serial Peripheral Interface Bus), and
two 10-bit ADCs. It also supports Li-ion battery charging, a 4x6 keypad, and an LCD
interface. Inputs/outputs are available for a speaker and microphone. An antenna does come
attached to the module.
Power supplied to the module should be regulated between 3.3-4.2VDC (3.6V nominal).
RF Functionalities
The RF part of SM5100B module converts RF signals to baseband for receiver chain and
translates base bandsignals into RF frequency spectrum.
The operating frequencies are:
Rx (EGSM 850): 869 to 894MHz
Tx (EGSM 850): 824 to 849MHz
Rx (EGSM 900): 925 to 960MHz
Tx (EGSM 900): 880 to 915MHz
Rx (DCS 1800): 1805 to 1880MHz
Tx (DCS 1800): 1710 to 1785MHz
Rx (PCS 1900): 1930 to 1990MHz
Tx (PCS 1900): 1850 to 1910MHz

of 148
5.3 Main Components of Cellular Shield:
 60-pin SM5100B connector,
 a SIM card socket, and
 SPX29302 voltage regulator configured to regulate the Arduino's raw voltage to 3.8V.
 The board's red LED indicates power. The Arduino's reset button is also brought out
on the shield.
5.4 Schematic Diagram of Cellular Shield
Figure-5.1: Schematic Diagram of Cellular Shield

of 148
5.5SM5100B-D GSM/GPRS Module Specification (Preliminary)
Connection 60 pins
Power supply VBAT: 3.3V to 4.2V range, 3.6V typical.
Power consumption Off mode: <100uA
Sleep mode: <2.0mA
Idle mode: <7.0mA (average)
Communication mode: 350 mA (average,GSM)
Communication mode: 2000mA (Typical peak
during TX slot,GSM)
Li-ion Battery charging management and
interface (OPTION)
Li-ion Battery charging management is included.
The charger Interface is provided on 60-pin
connector
. (only for 3.7V Li-ion Battery)
Frequency bands EGSM900 +GSM850+ DCS1800+PCS1900
Transmit power Class 4 (2W) for EGSM900/GSM850
Class 1 (1W) for DCS1800/PCS1900
Supported SIM card 3V/1.8V SIM card. (auto recognise)
Keyboard interface 4x6 keyboard interface is provided
UART0 interface with flow control Up to 460 kbps
Full hardware flow control signals (+3.0V) are
provided on 60 pins.
UART1 interface without flow control 2-Wire UART interface
Up to 460 kbps
LCD interface Support standard SPI interface,
Temperature range Normal range: -10°C to +55°C (full compliant)
Storage: -40°C to +85°C
Weight < 9g
Physical dimensions 35.0X39.0X2.9 mm (typical)
5.7 Power Consumption
Mode Condition I(Typ) I(Max)
Off mode off 1.6 A 2 A
GSM850/900mode During TX bursts
@PCL5*
100 mA 130 mA
GSM850/900 mode During RX bursts 350 mA 400 mA
GSM850/900 mode Average @PCL5* 250 mA 300 mA
GSM850/900 mode Average @PCL8* 250 mA 20 mA
GSM850/900 mode Average idle mode 13 mA 20 mA
5.8 Connection with Arduino Mega 2560
Jumper wire from GSM shield pin D2 to Mega pin 19,
Jumper from GSM shield pin D3 to Mega pin 18, as shown figure 5.1 next page
Figure 5.1 in next page indicates how the connection is done.

of 148
Chapter 6: Set up,Testing and Results
6.1 Setup and Connection
This test is to check the integration of RFID reader, LED matrix, servo motor, and IR sensor
which are essential for a reliable operation of our parking monitoring system.
For this test, the code in appendix A was used by sending it to the Arduino using
Arduinoprogram. Thefollowing connections shown in the figures below were made:
6.1.1RFID readers
Both RFID readers have been tested after the set up shown in figure 6.1 next page
At the entry:
At the exit:
Figure-5.1: Cellular ShieldConnection with Arduino Mega 2560

of 148
Figure-6.1 : Entry, Exit RFID ID-12 Readers and Arduino connection
6.1.2LED Display
The interface test of LED display with Arduino UNO was done after the following
connection has been made as shown in figure 6.2 next page
VCC (red) to the +5Vat Arduino Board
Ground (black) to ground at the Arduino
DATA(orange) tothe digital pin 2 (As configured in the program)
WRITE (yellow) to the digital pin 3 (As configured in the program)
CS0 (white) to the digital pin 4 (As configured in the program)

of 148
Figure-6.2 : Connection between LED Matrix and Arduino
6.1.3Servo Motor
At the entry:
Black wire is connected to the ground at the Arduino
Red wire connected to the +5V DC at the Arduino
White wire in the motor is the pulse and it is connected to the digital output in
Arduino configured at pin 10
At the exit:
White wire in the motor is the pulse and it is connected to the digital output in
Arduino configured at pin 9
See figure 6.3 for connecting two servo motor with Arduino

of 148
Figure-6.3 : Connection between Entry, Exit Servo Motor and Arduino
6.1.4Sharp IR Sensor
At the entry:
Yellow wire in the IR is the analog reading and it is connected to analog input in
Arduino configured at pin A2
At the exit:
Yellow wire in the IR is the analog reading and it is connected to analog input in
Arduino configured at pin A1
Figure 6.4 below indicates the connection of two IR sensors with Arduino.
Figure-6.4 : Connection between Entry, Exit IR Sensor and Arduino

of 148
6.2Results of Testing of RFID Readers Circuit
After making the above connection and setup, the parking monitoring system was tested with
successful results as follows:
1. At the moment of sending the code to the Arduino, The display shows 10 free
parkings. See fiigre 6.5
Figure-6.5 : Free 10 Display
4. If an employee tag is scanned , the counter will be decremented and the gate will open
as indicated in the figure 6.6
Figure-6.6 : Employee Display and gate opening
2. The gate does not close until the car gets in.

of 148
3. If student tag was scanned , the gate will open, and the counter will be decremented
as indicated in figure 6.7.
Figure-6.7: Student Display and gate opening
4. The gate does not close until the car gets in.
5. If the car left the parking, the gate will open and the counter will be incremented.
6. The gate does not close until the car gets out.
7. If the parking is full, then display will show ―Full‖ as shown in figurer 6.8.
Figure-6.8 : Full Display

of 148
8. If the person is not authorized, the display will be show‖Not Auth ‖ as in figure 6.9.
Figure-6.9: Not Authorized Display
9. If there is a visitor, then the gate can be opened using push button and that will be
shown in the display and recorded in the database.
6.3C#,Testingof Interfacing with Arduino Microcontroller
This test is to check the interfacing between the C# program with the microcontroller
connected with RFID readers, servo motors and LED matrix.Refer to figure 6.10,figure 6.11,
figure 6.12 and figure 6.13.
Figure-6.10 : Control Screen Test With A Valid REID Tag User.
The above shows our Dr.Samir Elnakla and showed that he is authorized and his membership
is vlaid to enter the parking.

of 148
Figure-6.11 : Historical log and Export option
Figure-6.12 : Database of Registered Users

of 148
Figure-6.12 : Option Tab
Regarding E-mail notification, the registered user on the database and automatic e-mail
notification will be sent to the user when his membership is soon to expire. The below figure
shows an example of the email notification sent through customer's email.
Figure-6.13 : Option Screen With Sending Notifcation Email (B)

of 148
However, the latest test conducted on C# are shown in the figures below. But now these
include a mojor feature of the system which is sending SMS notifications upon the entry of
the car park user.According to the type of SMS subscriptions the user is subscirbed to, the
user recieves SMS notification about events, car park regulations, renewing membership or
any message intended to be sent.
Figure-6.14 : SMS Alert Subscription
The blow figures 6.15 shows the entries for adding or editing a user which includes RFID tag,
customer's name, mobile, email, expiration date, photo and the SMS subscriptiions.
The advantage of using this technique of SMS subscription is the flexibility to send any
message for any purpose to the users of the parking system.

of 148
Figure 6.15: Two samples of customers' info registered in the database

of 148
Chapter 7: Difficulties, Refinement, and Conclusion
7.1 Difficulties and Obstacles
Many challenges were face in the project such as:
• Learning Arduino programming languages which is based special programming
language in addition to C.
• Learning database programming language (C#) which mainly based on Java and C or
C++. This is merely for software or IT professionals but taking the challenge was
overwhelming and interesting but yet difficult with slow progress.
• Solving the conflicts between RFID and LED matrix when connecting them with
Arduino.
• Controlling the motor forward and reverse rotation using DC motor; however, finally
servomotors were used since programing codes only needed without complicated
hardware design.
7.2 Product Refinement
In circuit design, itwas decided to change the DC motor with the servo motor type. That is
due to its simplicity and reliabilit. Unlike DC motor, it does not require using H-bridge or
transistor for smooth operation achievement.
7.3Conclusions
In the conclusion we say:
1. The course was interesting and challenging to us. It was interesting to use the
knowledge you earned to build a real circuit which is based on theories and
engineering problems. One of the most important challenges that faced is the little
experience in dealing with C language and C# language in addition to electronic
circuits. Another challenge was selecting the appropriate components for project such
as motors and its availability in the market.
2. Performing functional test of the electronic components is important prior to building
the circuit and the testing. Also, having testing equipment in the weekend could have
helped a lot in avoiding delays.

of 148
3. During undergraduate studies, there is no adequate skills and knowledge about
microcontroller languages, operation, and design. This is why most of the project time
was focusing on programming the Arduino and creating the data base which required
extra efforts and more time.
4. The group tasks list were divided as follows:
- Power Supply: Ali and Mustafa
- RFID, IR, servo, and Display: Muneer and Salman
- Arduino hardware: All group
- Arduino software (creating the parking system code): Muneer and Salman
- Data base (C#): Ali and Mustafa
However, teamwork requires that everybody to contribute in every subsystem. In fact,
every member spent effort, has a role in each subsystem, and gained the knowledge about
the whole project subsystems. So, the actual work list can sometimes change according
to the needs and other factors as well.

of 148
Chapter 8: Real Implementation (Future Work)
In the real implementation of the parking system, we will be seeking cost effective and
reliable product which will guide drivers into the nearest parking space automatically;
To achieve this, we would use:
 A camera for more security precautions. The camera
costs $75 (amazon)Wireless G Network Camera
DCS 920
 Ultrasonic sensor since it has longer range of
detection and more accurate under sun light. Ultrasonic detector type KEYTOP
Figure 8.1: KEYTOP Ultrasonic Detecting Sensor
Operating Voltage DC 24V
Operating Current 10mA
Power 0.24W
Communication Method RS485
Detecting Distance 0.1~3.5m
Communication Distance ≤1000m
Communication Rate 4800bps
Operating Temperature -20°C~80°C
Table 8.1: KEYTOP Ultrasonic Detecting Sensor Specification

of 148
 The LED display as shown in the figure below will be installed at the main entrances of
car park and the intersections of the main channels. In other places, it can be installed
according to the needs. Display the quantity of the current free parking spaces in the
connected region in the form of number and text. It can be 24-hour used. The internal
procedures can be modified at any time according to the customers' demands to display
the other needed information of the users.
Figure 8.2: LED Display
Operating Voltage DC5V, 5A
Panel size 36cm*12cm
Dot matrix 48*16
Luminance 300cd/m2
Table 8.2: LED Display Specification
 Central controller unit as shown in the figure below can handle huge amounts of
information wirelessly. Look at the table below for more specifications about CCU.
Figure 8.3: GCCU (General Central Control Unit)

of 148
Operating Voltage DC 5V
Operating current 375 mA
Power 1.875W
Communication way RS485,LAN,wireless
Communication Distance ≤1000m
Maximum Number of Connections 64 node controllers
Operating Temperature -20°C~+80°C
Table 8.3: GCCU Specifications
1- Parking guidance system type SP2-114. The SP2-114 signal parking guidance sensor
is use for signalling car parks vacant spaces designed for very busy car parks,
regardless of size. It is especially advantageous for multi-storey car parks where
motorists often find themselves driving round in vain to find an empty space. The
parking system ensures they will find one using guidance sensor directly to it in real
time, by floor, zone and lane.
2- 110 series AC servo motor type Hitec which can withstand high temperature
environment of -20 to 60 degree centigrade.
3- 120/220V relay connected with Arduino to control AC motors that are proposed to be
used for gates

of 148
7 Bibliography
1. Neamen, D. A. (3rd Edition). Microelectronics, Circuit Analysis and Design.
2. Ultrasonic VS infrared sensors, 2009,http://bildr.org/2011/02/rfid-arduino/
3. https://www.sparkfun.com/products/8419?
4. http://www.sparkfun.com/datasheets/Sensors/ID-12-Datasheet.pdf
5. http://www.mobiusconsulting.com/papers/HFE0805_RFIDTutorial.pdf
6. http://ladyada.net/products/16x24LEDmatrix/
7. http://www.zebra.com/id/zebra/na/en/documentlibrary/manuals/en/rfid_program
ming_guide_P1026148-001.File.tmp/P1026148-
001.pdf?dvar1=ProductLiterature&dvar2=RFID%20Programming%20Guide%20(P102
6148-001)%20(en)&dvar3=10662
8. http://csrc.nist.gov/publications/nistpubs/800-98/SP800-98_RFID-2007.pdf
9. (http://arduino.cc/en/Tutorial/HomePage
10. (http://www.jeremyblum.com/category/arduino-tutorials/)
11. (http://www.adafruit.com/tutorials)
12. https://www.sparkfun.com/products/10782
13. http://download.cnet.com/Personal-C-Sharp/3000-10247_4-10509460.html
14. http://www.codeproject.com/Articles/473828/Arduino-Csharp-and-serial-interface
15. http://arduino.cc/forum/index.php/topic%2c131445.0.html

of 148
14 Appendix A: Code of Arduino Software
#include <Servo.h>
#include "HT1632.h"
#define DATA 2
#define WR 3
#define CS 4
#define CS2 5
//int max =10;
//max count of cars
int count = 10;
//mssage id to write on the screen
int scrwrt =0;
int newtag =0;
int entrybutton =8;
int exitbutton =9;
int button_status =0;
int oldbtn_status=0;
int exitbtn_status=0;
int oldexitbtn_status=0;
int ledpin=7;
// vars to controle when counter goes less then zero or up more than ten
int fl=0;
int fr=0;
// use this line for single matrix
HT1632LEDMatrix matrix = HT1632LEDMatrix(DATA, WR, CS);
int RFIDResetPin = 13;
//Register your RFID tags here
// there is no need for those tags when we connect to computer because we will find tags
saved to computer later
char tag1[16] = "5100FEF6633A";
char tag2[16] = "4F0056E830C1";
//non used yet vars
int maxcars = 12;
int updown=0;
int oldexittag=0;
int oldentrytag=0;
//doors servo variable area
int open_door=1;
int close_door=0;

of 148
int entry_pin=10;
Servo entry_door;
int exit_pin=11;
Servo exit_door;
//this is ir distance
int ir_entry_pin = 1;
int ir_exit_pin = 2;
float ir_free_dsitance=40;//20 cm this is brown area Moneer
//doorcase
int entry_door_case=0; // 0 closed, 1= open
int exit_door_Case=0;
void setup(){
//init debugging and computer connection serial
Serial.begin(9600);
//init serials for two rfids please salman
Serial2.begin(9600);
Serial3.begin(9600);
//send count to computer
Serial.println(count);
scrwrt=10;
//init servo motors
init_door(entry_door, entry_pin);
init_door(exit_door, exit_pin);
// call init the ledscr procedure from its library
matrix.begin(HT1632_COMMON_16NMOS);
// fill all dots for 500 ms
matrix.fillScreen();
delay(500);
//clear led screen
matrix.clearScreen();
pinMode(entrybutton, INPUT);
pinMode(exitbutton, INPUT);
pinMode(ledpin, OUTPUT);
//initrfid
pinMode(RFIDResetPin, OUTPUT);
digitalWrite(RFIDResetPin, HIGH);
//write to led sceen
matrix.print("on..");
// update the led screen
matrix.writeScreen();

of 148
button_status=digitalRead(entrybutton);
exitbtn_status=digitalRead(exitbutton);
}
int release1=0;
int release2=0;
void loop(){
char tagString[13];
int index = 0;
boolean reading = false;
button_status=digitalRead(entrybutton);
exitbtn_status =digitalRead(exitbutton);
if ((button_status ==1) && (oldbtn_status==0))
{
oldbtn_status = button_status;
digitalWrite(ledpin, HIGH);
}
else if ((button_status ==0) && (oldbtn_status==1))
{
oldbtn_status = button_status;
digitalWrite(ledpin, 0);
release1 = 1;
//process_entry();
scrwrt =8;
updown=-1;
count +=updown;
if ((updown<0)&&(count==0))
{
scrwrt=13;
}
else if((updown>0)&&(count==10))
{
scrwrt=10;
}
}
if ((exitbtn_status ==1) && (oldexitbtn_status==0))
{
oldexitbtn_status = exitbtn_status;
digitalWrite(ledpin, HIGH);
}
else if ((exitbtn_status ==0) && (oldexitbtn_status==1))
{

of 148
oldexitbtn_status = exitbtn_status;
digitalWrite(ledpin, 0);
release2 = 1;
scrwrt =8;
updown = 1;
count +=updown;
{
scrwrt=13;
}
{
scrwrt=10;
}
}
// test if there is a message we want to output
if (scrwrt> 0)
{
// scrwrt==10 raise when park is free and contain 0 cars
if (scrwrt==10)
{
if (fr==0) //
{
rstscr(); // see the comment near the procedure it self
matrix.print("Free");
matrix.setCursor(7, 8); // next line, 8 pixels down
matrix.print(count);
fr++; // fr prevent counter goes less than 0
if (updown>0) {
process_exit();
release2=0;
Serial.println("process entry");
}
}
}
if (scrwrt==13)
{
if(fl==0)
{
rstscr();
matrix.print("Full");
fl++;//fl prevent counter goes more than 10

of 148
count=0;
if (updown<0) {
process_entry();
Serial.println("process exit");
release1=0;
}
//else
//{
//
// process_exit();
// release2=0;
//Serial.println("process entry");
//}
}
}
if (scrwrt==1)// non vaild tag
{
fl=0;
fr=0;
rstscr();
matrix.print("Not");
matrix.print("Auth");
delay(1000);
rstscr(); // see the comment near the procedure it self
matrix.print("Free");
}
if (scrwrt==2&&count<10) // valid tag received
{
fl=0;
fr=0;
rstscr();
matrix.print("stu:");

of 148
//open or close the door
if (updown<0) {
process_entry();
release1=0;
}
else if (updown>0)
{
process_exit();
release2=0;
}
else
{
scrwrt=10;
}
}
if (scrwrt==3&&count<10) // vaild tag emp recieved
{
fl=0;
fr=0;
rstscr();
matrix.print("emp:");
if (updown<0) {
process_entry();
release1=0;
}
else if (updown>0)
{
process_exit();
release2=0;
}
else {
scrwrt=10;
}
}

of 148
if (scrwrt==4) // valid tag received
{
fl=0;
fr=0;
rstscr();
matrix.print("Vis:");
if (updown<0) {
process_entry();
release1=0;
}
else
{
process_exit();
release2=0;
}
}
if (scrwrt==8) // valid tag received
{
fl=0;
fr=0;
rstscr();
matrix.print("Vis:");
if (updown<0) {
process_entry();
release1=0;
}
else
{
process_exit();

of 148
release2=0;
}
}
scrwrt=0;
}
clearTag(tagString); //Clear the char of all value
// if there is tag near serial2 reader catch it
while(Serial2.available()){
int readByte = Serial2.read(); //read next available byte Entry
if(readByte == 2) reading = true; //begining of tag
if(readByte == 3) reading = false; //end of tag
if(reading &&readByte != 2 &&readByte != 10 &&readByte != 13){
//store the tag
tagString[index] = readByte;
index ++;
}
//scrwrt=1; //put message
updown=-1; // the tag is for entry so updown is positave
}
// if there is tag near serial3 rfid catch it Exit
while(Serial3.available()){
int readByte = Serial3.read(); //read next available byte
if(readByte == 2) reading = true; //begining of tag
if(readByte == 3) reading = false; //end of tag
if(reading &&readByte != 2 &&readByte != 10 &&readByte != 13){
//store the tag
tagString[index] = readByte;
index ++;
}
//scrwrt=1;
updown=1;// the tag is for exit so updown is positave
}
checkTag(tagString); //Check if it is a match
resetReader(); //reset the RFID reader
}
// if new tag came it must processed
void checkTag(char tag[]){
if((strlen(tag) == 0)&& (release1==0 ))
return; //empty, no need to continue

of 148
{
scrwrt=13;// FULL
}
{
scrwrt=10; // Free 10
}
else if(compareTag(tag, tag1))
{ // if matched tag1, do this
count +=updown;
// need to open the door or close it
//Serial.println(count);
if (count >0)
{scrwrt =2;// student
}
}
else if(compareTag(tag, tag2))
{ //if matched tag2, do this
count +=updown;
Serial3.println(count);
scrwrt=3;// employee
}
else {
scrwrt=1;
//Serial.print("unknown");
//Serial.println(tag);
}
}
void lightLED(int pin){
///////////////////////////////////
//Turn on LED on pin "pin" for 250ms
///////////////////////////////////
Serial.println(pin);
digitalWrite(pin, HIGH);
delay(250);
digitalWrite(pin, LOW);
}
void resetReader(){
///////////////////////////////////
//Reset the RFID reader to read again.
///////////////////////////////////
digitalWrite(RFIDResetPin, LOW);
digitalWrite(RFIDResetPin, HIGH);

of 148
delay(150);
}
void clearTag(char one[]){
///////////////////////////////////
//clear the char array by filling with null - ASCII 0
//Will think same tag has been read otherwise
///////////////////////////////////
for(int i = 0; i <strlen(one); i++){
one[i] = 0;
}
}
boolean compareTag(char one[], char two[]){
///////////////////////////////////
//compare two value to see if same,
//strcmp not working 100% so we do this
///////////////////////////////////
if(strlen(one) == 0) return false; //empty
for(int i = 0; i < 12; i++){
if(one[i] != two[i]) return false;
}
return true; //no mismatches
}
void rstscr() // clear screen and reset font , cursor position, finally it update the screen
{
matrix.clearScreen();
matrix.setTextSize(1); // size 1 == 8 pixels high
matrix.setTextColor(1); // 'lit' LEDs
matrix.setCursor(0, 0);
}
void init_door(Servo door, int pin)
{
door.attach(pin);
Serial.println();
Serial.print("door pin ");
Serial.print(pin);
Serial.println(" attached");
}
void change_door(Servo door, int door_case)
{

of 148
Serial.println();
Serial.print("door case");
Serial.print(door_case);
Serial.println();
if(door_case==0)
{
door.write(90);
}
else
{
door.write(180);
}
}
int test_ir(int ir_pin)
{
float volts = analogRead(ir_pin)*0.0048828125; // value from sensor * (5/1024) - if
running 3.3.volts then change 5 to 3.3
float distance = 65*pow(volts, -1.10); // worked out from graph 65 = theretical
distance
if (distance<ir_free_dsitance) return 0;
else return 1;
}
void process_exit()
{
change_door(exit_door, open_door);
while (test_ir(ir_exit_pin)>0) ;
//delay(500);
change_door(exit_door, close_door);
}
void process_entry()
{
change_door(entry_door, open_door);
//delay(500);
while (test_ir(ir_entry_pin)>0) ;
change_door(entry_door, close_door);
}

of 148
15 Appendix B: Code of C # (Sharp) Data Base
namespace ParkingManager
{
partial class FormMain
{
/// <summary>
/// Required designer variable.
/// </summary>
private System.ComponentModel.IContainer components = null;
/// <summary>
/// Clean up any resources being used.
/// </summary>
/// <param name="disposing">true if managed resources should be disposed;
otherwise, false.</param>
protected override void Dispose(bool disposing)
{
if (disposing && (components != null))
{
components.Dispose();
}
base.Dispose(disposing);
}
#region Windows Form Designer generated code
/// <summary>
/// Required method for Designer support - do not modify
/// the contents of this method with the code editor.
/// </summary>
private void InitializeComponent()
{
this.components = new System.ComponentModel.Container();
System.ComponentModel.ComponentResourceManager resources = new
System.ComponentModel.ComponentResourceManager(typeof(FormMain));
this.panel1 = new System.Windows.Forms.Panel();
this.menuStrip1 = new System.Windows.Forms.MenuStrip();
this.systemToolStripMenuItem = new
System.Windows.Forms.ToolStripMenuItem();
this.openDatabaseToolStripMenuItem = new
this.saveDatabaseToolStripMenuItem = new
this.exitToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
this.helpToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
this.aboutToolStripMenuItem = new
this.tabControl1 = new System.Windows.Forms.TabControl();
this.tabPage1 = new System.Windows.Forms.TabPage();
this.listViewCustomers = new System.Windows.Forms.ListView();
this.columnHeader1 = ((System.Windows.Forms.ColumnHeader)(new
System.Windows.Forms.ColumnHeader()));
this.buttonSMS = new System.Windows.Forms.Button();

of 148
this.buttonDeleteTag = new System.Windows.Forms.Button();
this.buttonEditTag = new System.Windows.Forms.Button();
this.buttonAddTag = new System.Windows.Forms.Button();
this.label1 = new System.Windows.Forms.Label();
this.txtCommandsLog = new System.Windows.Forms.TextBox();
this.groupBox7 = new System.Windows.Forms.GroupBox();
this.buttonWriteArduino = new System.Windows.Forms.Button();
this.textBoxWriteArduino = new System.Windows.Forms.TextBox();
this.buttonArduinoWrite = new System.Windows.Forms.Button();
this.textBoxReadArduino = new System.Windows.Forms.TextBox();
this.pictureBox2 = new System.Windows.Forms.PictureBox();
this.comboBoxGate = new System.Windows.Forms.ComboBox();
this.txtFreeParking = new System.Windows.Forms.TextBox();
this.txtTotalParkingCount = new System.Windows.Forms.TextBox();
this.buttonSetParking = new System.Windows.Forms.Button();
this.txtLED = new System.Windows.Forms.TextBox();
this.buttonDisplayLED = new System.Windows.Forms.Button();
this.buttonCloseGate = new System.Windows.Forms.Button();
this.buttonOpenGate = new System.Windows.Forms.Button();
this.buttonStopListening = new System.Windows.Forms.Button();
this.buttonStartListening = new System.Windows.Forms.Button();
this.listViewLog = new System.Windows.Forms.ListView();
this.imageList1 = new System.Windows.Forms.ImageList(this.components);
this.buttonExport = new System.Windows.Forms.Button();
this.checkBoxTag1 = new System.Windows.Forms.CheckBox();
this.textBoxSmsApi = new System.Windows.Forms.TextBox();
this.textBoxSmsPassword = new System.Windows.Forms.TextBox();
this.textBoxSmsAccount = new System.Windows.Forms.TextBox();
this.textBoxGmailPassword = new System.Windows.Forms.TextBox();

of 148
this.textBoxGmailAccount = new System.Windows.Forms.TextBox();
this.comboBoxNotifcations = new System.Windows.Forms.ComboBox();
this.checkBoxNotifications = new System.Windows.Forms.CheckBox();
this.comboBoxStopBits = new System.Windows.Forms.ComboBox();
this.comboBoxParity = new System.Windows.Forms.ComboBox();
this.comboBoxDataBits = new System.Windows.Forms.ComboBox();
this.comboBoxRate = new System.Windows.Forms.ComboBox();
this.comboBoxPortName = new System.Windows.Forms.ComboBox();
this.listBoxSMS = new System.Windows.Forms.ListBox();
this.buttonEditMsg = new System.Windows.Forms.Button();
this.buttonRemoveMsg = new System.Windows.Forms.Button();
this.buttonAddMsg = new System.Windows.Forms.Button();
this.listBoxSMSCategory = new System.Windows.Forms.ListBox();
this.buttonRemoveCategory = new System.Windows.Forms.Button();
this.buttonAddCategory = new System.Windows.Forms.Button();
this.timer1 = new System.Windows.Forms.Timer(this.components);
this.imageList2 = new System.Windows.Forms.ImageList(this.components);
this.panel1.SuspendLayout();
this.menuStrip1.SuspendLayout();
this.tabControl1.SuspendLayout();
this.tabPage1.SuspendLayout();
this.groupBox7.SuspendLayout();
((System.ComponentModel.ISupportInitialize)(this.pictureBox2)).BeginInit();
this.SuspendLayout();
//
// panel1
//
this.panel1.Controls.Add(this.menuStrip1);
this.panel1.Dock = System.Windows.Forms.DockStyle.Top;

of 148
this.panel1.Location = new System.Drawing.Point(0, 0);
this.panel1.Name = "panel1";
this.panel1.Size = new System.Drawing.Size(850, 61);
this.panel1.TabIndex = 0;
//
// menuStrip1
//
this.menuStrip1.Items.AddRange(new System.Windows.Forms.ToolStripItem[] {
this.systemToolStripMenuItem,
this.helpToolStripMenuItem});
this.menuStrip1.Location = new System.Drawing.Point(0, 0);
this.menuStrip1.Name = "menuStrip1";
this.menuStrip1.Size = new System.Drawing.Size(850, 24);
this.menuStrip1.TabIndex = 0;
this.menuStrip1.Text = "menuStrip1";
//
// systemToolStripMenuItem
//
this.systemToolStripMenuItem.DropDownItems.AddRange(new
System.Windows.Forms.ToolStripItem[] {
this.openDatabaseToolStripMenuItem,
this.saveDatabaseToolStripMenuItem,
this.exitToolStripMenuItem});
this.systemToolStripMenuItem.Name = "systemToolStripMenuItem";
this.systemToolStripMenuItem.Size = new System.Drawing.Size(57, 20);
this.systemToolStripMenuItem.Text = "System";
//
// openDatabaseToolStripMenuItem
//
this.openDatabaseToolStripMenuItem.Name = "openDatabaseToolStripMenuItem";
this.openDatabaseToolStripMenuItem.Size = new System.Drawing.Size(154,
22);
this.openDatabaseToolStripMenuItem.Text = "Open Database";
this.openDatabaseToolStripMenuItem.Click += new
System.EventHandler(this.openDatabaseToolStripMenuItem_Click);
//
// saveDatabaseToolStripMenuItem
//
this.saveDatabaseToolStripMenuItem.Name = "saveDatabaseToolStripMenuItem";
this.saveDatabaseToolStripMenuItem.Size = new System.Drawing.Size(154,
22);
this.saveDatabaseToolStripMenuItem.Text = "Save Database";
this.saveDatabaseToolStripMenuItem.Click += new
System.EventHandler(this.saveDatabaseToolStripMenuItem_Click);
//
// exitToolStripMenuItem
//
this.exitToolStripMenuItem.Name = "exitToolStripMenuItem";
this.exitToolStripMenuItem.Size = new System.Drawing.Size(154, 22);
this.exitToolStripMenuItem.Text = "Exit";
this.exitToolStripMenuItem.Click += new
System.EventHandler(this.exitToolStripMenuItem_Click);
//
// helpToolStripMenuItem
//
this.helpToolStripMenuItem.DropDownItems.AddRange(new
System.Windows.Forms.ToolStripItem[] {
this.aboutToolStripMenuItem});
this.helpToolStripMenuItem.Name = "helpToolStripMenuItem";
this.helpToolStripMenuItem.Size = new System.Drawing.Size(44, 20);
this.helpToolStripMenuItem.Text = "Help";
//
// aboutToolStripMenuItem
//
this.aboutToolStripMenuItem.Name = "aboutToolStripMenuItem";

of 148
this.aboutToolStripMenuItem.Size = new System.Drawing.Size(107, 22);
this.aboutToolStripMenuItem.Text = "About";
this.aboutToolStripMenuItem.Click += new
System.EventHandler(this.aboutToolStripMenuItem_Click);
//
// panel2
//
this.panel2.Controls.Add(this.tabControl1);
this.panel2.Dock = System.Windows.Forms.DockStyle.Fill;
//
// tabControl1
//
this.tabControl1.Controls.Add(this.tabPage1);
this.tabControl1.Dock = System.Windows.Forms.DockStyle.Fill;
this.tabControl1.Location = new System.Drawing.Point(0, 0);
this.tabControl1.Name = "tabControl1";
this.tabControl1.SelectedIndex = 0;
this.tabControl1.Size = new System.Drawing.Size(850, 532);
this.tabControl1.TabIndex = 0;
//
// tabPage1
//
this.tabPage1.Controls.Add(this.listViewCustomers);
this.tabPage1.Controls.Add(this.panel3);
this.tabPage1.Location = new System.Drawing.Point(4, 22);
this.tabPage1.Name = "tabPage1";
this.tabPage1.Padding = new System.Windows.Forms.Padding(3);
this.tabPage1.Size = new System.Drawing.Size(842, 506);
this.tabPage1.TabIndex = 0;
this.tabPage1.Text = "TAGs";
this.tabPage1.UseVisualStyleBackColor = true;
//
// listViewCustomers
//
this.listViewCustomers.Columns.AddRange(new
System.Windows.Forms.ColumnHeader[] {
this.columnHeader1,
this.columnHeader2,
this.columnHeader3,
this.columnHeader8,
this.columnHeader4});
this.listViewCustomers.Dock = System.Windows.Forms.DockStyle.Fill;
this.listViewCustomers.FullRowSelect = true;
this.listViewCustomers.Location = new System.Drawing.Point(3, 3);
this.listViewCustomers.Name = "listViewCustomers";
this.listViewCustomers.Size = new System.Drawing.Size(717, 500);
this.listViewCustomers.TabIndex = 1;
this.listViewCustomers.UseCompatibleStateImageBehavior = false;
this.listViewCustomers.View = System.Windows.Forms.View.Details;
this.listViewCustomers.SelectedIndexChanged += new
System.EventHandler(this.listViewCustomers_SelectedIndexChanged);
//
// columnHeader1
//
this.columnHeader1.Text = "TAG Number";
this.columnHeader1.Width = 120;
//

of 148
// columnHeader2
//
this.columnHeader2.Text = "Customer Name";
//
// columnHeader3
//
this.columnHeader3.Text = "Customer Mobile";
//
// columnHeader8
//
this.columnHeader8.Text = "Customer Email";
//
// columnHeader4
//
this.columnHeader4.Text = "TAG Expiration Date";
//
// panel3
//
this.panel3.Controls.Add(this.buttonSMS);
this.panel3.Controls.Add(this.buttonDeleteTag);
this.panel3.Controls.Add(this.buttonEditTag);
this.panel3.Controls.Add(this.buttonAddTag);
this.panel3.Controls.Add(this.label1);
this.panel3.Dock = System.Windows.Forms.DockStyle.Right;
//
// buttonSMS
//
this.buttonSMS.Location = new System.Drawing.Point(9, 149);
this.buttonSMS.Name = "buttonSMS";
this.buttonSMS.Size = new System.Drawing.Size(75, 23);
this.buttonSMS.TabIndex = 4;
this.buttonSMS.Text = "SMS";
this.buttonSMS.UseVisualStyleBackColor = true;
this.buttonSMS.Click += new System.EventHandler(this.buttonSMS_Click);
//
// buttonDeleteTag
//
this.buttonDeleteTag.Location = new System.Drawing.Point(9, 93);
this.buttonDeleteTag.Name = "buttonDeleteTag";
this.buttonDeleteTag.Size = new System.Drawing.Size(75, 23);
this.buttonDeleteTag.TabIndex = 3;
this.buttonDeleteTag.Text = "Delete";
this.buttonDeleteTag.UseVisualStyleBackColor = true;
this.buttonDeleteTag.Click += new
System.EventHandler(this.buttonDeleteTag_Click);
//
// buttonEditTag
//
this.buttonEditTag.Location = new System.Drawing.Point(9, 64);
this.buttonEditTag.Name = "buttonEditTag";
this.buttonEditTag.Size = new System.Drawing.Size(75, 23);
this.buttonEditTag.TabIndex = 2;
this.buttonEditTag.Text = "Edit";
this.buttonEditTag.UseVisualStyleBackColor = true;
this.buttonEditTag.Click += new
System.EventHandler(this.buttonEditTag_Click);
//

of 148
// buttonAddTag
//
this.buttonAddTag.Location = new System.Drawing.Point(9, 35);
this.buttonAddTag.Name = "buttonAddTag";
this.buttonAddTag.Size = new System.Drawing.Size(75, 23);
this.buttonAddTag.TabIndex = 1;
this.buttonAddTag.Text = "Add";
this.buttonAddTag.UseVisualStyleBackColor = true;
this.buttonAddTag.Click += new
System.EventHandler(this.buttonAddTag_Click);
//
// label1
//
this.label1.AutoSize = true;
this.label1.Location = new System.Drawing.Point(6, 9);
this.label1.Name = "label1";
this.label1.Size = new System.Drawing.Size(42, 13);
this.label1.TabIndex = 0;
this.label1.Text = "Actions";
//
// tabPage3
//
this.tabPage3.Controls.Add(this.txtCommandsLog);
this.tabPage3.Text = "Control";
//
// txtCommandsLog
//
this.txtCommandsLog.BackColor = System.Drawing.SystemColors.GrayText;
this.txtCommandsLog.Dock = System.Windows.Forms.DockStyle.Fill;
this.txtCommandsLog.Font = new System.Drawing.Font("Microsoft Sans Serif",
9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.txtCommandsLog.ForeColor = System.Drawing.Color.White;
this.txtCommandsLog.Location = new System.Drawing.Point(0, 0);
this.txtCommandsLog.Multiline = true;
this.txtCommandsLog.Name = "txtCommandsLog";
this.txtCommandsLog.ReadOnly = true;
this.txtCommandsLog.ScrollBars = System.Windows.Forms.ScrollBars.Vertical;
this.txtCommandsLog.Size = new System.Drawing.Size(653, 309);
this.txtCommandsLog.TabIndex = 7;
this.txtCommandsLog.TextChanged += new
System.EventHandler(this.txtCommandsLog_TextChanged);
//
// panel4
//
this.panel4.Controls.Add(this.groupBox7);
this.panel4.Controls.Add(this.pictureBox2);
this.panel4.Controls.Add(this.pictureBox1);
this.panel4.Dock = System.Windows.Forms.DockStyle.Bottom;
//
// groupBox7
//
this.groupBox7.Controls.Add(this.buttonWriteArduino);
this.groupBox7.Controls.Add(this.textBoxWriteArduino);
this.groupBox7.Controls.Add(this.label14);

of 148
this.groupBox7.Controls.Add(this.buttonArduinoWrite);
this.groupBox7.Controls.Add(this.textBoxReadArduino);
this.groupBox7.Location = new System.Drawing.Point(317, 10);
this.groupBox7.Name = "groupBox7";
this.groupBox7.Size = new System.Drawing.Size(321, 179);
this.groupBox7.TabIndex = 2;
this.groupBox7.TabStop = false;
this.groupBox7.Text = "Arduino Simulation";
//
// buttonWriteArduino
//
this.buttonWriteArduino.Location = new System.Drawing.Point(227, 131);
this.buttonWriteArduino.Name = "buttonWriteArduino";
this.buttonWriteArduino.Size = new System.Drawing.Size(88, 30);
this.buttonWriteArduino.TabIndex = 12;
this.buttonWriteArduino.Text = "Write Line";
this.buttonWriteArduino.UseVisualStyleBackColor = true;
this.buttonWriteArduino.Click += new
System.EventHandler(this.buttonWriteArduino_Click);
//
// textBoxWriteArduino
//
this.textBoxWriteArduino.Location = new System.Drawing.Point(6, 134);
this.textBoxWriteArduino.Multiline = true;
this.textBoxWriteArduino.Name = "textBoxWriteArduino";
this.textBoxWriteArduino.Size = new System.Drawing.Size(215, 27);
this.textBoxWriteArduino.TabIndex = 11;
//
// label14
//
this.label14.Text = "t=10230411,g=1,d=in,";
//
// label13
//
this.label13.Text = "t=[tag-number],g=[gate-number],d=[direction],";
//
// buttonArduinoWrite
//
this.buttonArduinoWrite.Location = new System.Drawing.Point(227, 28);
this.buttonArduinoWrite.Name = "buttonArduinoWrite";
this.buttonArduinoWrite.Size = new System.Drawing.Size(88, 30);
this.buttonArduinoWrite.TabIndex = 8;
this.buttonArduinoWrite.Text = "Read Line";
this.buttonArduinoWrite.UseVisualStyleBackColor = true;
this.buttonArduinoWrite.Click += new
System.EventHandler(this.buttonArduinoWrite_Click);
//
// textBoxReadArduino
//
this.textBoxReadArduino.Location = new System.Drawing.Point(6, 31);
this.textBoxReadArduino.Multiline = true;
this.textBoxReadArduino.Name = "textBoxReadArduino";
this.textBoxReadArduino.Size = new System.Drawing.Size(215, 27);
this.textBoxReadArduino.TabIndex = 7;

of 148
//
// pictureBox2
//
this.pictureBox2.Location = new System.Drawing.Point(214, 77);
this.pictureBox2.Name = "pictureBox2";
this.pictureBox2.Size = new System.Drawing.Size(56, 50);
this.pictureBox2.TabIndex = 1;
this.pictureBox2.TabStop = false;
//
// pictureBox1
//
//
// panel5
//
this.panel5.Controls.Add(this.comboBoxGate);
this.panel5.Controls.Add(this.buttonCloseGate);
this.panel5.Controls.Add(this.buttonOpenGate);
this.panel5.Controls.Add(this.buttonStopListening);
this.panel5.Controls.Add(this.buttonStartListening);
//
// comboBoxGate
//
this.comboBoxGate.FormattingEnabled = true;
this.comboBoxGate.Items.AddRange(new object[] {
"1",
"2",
"3",
"4"});
this.comboBoxGate.Location = new System.Drawing.Point(15, 146);
this.comboBoxGate.Name = "comboBoxGate";
this.comboBoxGate.Size = new System.Drawing.Size(69, 21);
this.comboBoxGate.TabIndex = 9;
//
// label10
//
this.label10.Text = "Gate No";
//
// groupBox3
//
this.groupBox3.Controls.Add(this.txtFreeParking);
this.groupBox3.Controls.Add(this.txtTotalParkingCount);
this.groupBox3.Controls.Add(this.buttonSetParking);

of 148
this.groupBox3.Text = "Parkings Count";
//
// label9
//
this.label9.Text = "Free";
//
// label2
//
this.label2.Text = "Total ";
//
// txtFreeParking
//
this.txtFreeParking.Location = new System.Drawing.Point(47, 102);
this.txtFreeParking.Multiline = true;
this.txtFreeParking.Name = "txtFreeParking";
this.txtFreeParking.Size = new System.Drawing.Size(75, 27);
this.txtFreeParking.TabIndex = 7;
//
// txtTotalParkingCount
//
this.txtTotalParkingCount.Location = new System.Drawing.Point(47, 69);
this.txtTotalParkingCount.Multiline = true;
this.txtTotalParkingCount.Name = "txtTotalParkingCount";
this.txtTotalParkingCount.Size = new System.Drawing.Size(75, 27);
this.txtTotalParkingCount.TabIndex = 6;
//
// buttonSetParking
//
this.buttonSetParking.Location = new System.Drawing.Point(47, 19);
this.buttonSetParking.Name = "buttonSetParking";
this.buttonSetParking.Size = new System.Drawing.Size(75, 42);
this.buttonSetParking.TabIndex = 5;
this.buttonSetParking.Text = "Set";
this.buttonSetParking.UseVisualStyleBackColor = true;
this.buttonSetParking.Click += new
System.EventHandler(this.buttonSetParking_Click);
//
// groupBox2
//
this.groupBox2.Controls.Add(this.txtLED);
this.groupBox2.Controls.Add(this.buttonDisplayLED);
this.groupBox2.Text = "LED Screen";
//
// txtLED
//
this.txtLED.Location = new System.Drawing.Point(6, 67);
this.txtLED.Multiline = true;

of 148
this.txtLED.Name = "txtLED";
this.txtLED.Size = new System.Drawing.Size(159, 85);
this.txtLED.TabIndex = 6;
//
// buttonDisplayLED
//
this.buttonDisplayLED.Location = new System.Drawing.Point(6, 19);
this.buttonDisplayLED.Name = "buttonDisplayLED";
this.buttonDisplayLED.Size = new System.Drawing.Size(75, 42);
this.buttonDisplayLED.TabIndex = 5;
this.buttonDisplayLED.Text = "Display Text";
this.buttonDisplayLED.UseVisualStyleBackColor = true;
this.buttonDisplayLED.Click += new
System.EventHandler(this.buttonDisplayLED_Click);
//
// buttonCloseGate
//
this.buttonCloseGate.Location = new System.Drawing.Point(105, 84);
this.buttonCloseGate.Name = "buttonCloseGate";
this.buttonCloseGate.Size = new System.Drawing.Size(75, 42);
this.buttonCloseGate.TabIndex = 4;
this.buttonCloseGate.Text = "Close Gate";
this.buttonCloseGate.UseVisualStyleBackColor = true;
this.buttonCloseGate.Click += new
System.EventHandler(this.buttonCloseGate_Click);
//
// buttonOpenGate
//
this.buttonOpenGate.Location = new System.Drawing.Point(9, 84);
this.buttonOpenGate.Name = "buttonOpenGate";
this.buttonOpenGate.Size = new System.Drawing.Size(75, 42);
this.buttonOpenGate.TabIndex = 3;
this.buttonOpenGate.Text = "Open Gate";
this.buttonOpenGate.UseVisualStyleBackColor = true;
this.buttonOpenGate.Click += new
System.EventHandler(this.buttonOpenGate_Click);
//
// buttonStopListening
//
this.buttonStopListening.Location = new System.Drawing.Point(105, 37);
this.buttonStopListening.Name = "buttonStopListening";
this.buttonStopListening.Size = new System.Drawing.Size(75, 42);
this.buttonStopListening.TabIndex = 2;
this.buttonStopListening.Text = "Stop Listening";
this.buttonStopListening.UseVisualStyleBackColor = true;
this.buttonStopListening.Click += new
System.EventHandler(this.buttonStopListening_Click);
//
// buttonStartListening
//
this.buttonStartListening.Location = new System.Drawing.Point(9, 37);
this.buttonStartListening.Name = "buttonStartListening";
this.buttonStartListening.Size = new System.Drawing.Size(75, 42);
this.buttonStartListening.TabIndex = 1;
this.buttonStartListening.Text = "Start Listening";
this.buttonStartListening.UseVisualStyleBackColor = true;
this.buttonStartListening.Click += new
System.EventHandler(this.buttonStartListening_Click);
//
// label3
//

of 148
//
// tabPage2
//
this.tabPage2.Controls.Add(this.groupBox5);
this.tabPage2.Text = "Log";
//
// groupBox5
//
this.groupBox5.Controls.Add(this.listViewLog);
this.groupBox5.Controls.Add(this.panel6);
this.groupBox5.Dock = System.Windows.Forms.DockStyle.Fill;
this.groupBox5.Text = "In";
//
// listViewLog
//
this.listViewLog.Columns.AddRange(new System.Windows.Forms.ColumnHeader[]
{
this.columnHeader5,
this.columnHeader10,
this.columnHeader6,
this.columnHeader7,
this.columnHeader9});
this.listViewLog.Dock = System.Windows.Forms.DockStyle.Fill;
this.listViewLog.LargeImageList = this.imageList1;
this.listViewLog.Location = new System.Drawing.Point(3, 16);
this.listViewLog.Name = "listViewLog";
this.listViewLog.Size = new System.Drawing.Size(694, 481);
this.listViewLog.TabIndex = 0;
this.listViewLog.UseCompatibleStateImageBehavior = false;
this.listViewLog.View = System.Windows.Forms.View.Details;
//
// columnHeader5
//
this.columnHeader5.Text = "Tag";
//
// columnHeader10
//
this.columnHeader10.Text = "Time";
//
// columnHeader6
//
this.columnHeader6.Text = "Customer Name";
//
// columnHeader7
//
this.columnHeader7.Text = "Gate";
//
// columnHeader9
//

of 148
this.columnHeader9.Text = "In/Out";
//
// imageList1
//
this.imageList1.ColorDepth = System.Windows.Forms.ColorDepth.Depth8Bit;
this.imageList1.ImageSize = new System.Drawing.Size(64, 64);
this.imageList1.TransparentColor = System.Drawing.Color.Transparent;
//
// panel6
//
this.panel6.Controls.Add(this.buttonExport);
//
// buttonExport
//
this.buttonExport.Location = new System.Drawing.Point(9, 36);
this.buttonExport.Name = "buttonExport";
this.buttonExport.Size = new System.Drawing.Size(75, 23);
this.buttonExport.TabIndex = 2;
this.buttonExport.Text = "Export ";
this.buttonExport.UseVisualStyleBackColor = true;
this.buttonExport.Click += new
System.EventHandler(this.buttonExport_Click);
//
// label12
//
//
// tabPage4
//
this.tabPage4.Text = "Options";
//
// groupBox6
//
this.groupBox6.Controls.Add(this.checkBoxTag1);
this.groupBox6.Text = "Tag Validation";
//
// checkBoxTag1
//
this.checkBoxTag1.AutoSize = true;
this.checkBoxTag1.Location = new System.Drawing.Point(15, 24);

of 148
this.checkBoxTag1.Name = "checkBoxTag1";
this.checkBoxTag1.Size = new System.Drawing.Size(199, 17);
this.checkBoxTag1.TabIndex = 0;
this.checkBoxTag1.Text = "Tag is used by only one car at a time";
this.checkBoxTag1.UseVisualStyleBackColor = true;
//
// groupBox4
//
this.groupBox4.Controls.Add(this.groupBox9);
this.groupBox4.Controls.Add(this.groupBox8);
this.groupBox4.Controls.Add(this.comboBoxNotifcations);
this.groupBox4.Controls.Add(this.checkBoxNotifications);
this.groupBox4.Text = "Notifcation Settings";
//
// groupBox9
//
this.groupBox9.Controls.Add(this.textBoxSmsApi);
this.groupBox9.Controls.Add(this.textBoxSmsPassword);
this.groupBox9.Controls.Add(this.textBoxSmsAccount);
this.groupBox9.Text = "SMS";
//
// textBoxSmsApi
//
this.textBoxSmsApi.Location = new System.Drawing.Point(94, 69);
this.textBoxSmsApi.Name = "textBoxSmsApi";
this.textBoxSmsApi.Size = new System.Drawing.Size(124, 20);
this.textBoxSmsApi.TabIndex = 8;
//
// label19
//
this.label19.Text = "API_ID";
//
// label17
//
this.label17.Text = "Account";
//
// textBoxSmsPassword
//
this.textBoxSmsPassword.Location = new System.Drawing.Point(94, 43);
this.textBoxSmsPassword.Name = "textBoxSmsPassword";
this.textBoxSmsPassword.Size = new System.Drawing.Size(124, 20);

of 148
this.textBoxSmsPassword.TabIndex = 6;
this.textBoxSmsPassword.UseSystemPasswordChar = true;
//
// label18
//
this.label18.Text = "Password";
//
// textBoxSmsAccount
//
this.textBoxSmsAccount.Location = new System.Drawing.Point(94, 13);
this.textBoxSmsAccount.Name = "textBoxSmsAccount";
this.textBoxSmsAccount.Size = new System.Drawing.Size(124, 20);
this.textBoxSmsAccount.TabIndex = 5;
//
// groupBox8
//
this.groupBox8.Controls.Add(this.textBoxGmailPassword);
this.groupBox8.Controls.Add(this.textBoxGmailAccount);
this.groupBox8.Text = "Email";
//
// label15
//
this.label15.Text = "Gmail Account";
//
// textBoxGmailPassword
//
this.textBoxGmailPassword.Location = new System.Drawing.Point(94, 43);
this.textBoxGmailPassword.Name = "textBoxGmailPassword";
this.textBoxGmailPassword.Size = new System.Drawing.Size(124, 20);
this.textBoxGmailPassword.TabIndex = 6;
this.textBoxGmailPassword.UseSystemPasswordChar = true;
//
// label16
//
this.label16.Text = "Password";
//
// textBoxGmailAccount
//
this.textBoxGmailAccount.Location = new System.Drawing.Point(94, 13);
this.textBoxGmailAccount.Name = "textBoxGmailAccount";
this.textBoxGmailAccount.Size = new System.Drawing.Size(124, 20);
this.textBoxGmailAccount.TabIndex = 5;
//

of 148
// label11
//
this.label11.Text = "Number of Days";
//
// comboBoxNotifcations
//
this.comboBoxNotifcations.DropDownStyle =
System.Windows.Forms.ComboBoxStyle.DropDownList;
this.comboBoxNotifcations.FormattingEnabled = true;
this.comboBoxNotifcations.Items.AddRange(new object[] {
"1",
"2",
"3",
"4",
"5",
"6",
"7"});
this.comboBoxNotifcations.Location = new System.Drawing.Point(95, 54);
this.comboBoxNotifcations.Name = "comboBoxNotifcations";
this.comboBoxNotifcations.Size = new System.Drawing.Size(124, 21);
this.comboBoxNotifcations.TabIndex = 1;
//
// checkBoxNotifications
//
this.checkBoxNotifications.AutoSize = true;
this.checkBoxNotifications.Location = new System.Drawing.Point(9, 24);
this.checkBoxNotifications.Name = "checkBoxNotifications";
this.checkBoxNotifications.Size = new System.Drawing.Size(110, 17);
this.checkBoxNotifications.TabIndex = 0;
this.checkBoxNotifications.Text = "Allow Notifcations";
this.checkBoxNotifications.UseVisualStyleBackColor = true;
this.checkBoxNotifications.CheckedChanged += new
System.EventHandler(this.checkBoxNotifications_CheckedChanged);
//
// groupBox1
//
this.groupBox1.Controls.Add(this.comboBoxStopBits);
this.groupBox1.Controls.Add(this.comboBoxParity);
this.groupBox1.Controls.Add(this.comboBoxDataBits);
this.groupBox1.Controls.Add(this.comboBoxRate);
this.groupBox1.Controls.Add(this.comboBoxPortName);
this.groupBox1.Text = "Serial Port Settings";
//
// comboBoxStopBits
//
this.comboBoxStopBits.FormattingEnabled = true;
this.comboBoxStopBits.Location = new System.Drawing.Point(86, 127);
this.comboBoxStopBits.Name = "comboBoxStopBits";
this.comboBoxStopBits.Size = new System.Drawing.Size(121, 21);
this.comboBoxStopBits.TabIndex = 9;

of 148
this.comboBoxStopBits.Visible = false;
//
// comboBoxParity
//
this.comboBoxParity.FormattingEnabled = true;
this.comboBoxParity.Location = new System.Drawing.Point(86, 101);
this.comboBoxParity.Name = "comboBoxParity";
this.comboBoxParity.Size = new System.Drawing.Size(121, 21);
this.comboBoxParity.TabIndex = 8;
this.comboBoxParity.Visible = false;
//
// comboBoxDataBits
//
this.comboBoxDataBits.FormattingEnabled = true;
this.comboBoxDataBits.Location = new System.Drawing.Point(86, 75);
this.comboBoxDataBits.Name = "comboBoxDataBits";
this.comboBoxDataBits.Size = new System.Drawing.Size(121, 21);
this.comboBoxDataBits.TabIndex = 7;
this.comboBoxDataBits.Visible = false;
//
// comboBoxRate
//
this.comboBoxRate.FormattingEnabled = true;
this.comboBoxRate.Items.AddRange(new object[] {
"4800",
"7200",
"9600",
"14400",
"19200 "});
this.comboBoxRate.Location = new System.Drawing.Point(86, 49);
this.comboBoxRate.Name = "comboBoxRate";
this.comboBoxRate.Size = new System.Drawing.Size(121, 21);
this.comboBoxRate.TabIndex = 6;
//
// comboBoxPortName
//
this.comboBoxPortName.FormattingEnabled = true;
this.comboBoxPortName.Items.AddRange(new object[] {
"COM1",
"COM2",
"COM3",
"COM4",
"COM5"});
this.comboBoxPortName.Location = new System.Drawing.Point(86, 23);
this.comboBoxPortName.Name = "comboBoxPortName";
this.comboBoxPortName.Size = new System.Drawing.Size(121, 21);
this.comboBoxPortName.TabIndex = 5;
//
// label8
//
this.label8.Text = "Stop Bits";
this.label8.Visible = false;
//
// label7
//

of 148
this.label7.Text = "Parity";
//
// label6
//
this.label6.Text = "Data Bits";
//
// label5
//
this.label5.Text = "Baud Rate";
//
// label4
//
this.label4.Text = "Port Name";
//
// tabPage5
//
this.tabPage5.Text = "SMS Alerts";
//
// groupBox11
//
this.groupBox11.Controls.Add(this.listBoxSMS);
this.groupBox11.Dock = System.Windows.Forms.DockStyle.Fill;
this.groupBox11.Text = "Message";
//
// listBoxSMS
//
this.listBoxSMS.Dock = System.Windows.Forms.DockStyle.Fill;
this.listBoxSMS.FormattingEnabled = true;
this.listBoxSMS.Location = new System.Drawing.Point(3, 16);
this.listBoxSMS.Name = "listBoxSMS";
this.listBoxSMS.Size = new System.Drawing.Size(523, 481);
this.listBoxSMS.TabIndex = 2;
//
// panel8

of 148
//
this.panel8.Controls.Add(this.buttonEditMsg);
this.panel8.Controls.Add(this.buttonRemoveMsg);
this.panel8.Controls.Add(this.buttonAddMsg);
//
// buttonEditMsg
//
this.buttonEditMsg.Location = new System.Drawing.Point(3, 41);
this.buttonEditMsg.Name = "buttonEditMsg";
this.buttonEditMsg.Size = new System.Drawing.Size(76, 32);
this.buttonEditMsg.TabIndex = 2;
this.buttonEditMsg.Text = "Edit";
this.buttonEditMsg.UseVisualStyleBackColor = true;
this.buttonEditMsg.Click += new
System.EventHandler(this.buttonEditMsg_Click);
//
// buttonRemoveMsg
//
this.buttonRemoveMsg.Location = new System.Drawing.Point(3, 80);
this.buttonRemoveMsg.Name = "buttonRemoveMsg";
this.buttonRemoveMsg.Size = new System.Drawing.Size(77, 35);
this.buttonRemoveMsg.TabIndex = 1;
this.buttonRemoveMsg.Text = "Remove";
this.buttonRemoveMsg.UseVisualStyleBackColor = true;
this.buttonRemoveMsg.Click += new
System.EventHandler(this.buttonRemoveMsg_Click);
//
// buttonAddMsg
//
this.buttonAddMsg.Location = new System.Drawing.Point(3, 3);
this.buttonAddMsg.Name = "buttonAddMsg";
this.buttonAddMsg.Size = new System.Drawing.Size(76, 32);
this.buttonAddMsg.TabIndex = 0;
this.buttonAddMsg.Text = "Add";
this.buttonAddMsg.UseVisualStyleBackColor = true;
this.buttonAddMsg.Click += new
System.EventHandler(this.buttonAddMsg_Click);
//
// groupBox10
//
this.groupBox10.Controls.Add(this.listBoxSMSCategory);
this.groupBox10.Dock = System.Windows.Forms.DockStyle.Left;
this.groupBox10.Text = "Category";
//
// listBoxSMSCategory
//
this.listBoxSMSCategory.Dock = System.Windows.Forms.DockStyle.Fill;
this.listBoxSMSCategory.FormattingEnabled = true;
this.listBoxSMSCategory.Location = new System.Drawing.Point(3, 16);
this.listBoxSMSCategory.Name = "listBoxSMSCategory";
this.listBoxSMSCategory.Size = new System.Drawing.Size(213, 437);
this.listBoxSMSCategory.TabIndex = 0;
this.listBoxSMSCategory.SelectedIndexChanged += new
System.EventHandler(this.listBoxSMSCategory_SelectedIndexChanged);

of 148
//
// panel7
//
this.panel7.Controls.Add(this.buttonRemoveCategory);
this.panel7.Controls.Add(this.buttonAddCategory);
this.panel7.Dock = System.Windows.Forms.DockStyle.Bottom;
//
// buttonRemoveCategory
//
this.buttonRemoveCategory.Location = new System.Drawing.Point(14, 2);
this.buttonRemoveCategory.Name = "buttonRemoveCategory";
this.buttonRemoveCategory.Size = new System.Drawing.Size(77, 35);
this.buttonRemoveCategory.TabIndex = 1;
this.buttonRemoveCategory.Text = "Remove";
this.buttonRemoveCategory.UseVisualStyleBackColor = true;
this.buttonRemoveCategory.Click += new
System.EventHandler(this.buttonRemoveCategory_Click);
//
// buttonAddCategory
//
this.buttonAddCategory.Location = new System.Drawing.Point(114, 2);
this.buttonAddCategory.Name = "buttonAddCategory";
this.buttonAddCategory.Size = new System.Drawing.Size(76, 32);
this.buttonAddCategory.TabIndex = 0;
this.buttonAddCategory.Text = "Add";
this.buttonAddCategory.UseVisualStyleBackColor = true;
this.buttonAddCategory.Click += new
System.EventHandler(this.buttonAddCategory_Click);
//
// timer1
//
this.timer1.Interval = 5000;
this.timer1.Tick += new System.EventHandler(this.timer1_Tick);
//
// imageList2
//
this.imageList2.ImageStream =
((System.Windows.Forms.ImageListStreamer)(resources.GetObject("imageList2.ImageStream"
)));
this.imageList2.TransparentColor = System.Drawing.Color.Transparent;
this.imageList2.Images.SetKeyName(0, "check-64.png");
this.imageList2.Images.SetKeyName(1, "delete_2.png");
//
// FormMain
//
this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
this.ClientSize = new System.Drawing.Size(850, 593);
this.Controls.Add(this.panel2);
this.Controls.Add(this.panel1);
this.MainMenuStrip = this.menuStrip1;
this.Name = "FormMain";
this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen;
this.Text = "Parking Monitoring and Control System";
this.Load += new System.EventHandler(this.Form1_Load);
this.panel1.ResumeLayout(false);
this.panel1.PerformLayout();
this.menuStrip1.ResumeLayout(false);
this.menuStrip1.PerformLayout();
this.tabControl1.ResumeLayout(false);

of 148
this.tabPage1.ResumeLayout(false);
this.tabPage3.PerformLayout();
this.groupBox7.ResumeLayout(false);
this.groupBox7.PerformLayout();
((System.ComponentModel.ISupportInitialize)(this.pictureBox2)).EndInit();
this.ResumeLayout(false);
}
#endregion
private System.Windows.Forms.Panel panel1;
private System.Windows.Forms.TabControl tabControl1;
private System.Windows.Forms.TabPage tabPage1;
private System.Windows.Forms.ListView listViewCustomers;
private System.Windows.Forms.Label label1;
private System.Windows.Forms.ColumnHeader columnHeader1;
private System.Windows.Forms.Button buttonDeleteTag;
private System.Windows.Forms.Button buttonEditTag;
private System.Windows.Forms.Button buttonAddTag;
private System.Windows.Forms.MenuStrip menuStrip1;
private System.Windows.Forms.ToolStripMenuItem systemToolStripMenuItem;
private System.Windows.Forms.ToolStripMenuItem openDatabaseToolStripMenuItem;
private System.Windows.Forms.ToolStripMenuItem saveDatabaseToolStripMenuItem;
private System.Windows.Forms.ToolStripMenuItem exitToolStripMenuItem;
private System.Windows.Forms.ToolStripMenuItem helpToolStripMenuItem;
private System.Windows.Forms.ToolStripMenuItem aboutToolStripMenuItem;

of 148
private System.Windows.Forms.GroupBox groupBox1;
private System.Windows.Forms.ComboBox comboBoxStopBits;
private System.Windows.Forms.ComboBox comboBoxParity;
private System.Windows.Forms.ComboBox comboBoxDataBits;
private System.Windows.Forms.ComboBox comboBoxRate;
private System.Windows.Forms.ComboBox comboBoxPortName;
private System.Windows.Forms.Button buttonStopListening;
private System.Windows.Forms.Button buttonStartListening;
private System.Windows.Forms.TextBox txtLED;
private System.Windows.Forms.Button buttonDisplayLED;
private System.Windows.Forms.Button buttonCloseGate;
private System.Windows.Forms.Button buttonOpenGate;
private System.Windows.Forms.TextBox txtCommandsLog;
private System.Windows.Forms.TextBox txtFreeParking;
private System.Windows.Forms.TextBox txtTotalParkingCount;
private System.Windows.Forms.Button buttonSetParking;
private System.Windows.Forms.ComboBox comboBoxGate;
private System.Windows.Forms.ComboBox comboBoxNotifcations;
private System.Windows.Forms.CheckBox checkBoxNotifications;
private System.Windows.Forms.Timer timer1;
private System.Windows.Forms.ListView listViewLog;
private System.Windows.Forms.ImageList imageList1;
private System.Windows.Forms.PictureBox pictureBox1;
private System.Windows.Forms.ImageList imageList2;
private System.Windows.Forms.CheckBox checkBoxTag1;
private System.Windows.Forms.Button buttonArduinoWrite;
private System.Windows.Forms.TextBox textBoxReadArduino;
private System.Windows.Forms.Button buttonWriteArduino;
private System.Windows.Forms.TextBox textBoxWriteArduino;
private System.Windows.Forms.Button buttonExport;
private System.Windows.Forms.TextBox textBoxGmailPassword;
private System.Windows.Forms.TextBox textBoxGmailAccount;
private System.Windows.Forms.Button buttonSMS;

of 148
private System.Windows.Forms.TextBox textBoxSmsApi;
private System.Windows.Forms.TextBox textBoxSmsPassword;
private System.Windows.Forms.TextBox textBoxSmsAccount;
private System.Windows.Forms.ListBox listBoxSMS;
private System.Windows.Forms.Button buttonRemoveMsg;
private System.Windows.Forms.Button buttonAddMsg;
private System.Windows.Forms.Button buttonRemoveCategory;
private System.Windows.Forms.Button buttonAddCategory;
private System.Windows.Forms.ListBox listBoxSMSCategory;
private System.Windows.Forms.Button buttonEditMsg;
}
}
{
partial class FormAbout
{
/// <summary>
/// </summary>
/// <summary>
/// </summary>
{
{
}
}
/// <summary>
/// </summary>
{
this.textBox1 = new System.Windows.Forms.TextBox();
this.buttonOk = new System.Windows.Forms.Button();
//
// label1
//

of 148
this.label1.Text = "Parking Monitoring and Control System";
//
// textBox1
//
this.textBox1.Location = new System.Drawing.Point(15, 44);
this.textBox1.Multiline = true;
this.textBox1.Name = "textBox1";
this.textBox1.ReadOnly = true;
this.textBox1.Size = new System.Drawing.Size(290, 139);
this.textBox1.TabIndex = 1;
//
// buttonOk
//
this.buttonOk.Location = new System.Drawing.Point(126, 191);
this.buttonOk.Name = "buttonOk";
this.buttonOk.Size = new System.Drawing.Size(75, 23);
this.buttonOk.TabIndex = 0;
this.buttonOk.Text = "Ok";
this.buttonOk.UseVisualStyleBackColor = true;
this.buttonOk.Click += new System.EventHandler(this.buttonOk_Click);
//
// FormAbout
//
this.Controls.Add(this.buttonOk);
this.Controls.Add(this.textBox1);
this.Controls.Add(this.label1);
this.Name = "FormAbout";
this.Text = "About";
this.Load += new System.EventHandler(this.FormAbout_Load);
this.PerformLayout();
}
#endregion
private System.Windows.Forms.TextBox textBox1;
private System.Windows.Forms.Button buttonOk;
}
}
{
partial class FormSMS
{
/// <summary>
/// </summary>
/// <summary>
/// </summary>
{
{

of 148
}
}
/// <summary>
/// </summary>
{
this.textBoxTo = new System.Windows.Forms.TextBox();
this.textBoxSubject = new System.Windows.Forms.TextBox();
this.textBoxMessage = new System.Windows.Forms.TextBox();
this.buttonSend = new System.Windows.Forms.Button();
this.buttonCancel = new System.Windows.Forms.Button();
//
// label1
//
this.label1.Text = "To";
//
// textBoxTo
//
this.textBoxTo.Location = new System.Drawing.Point(66, 23);
this.textBoxTo.Name = "textBoxTo";
this.textBoxTo.Size = new System.Drawing.Size(155, 20);
this.textBoxTo.TabIndex = 1;
//
// textBoxSubject
//
this.textBoxSubject.Location = new System.Drawing.Point(66, 49);
this.textBoxSubject.Name = "textBoxSubject";
this.textBoxSubject.Size = new System.Drawing.Size(155, 20);
this.textBoxSubject.TabIndex = 3;
//
// label2
//
this.label2.Text = "Subject";
//
// textBoxMessage
//
this.textBoxMessage.Location = new System.Drawing.Point(66, 75);
this.textBoxMessage.Multiline = true;
this.textBoxMessage.Name = "textBoxMessage";
this.textBoxMessage.Size = new System.Drawing.Size(155, 80);
this.textBoxMessage.TabIndex = 5;
//
// label3
//

of 148
this.label3.Text = "Message";
//
// buttonSend
//
this.buttonSend.Location = new System.Drawing.Point(129, 178);
this.buttonSend.Name = "buttonSend";
this.buttonSend.Size = new System.Drawing.Size(75, 23);
this.buttonSend.TabIndex = 6;
this.buttonSend.Text = "Send";
this.buttonSend.UseVisualStyleBackColor = true;
this.buttonSend.Click += new System.EventHandler(this.buttonSend_Click);
//
// buttonCancel
//
this.buttonCancel.DialogResult = System.Windows.Forms.DialogResult.Cancel;
this.buttonCancel.Location = new System.Drawing.Point(34, 178);
this.buttonCancel.Name = "buttonCancel";
this.buttonCancel.Size = new System.Drawing.Size(75, 23);
this.buttonCancel.TabIndex = 7;
this.buttonCancel.Text = "Cancel";
this.buttonCancel.UseVisualStyleBackColor = true;
this.buttonCancel.Click += new
System.EventHandler(this.buttonCancel_Click);
//
// FormSMS
//
this.AcceptButton = this.buttonSend;
this.CancelButton = this.buttonCancel;
this.ControlBox = false;
this.Controls.Add(this.buttonCancel);
this.Controls.Add(this.buttonSend);
this.Controls.Add(this.textBoxMessage);
this.Controls.Add(this.textBoxSubject);
this.Controls.Add(this.textBoxTo);
this.Name = "FormSMS";
this.StartPosition = System.Windows.Forms.FormStartPosition.CenterParent;
this.Text = "Send Message";
this.Load += new System.EventHandler(this.FormSMS_Load);
}
#endregion
private System.Windows.Forms.TextBox textBoxTo;
private System.Windows.Forms.TextBox textBoxSubject;
private System.Windows.Forms.TextBox textBoxMessage;
private System.Windows.Forms.Button buttonSend;
private System.Windows.Forms.Button buttonCancel;
}

of 148
}
{
partial class FormSmsCategory
{
/// <summary>
/// </summary>
/// <summary>
/// </summary>
{
{
}
}
/// <summary>
/// </summary>
{
this.textBoxCategory = new System.Windows.Forms.TextBox();
//
// buttonOk
//
this.buttonOk.Text = "&Ok";
//
// buttonCancel
//
this.buttonCancel.Text = "&Cancel";
//
// textBoxCategory
//
this.textBoxCategory.Location = new System.Drawing.Point(23, 28);
this.textBoxCategory.Name = "textBoxCategory";
this.textBoxCategory.Size = new System.Drawing.Size(172, 20);
this.textBoxCategory.TabIndex = 6;
//
// FormSmsCategory

of 148
//
this.AcceptButton = this.buttonOk;
this.Controls.Add(this.textBoxCategory);
this.Name = "FormSmsCategory";
this.Text = "Category";
this.Load += new System.EventHandler(this.FormSmsCategory_Load);
}
#endregion
private System.Windows.Forms.TextBox textBoxCategory;
}
}
{
partial class FormSMSNotification
{
/// <summary>
/// </summary>
/// <summary>
/// </summary>
{
{
}
}
/// <summary>
/// </summary>
{
this.textBoxSMS = new System.Windows.Forms.TextBox();
//
// label1
//

of 148
this.label1.Text = "Message";
//
// textBoxSMS
//
this.textBoxSMS.Location = new System.Drawing.Point(15, 25);
this.textBoxSMS.Multiline = true;
this.textBoxSMS.Name = "textBoxSMS";
this.textBoxSMS.Size = new System.Drawing.Size(352, 53);
this.textBoxSMS.TabIndex = 1;
//
// buttonCancel
//
this.buttonCancel.Text = "&Cancel";
//
// buttonOk
//
this.buttonOk.Text = "&Ok";
//
// FormSMSNotification
//
this.Controls.Add(this.textBoxSMS);
this.Name = "FormSMSNotification";
this.Text = "Message";
this.Load += new System.EventHandler(this.FormSMSNotification_Load);
}
#endregion
private System.Windows.Forms.TextBox textBoxSMS;
}
}
{

of 148
partial class FormTag
{
/// <summary>
/// </summary>
/// <summary>
/// </summary>
{
{
}
}
/// <summary>
/// </summary>
{
this.txtTagNumber = new System.Windows.Forms.TextBox();
this.txtCustomerName = new System.Windows.Forms.TextBox();
this.txtCustomerMobile = new System.Windows.Forms.TextBox();
this.dateTimeTagExpiration = new System.Windows.Forms.DateTimePicker();
this.buttonPhoto = new System.Windows.Forms.Button();
this.textBoxEmail = new System.Windows.Forms.TextBox();
this.checkedListBoxSmsSubscriptions = new
System.Windows.Forms.CheckedListBox();
//
// txtTagNumber
//
this.txtTagNumber.Location = new System.Drawing.Point(97, 24);
this.txtTagNumber.Name = "txtTagNumber";
this.txtTagNumber.Size = new System.Drawing.Size(129, 20);
this.txtTagNumber.TabIndex = 0;
//
// label1
//

of 148
this.label1.Text = "TAG Number";
//
// label2
//
this.label2.Text = "Customer Name";
//
// txtCustomerName
//
this.txtCustomerName.Location = new System.Drawing.Point(97, 50);
this.txtCustomerName.Name = "txtCustomerName";
this.txtCustomerName.Size = new System.Drawing.Size(129, 20);
this.txtCustomerName.TabIndex = 2;
//
// label3
//
this.label3.Text = "Customer Mobile";
//
// txtCustomerMobile
//
this.txtCustomerMobile.Location = new System.Drawing.Point(97, 76);
this.txtCustomerMobile.Name = "txtCustomerMobile";
this.txtCustomerMobile.Size = new System.Drawing.Size(129, 20);
this.txtCustomerMobile.TabIndex = 4;
//
// label4
//
this.label4.Text = "Expiration Date";
//
// dateTimeTagExpiration
//
this.dateTimeTagExpiration.Location = new System.Drawing.Point(97, 129);
this.dateTimeTagExpiration.Name = "dateTimeTagExpiration";
this.dateTimeTagExpiration.Size = new System.Drawing.Size(200, 20);
this.dateTimeTagExpiration.TabIndex = 8;
//
// buttonOk
//
//
// buttonCancel
//

of 148
this.buttonCancel.Text = "Cancel";
this.buttonCancel.Click += new
System.EventHandler(this.buttonCancel_Click);
//
// buttonPhoto
//
this.buttonPhoto.Location = new System.Drawing.Point(15, 168);
this.buttonPhoto.Name = "buttonPhoto";
this.buttonPhoto.Size = new System.Drawing.Size(75, 23);
this.buttonPhoto.TabIndex = 12;
this.buttonPhoto.Text = "Photo";
this.buttonPhoto.UseVisualStyleBackColor = true;
this.buttonPhoto.Click += new System.EventHandler(this.buttonPhoto_Click);
//
// pictureBox1
//
//
// label5
//
this.label5.Text = "Customer Email";
//
// textBoxEmail
//
this.textBoxEmail.Location = new System.Drawing.Point(97, 102);
this.textBoxEmail.Name = "textBoxEmail";
this.textBoxEmail.Size = new System.Drawing.Size(129, 20);
this.textBoxEmail.TabIndex = 14;
//
// groupBox1
//
this.groupBox1.Controls.Add(this.checkedListBoxSmsSubscriptions);
this.groupBox1.Text = "SMS Subscriptions";
//
// checkedListBoxSmsSubscriptions
//
this.checkedListBoxSmsSubscriptions.Dock =
System.Windows.Forms.DockStyle.Fill;
this.checkedListBoxSmsSubscriptions.FormattingEnabled = true;
this.checkedListBoxSmsSubscriptions.Location = new System.Drawing.Point(3,
16);
this.checkedListBoxSmsSubscriptions.Name =
"checkedListBoxSmsSubscriptions";
this.checkedListBoxSmsSubscriptions.ScrollAlwaysVisible = true;
this.checkedListBoxSmsSubscriptions.Size = new System.Drawing.Size(276,
65);
this.checkedListBoxSmsSubscriptions.TabIndex = 0;

of 148
this.checkedListBoxSmsSubscriptions.ItemCheck += new
System.Windows.Forms.ItemCheckEventHandler(this.checkedListBoxSmsSubscriptions_ItemChe
ck);
//
// FormTag
//
this.Controls.Add(this.groupBox1);
this.Controls.Add(this.textBoxEmail);
this.Controls.Add(this.pictureBox1);
this.Controls.Add(this.buttonPhoto);
this.Controls.Add(this.dateTimeTagExpiration);
this.Controls.Add(this.txtCustomerMobile);
this.Controls.Add(this.txtCustomerName);
this.Controls.Add(this.txtTagNumber);
this.Name = "FormTag";
this.Text = "FormTag";
this.Load += new System.EventHandler(this.FormTag_Load);
}
#endregion
private System.Windows.Forms.TextBox txtTagNumber;
private System.Windows.Forms.TextBox txtCustomerName;
private System.Windows.Forms.TextBox txtCustomerMobile;
private System.Windows.Forms.DateTimePicker dateTimeTagExpiration;
private System.Windows.Forms.Button buttonPhoto;
private System.Windows.Forms.TextBox textBoxEmail;
private System.Windows.Forms.CheckedListBox checkedListBoxSmsSubscriptions;
}
}
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Net;
using System.Text;
using System.Windows.Forms;

of 148
{
public class Logic
{
public static bool SendSMS(string account, string password, string api, string
phone, string subject, string body, bool showProviderMsg)
{
bool success = true;
string value = SendSmsClickatell(account, password, api,
phone,subject,body);
if (showProviderMsg)
{
MessageBox.Show(value, "SMS Provider");
}
return success;
}
public static string SendSmsClickatell(string account, string password, string
api, string phone, string subject, string body)
{
// bool success = true;
WebClient client = new WebClient();
client.Headers.Add("user-agent", "Mozilla/4.0 compatible; MSIE 6.0; Windows
NT 5.2; .NET CLR 1.0.3705;)");
client.QueryString.Add("user", account);
client.QueryString.Add("password", password);
client.QueryString.Add("api_id", api);
client.QueryString.Add("to", phone);
client.QueryString.Add("text", body);
string baseurl = "http://api.clickatell.com/http/sendmsg";
Stream data = client.OpenRead(baseurl);
StreamReader reader = new StreamReader(data);
string s = reader.ReadToEnd();
Debug.WriteLine(s);
data.Close();
reader.Close();
return s;
// return success;
}
}
}
using System;
using System.Text;
{
[Serializable]
public class LogRecord
{
public TagCard Tag;
public DateTime Time;
public int GateNumber;
public bool GoingIn;
}

of 148
}
using System;
{
static class Program
{
/// <summary>
/// The main entry point for the application.
/// </summary>
[STAThread]
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new FormMain());
}
}
}
using System;
using System.Drawing;
using System.Text;
{
[Serializable]
public class TagCard
{
public string TagID;
public string CustomerName;
public string CustomerNID;
public string CustomerMobile;
public string CustomerEmail;
public bool NotificationSent = false;
public DateTime Expiration;
public bool CustomerHasSecurityClearance;
public Image Photo;
public List<string> SmsSubscriptions = new List<string>();
}
}

of 148
using System;
using System.Drawing;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
using System.Text;
{
[Serializable]
public class Database
{
public string PortName;
public string PortSpeed;
public bool TagValidationRule1;
public bool EnableNotification;
public int NotficationDays;
public string GmailAccount;
public string GmailPassword;
public string SmsAccount;
public string SmsPassword;
public string SmsApi;
public Dictionary<string, TagCard> Tags = new Dictionary<string, TagCard>();
public List<LogRecord> Records = new List<LogRecord>();
public Dictionary<string, Image> Photos = new Dictionary<string, Image>();
public Dictionary<string, List<string>> SmsSubscriptions = new
Dictionary<string, List<string>>();
public void SaveDatabase(string file)
{
BinaryFormatter f = new BinaryFormatter();
FileStream fs = new FileStream(file, FileMode.Create, FileAccess.Write,
FileShare.Read);
f.Serialize(fs, this);
fs.Close();
}

of 148
public static Database ReadDatabase(string file)
{
FileStream fs = new FileStream(file, FileMode.Open, FileAccess.Read,
FileShare.ReadWrite);
BinaryFormatter f = new BinaryFormatter();
Database db = (Database)f.Deserialize(fs);
fs.Close();
return db;
}
}
}
{
partial class FormAbout
{
/// <summary>
/// </summary>
/// <summary>
/// </summary>
{
{
}
}
/// <summary>
/// </summary>
{
this.textBox1 = new System.Windows.Forms.TextBox();
//
// label1
//
this.label1.Text = "Parking Monitoring and Control System";
//
// textBox1
//
this.textBox1.Location = new System.Drawing.Point(15, 44);

of 148
this.textBox1.Multiline = true;
this.textBox1.Name = "textBox1";
this.textBox1.ReadOnly = true;
this.textBox1.Size = new System.Drawing.Size(290, 139);
this.textBox1.TabIndex = 1;
//
// buttonOk
//
//
// FormAbout
//
this.Controls.Add(this.textBox1);
this.Name = "FormAbout";
this.Text = "About";
this.Load += new System.EventHandler(this.FormAbout_Load);
}
#endregion
private System.Windows.Forms.TextBox textBox1;
}
}

of 148
17Appendix D: Bill of Materials
Bills of all components bought &used, quantities and cost

of 148
18Appendix E: Datasheets
1-Voltage regulator data sheet

of 148
2-L78S09 Series datasheet

of 148
3-50SQ... SERIES datasheet

of 148
3-RFID reader ID-12 datasheet

of 148
6-SM5100B-D GSM/GPRS Module Specification

of 148
7-SM5100B-D GSM/GPRS Module Specification

of 148
8-Servo motor specification

of 148
8-Arduino MEGA 2560 Technical Specification

final report (parking project).pdf

More Related Content

Similar to final report (parking project).pdf (20)

Recently uploaded (20)

final report (parking project).pdf