Portable Synchronized Basketball Scoreboard Using Zigbee

Portable Synchronized Basketball Scoreboard
Using Zigbee
by
Rhovie Emmanuel C. Concepcion
Rends C. Maniquis
Ian A. Punzalan
A Thesis Report Submitted to the School of EECE
in Partial Fulfillment of the Requirements of the Degree of
Bachelor of Science in Electrical Engineering
Mapua Institute of Technology
November 2012
ACKNOWLEDGEMENT
The researcherswould liketoexpresstheir de ep es t gratitudetoall the peoplewho
helped and supported them in making this project possible. This venture would
not be a success without them.
Firstandforemost,toGodtheCreatorofall for strength, skills, discipline, and character
development He gave them throughout the completion of the thesis.
ToEngr. R omni c C hua for sharing his ideas and expertise in program
designing. His knowledge and skills helped to improve the study. His encouragement and
personal guidance helped the team to work better.
To Engr. Mi ch ae l Pa c i s , En gr. N o e l Li ns a n ga n, a nd En gr. Vi c D en ni s
C hu a for theirunselfishandunfailingsupportasthesisadvisers. Their knowledge and skills
helped to improve the study.
To Engr. Conrado Ostia, Engr. Ronaldo Cabuang and Engr. Janette Fausto, the
panellists, for giving useful directions and construction comments.
To Concepcion Family, Maniquis Family and Punzalan Family for their
encouragement, moral support, financial support, and endless unconditional love.
Lastbutnottheleast,to
theirfriends,
EE
Youth
07,
andothermentors
whoneverfailedtoguidethem and givethem moralsupport.
iii
TABLE OF CONTENTS
TITLE PAGE
i
APPROVAL PAGE
ii
ACKNOWLEDGEMENT
iii
TABLE OF CONTENTS
iv
LIST OF TABLES
vi
LIST OF FIGURES
vii
ABSTRACT
viii
Chapter 1:
INTRODUCTION
1
Chapter 2:
REVIEW OF LITERATURE
5
A.
B.
C.
D.
E.
F.
Chapter 3:
Previous Study of Wireless Scoreboard
Introduction to Zigbee
Studies on Zigbee Wireless Sensor Networks
Applications of Zigbee
Microcontroller
Graphical User Interface
PORTABLE SYNCHRONIZED BASKETBALL SCOREBOARD
USING ZIGBEE
A.
B.
C.
D.
E.
F.
G.
H.
I.
J.
K.
L.
M.
N.
Abstract
Introduction
Previous Study of Wireless Scoreboard
Introduction to Zigbee
Studies on Zigbee Wireless Sensor Networks
Applications of Zigbee
Microcontroller
Graphical User Interface
Design Outline
Initial Planning
Conceptual Diagram
Conceptual Framework
Design Procedures
Building the Portable Basketball Scoreboard Using Zigbee
i. Scoreboard Display
ii. Inventory and Canvassing
5
6
8
9
11
12
13
13
13
17
18
20
21
23
24
25
25
26
27
28
28
31
32
iv
O.
P.
Q.
R.
S.
T.
U.
iii. Testing of 7 Segment LEDs
iv. Translating the Schematic Diagram to PCB
v. Creating Graphical User Interface
vi. Pin Configuration of Arduino
vii. Initial Testing of the Prototype
viii. Prototype Enclosure
Testing of the Prototype
i. Data Precision Test
ii. Range Test
Measuring Signal Strength
Measuring Time Delay
Statistical Treatment
Conclusion
Recommendation
References
33
34
36
37
38
38
39
39
43
45
49
54
55
56
56
Chapter 4:
CONCLUSION
59
Chapter 5:
RECOMMENDATION
60
REFERENCES
61
APPENDICES
63
v
LIST OF TABLES
Table 3.1: GUI Command Details
40
Table 3.2: Data Precision Testing
41
Table 3.3: Signal Strength Testing Results
46
Table 3.4: Time DelayTesting Results
50
vi
LIST OF FIGURES
Figure 1.1: Scoring Diagrams
1
Figure 1.2: Typical Scoreboards
2
Figure 2.1: Comparison of Existing Signals
7
Figure 3.1: Conceptual Diagram
25
Figure 3.2: Design Flow Chart
29
Figure 3.3: Scoreboard Display
31
Figure 3.4: Power Supply
32
Figure 3.5: Testing of LEDs
33
Figure 3.6: Schematic Diagram of Each LED
34
Figure 3.7: Translating the Schematic Diagram to PCB
35
Figure 3.8: Graphical User Interface
36
Figure 3.9: Pin Configuration of Arduino
37
Figure 3.10: Prototype Enclosure
38
Figure 3.11: Range Testing
44
Figure 3.12: Circuit A
45
Figure 3.13: Circuit B
45
Figure 3.14: X-CTU Program
45
Figure 3.15: Measurement of Time Delay
49
vii
ABSTRACT
The scoreboard of any sport shows the status of the game by displaying the
significant data like time and the team scores. Players and viewers rely on the numerical
figures that are shown on the scoreboard especially the scores of each team and the game
clock to determine which team is winning. Since the technologies nowadays are accelerating
very fast, the present scoreboard can be improved by reducing its size and making it wireless.
Existing scoreboard is permanently placed at a higher location where viewers can see it.
However, it usually takes time for people to set it up and when it encounters trouble, they
will have difficulty repairing the system.The scoreboard designed in this study is portable
because it can be easily assembled and repaired.It is also wireless.These features are in
keeping withcurrenttrends in every new gadget nowadays. The design also synchronizes the
scoreboard to a laptop through a Zigbee signal.
Keywords: Scoreboard, Portability, Zigbee, Synchronize
viii
Chapter 1
INTRODUCTION
Basketball is a team sport in which two teams of five players try to score points by
throwing or "shooting"" a ball through the top of a basketball hoop while following a set
of rules.. Basketball is one of the world's most popular and widely viewed sports (Borger,
2008).. Looking at Figure 1.1 (Scoring Diagram), one point can be earned when the ball
ba is
thrown by a free throw while two points inside the arc and three points beyond. At the end of
the game, the team with higher earned points
p
will be declared winner. Basketball scoreboard
is very essential to people who understand the game. Commonly the
the scoreboard is located
near the committee to be able to update the scores via a computer connected
connect to the gadget. In
this manner, the scores are updated using a program that sends the input from the laptop to
the scoreboard.
reboard. Digital scoreboard applies technology
chnology to the scoreboard because in the old
times, the scores are written on board which can be erased or even edited that may result to
cheating.
Figure 1.1 Scoring Diagram
Source: http://www.coaching-basketball-for-beginners.com/half-court-basketball
http://www.coaching
basketball-diagram.html
1
Traditional scoreboard uses a board with the team name placed at the top and the
corresponding score below its name. The game time is only declared verbally by the
announcer same with the shot clock. As time evolves, the scoreboard has been innovated and
it became technical by using a seven segment display as illustrated in Figure 1.2 (Typical
Scoreboard). The proposed new design in scoreboard is that it will be wireless and portable
through the use of ZigBee. The idea of the project came from the Synchronized Wireless
Clock wherein the clock is displaying the time of the computer. Since the clock is operating
wirelessly, the researchers came up with an idea that the concept can be applied in the
Basketball Scoreboard making the old design wireless and portable. So it is poised to become
a very significant enabling technology in many fields, as it is widely used in military
security, environment monitoring, and home automation (Cao et al, 2008).ZigBee is also
considered as a new standard intended for low cost devices in automation, home controls and
computer peripherals. It enables the broad-based deployment of wireless networks with low
cost, and low power solutions (Ondrei et al, 2006, Heile, 2004).
Figure 1.2 Typical Scoreboard
Source:http://antipolocity.olx.com.ph/tronix-electronic-basketball-scoreboard-iid-181750357
2
In any ball game, the use of scoreboard is very important because it is where the
players and audience are informed of the game status such as time elapsed or time left, the
team scores, and other information that the general audience should know. If scoreboards are
available in a game venue, they are normally permanently attached and cannot be moved
from one venue to another. If a venue has no scoreboard available, there are several things
can unwontedly happen and one of there is cheating. If a portable scoreboard is available, the
game can run smoothly. This paper will attempt to solve the aforementioned conditions by
creating a wireless portable scoreboard that can be used in basketball games.
The objectives of the study are the following:
1. to design a wireless and portable basketball scoreboard
2. to synchronize the laptop and scoreboard using Zigbee
The significance of the study is for the researchers to have a wider knowledge in
microcontrollers and other peripherals which are included in making the prototype. Data
transmission is also studied since it is wireless. It will be easy to operate and troubleshoot
unlike the existing ones which have wires.
The scoreboard that will be designed has the ability to display the remaining time,
team points, team foul and shot clock as illustrated in Figure 1.2. The system is limited in
using ZigBee as the medium for transferring the data from the laptop to the scoreboard. The
Graphical User Interface is also provided as the software to input the data to be displayed in
the scoreboard. However, like any wireless operating gadget, the expected performance of
the scoreboard is only found satisfactory within a maximum radius of 200 feet from the base
station which is the Zigbee transmitter. The study does not cover how to increase the
3
maximum allowable distance between the Zigbee transmitter and its receiver. Furthermore,
itdoes not include troubleshooting the prototype and repairing. The study also follows the old
ruleof playing basketball wherein there is no 14 reset shot clock.
4
Chapter 2
REVIEW OF LITERATURE
Previous Study of Wireless Scoreboard
The main study of this wireless scoreboard display system is the use of the radio
transmitter and receiver and a remote controller. The similarity between the radio
transmitter/receiver and ZigBee wireless device is that both have 2.4 GHz transmission
bandwidth, while the difference is the limitation of the displacement and speed that a radio
transmitter can compare to the ZigBee.
In a study(author,year), the designed scoreboard consists of a wireless scoreboard
display system with at least two scoreboard displays, two controllers, a radio transmitter in
each controller, and a radio receiver in each scoreboard display either together or separately
from one or both controllers. This design is quite complicated because it is difficult to control
two scoreboard displays from one controller or two controllers, and it is always necessary to
rewire the controllers. This is especially the case in indoor basketball games where
scoreboard displays are operated for the entire court using one controller or for split courts
using two controllers.
Radio transmitters 16 and 18 and radio receivers 24 and 26 are 2.4 GHZ spread
spectrum radio devices. The radio devices eliminate interference by the use of frequency
hopping from outside sources including cordless phones and other RF devices on the same
frequency (Uehran, 2005).The proponents will use wireless sensor signal which is actually
theZigBee rather than radio frequency.
5
The radio receivers 24 and 26 are housed in ABS plastic enclosures, which are easily
mounted inside the scoreboard displays 20 and 22 with a small dipole antenna mounted to the
face of or adjacent to the scoreboard displays 20 and 22. Outdoor scoreboard displays 20 and
22 can include rubber gaskets to keep moisture out of the enclosures. The radio receivers 24
and 26 can include a rotary switch or other selection device allowing the user to select
different operating channels, normally set once during installation. The instant invention can
be used in multi-field complexes, such as in baseball, enabling each system to operate
independently without interfering with one another. Currently, there are 16 channels
available to select from with the ability to expand to 77 non-interfering channels (Uehran,
2005).
The prototype design is an improvement of existing design because it uses a wireless
scoreboard with the aide of ZigBee, microcontrollers, and a laptop or personal computer.
Introduction to Zigbee
ZigBee is a low-cost, low-power, wireless mesh network standard. Due to its lowcost, it can be extensively distributed in wireless control and monitoring applications. Thanks
to its low-power consumption, it can use smaller batteries and still last for months or even
years. Mesh networking results a high reliability and greater range. It is cheaper and simpler
than other WPAN (wireless personal area network) like Bluetooth. Zigbee chips vendors
usually sell integrated radios and microcontrollers with between 60 KB and 256 KB flash
memory. The ZigBee Alliance is a group of companies working together to enable reliable,
cost-effective, low-power, wirelessly networked, monitoring and control products based on
an open global standard. Their goal is to provide the consumer with ultimate flexibility,
6
mobility, and ease of use by building wireless intelligence and capabilities into every day
devices. ZigBee technology will be embedded in a wide range of products and applications
for the needs of remote monitoring and control applications, including simplicity, reliability,
low-cost and low-power. With acceptance and implementation of ZigBee, interoperability
will be enabled in multi-purpose, self-organizing mesh networks.
Figure 2.1: Comparison of Existing Signals
Source:http://i.cmpnet.com/eetimes/news/07/02/DC1464_UTH_2_PG_38.jpg
As seen in Figure 2.1 (Comparison of Existing Signals), the Zigbee has a data rate of
100kilobytes per second and operates in 50 meters unlike in Bluetooth which operates at only
10 meters. Wi-fi also operates at 50 meters and has a data rate of 200megabits per second.
Wi-fi has very high data rate compared to Zigbee because it specializes in transferring large
sizes of data such as video and sounds. However, transferring large size requires larger power
to accommodate that high data rate.
7
Studies on ZigbeeWireless Sensor Networks
The Institute of Electrical and Electronics Engineers (IEEE) has a large collection of
studies. Researchers’ designs and projects are related to ZigBee wireless sensor network
technology. There are some studies that are important and somehow related to the design
prototype. These articles and studies are as follow:
IEEE members namely Wan-Ki, Chang-Sic, Han J. and Han I., (2007) implemented
ZigBee-based universal remote control for home appliances. Different consumer electronics
appliances are controlled and managed using remote control units based on Infrared (IR)
signal in home environments. Instead of IR technology, the group used ZigBee technology.
This study is intended for dynamic control scheme controlling and managing IR controllable
multiple legacy consumer electronics appliances based on ZigBee protocol or the
IEEE802.15. The design implementation is critical for clock synchronization as digital clocks
are included in consumer electronics and is widely used in home and workplaces. The paper
relates the controlling of the devices specifically digital clocks to be synchronized using
ZigBee. The design of the Synchronize Portable Scoreboard is similar to this because it has a
game clock which is similar to the remote controls for appliances. Game clock needs to be
stopped at some point in the game if there is a violation called by the referee and it has to be
resumed to continue the game. This mechanism is also related to the paper wherein the laptop
acts as a remote and the scoreboard is the appliances.
8
Applications of ZigBee
ZigBee commonly used as a remote control for equipment that require low level of
complexity such as home lighting systems, refrigerator and washing machines. The earlier
methods of remote control are the proprietary routing algorithms and Radio Frequency
technology (Zheng et al, 2006). Since the main objectives of this paper is to design a wireless
scoreboard Zigbee-controlled home appliances have similar application to the Portable
Synchronize Scoreboard. The laptop will control the scoreboard wirelessly by using the
installedGUI.
Humans are aware on how to fight chronic diseases such as cancer and heart attack.
Hospitals also consider the wireless technology as a tool in scanningpatients. Now most
hospitals use a fixed medical monitor to obtain the patient's physiological indicators, which
can take information by printer or LCD. Nurses constantly need to read important monitor
data in the ward and record it. In this method, some writing mistakes may be made and this
will limit the patient’s freedom of activity to some extent (Zhao et al., 2005).
Doctors,monitoring their patients’ condition, can only stay in his office then monitor the
patients via laptop or computer. They do not need to examine their patients. Wireless
technologies are used to rapidly exchange images, data, audio, and other information
between remote locations. These technologies are currently being applied to improve
healthcare around the world (A Framework for SIP-Based Wireless Medical Application,
2005; Jovanov, 2005; Cypher et al., 2006).
System designs for modern wireless sensor systems are based on low capability
microprocessors and limited range radios since such designs have small physical size and
limited energy budgets. But given the fact that these sensor nodes are based on low-cost
9
components, development supplies for wireless sensor network are somewhat expensive, just
like the sensor nodes. Instead of making the cost a few dollars less, these “low cost” systems
usually cost above a hundred dollars each. Such cost of the system is affected by the wide
variety of sensor nodes available and the limited market size for any one node. The said
concern prompted the researchers to develop this study which aims to develop a low-cost
prototyping platform that is based on existing open-source PCB designs and software
environments. This project used Arduino low-cost microprocessor platform, XBEE low-cost
Zigbee networking modules, and open-source TinyOS software system. (Bergmann et
al.,2010).
A study in Malaysia used Zigbee as a switch in electrical appliances. The purpose of
this project is to design an automation system that can be used to switch ON, OFF and know
the STATUS of the electrical appliances by using personal computer. This project focused on
developing an automation system with Zigbee wireless technology which is controlled by
programmable interface controller (PIC18F14K50). This overall project is divided into two
parts. The first part concerns the hardware development where all electronic components are
connected to a single board. Personal computer is the input component while fluorescent
lamp and fan are the output component which are controlled by controller circuit. Zigbee is a
new technology, which has at its centre the goal of eliminating wired connections between
home appliances and personal computer. Instead of connecting with wires, every appliance
has small transmitters or receivers (Kuppusamy, 2010).
10
Microcontroller
Microcontroller has an input device in order to get the input and an output device
such as LED or LCD display to exhibit the final process. It processes its input resulting to its
output depending on the design of the microcontroller. One example of the application of the
microcontroller is the television. It has a remote control as an Input device and the TV screen
as the output device. The signal that will be sent from the remote control is captured by the
microcontroller. Each button on the remote controller has a function. The microcontroller at
the receiving end, which is inside the television, controls the channel selection, the volume
and picture tube adjustments such as hue, brightness, contrast. In relation to the project
design proposal, the input data will pass by the Zigbee transmitter to its receiver and to the
microcontroller which also serve as a bridge to the scoreboard in transmitting data (Axelson,
1994).
Arduino is a popular open-source single-board microcontroller. This is designed to
make theprocess of using electronics in multidisciplinary projects more accessible. The
hardware consists of a simple open hardware design for the Arduino board with an Atmel
AVR processor and on-board input/output support. The software consists of a standard
programming language compiler and the boot loader that runs on the board (Shiffman, 2009).
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. In
addition, Arduino projects can be stand-alone and can communicate with software running
on a computer (e.g. Flash, Processing, Max MSP).
11
Graphical User Interface
A Graphical User Interface(GUI) component is a visual object with which the user
interacts via the mouse or the keyboard. An event-driven application can respond to or
handle events the GUI elements generate from an action of the user over them (Robles,
2007). The GUI is used to simplify the commands in a way that can be understood by
common people. The prototype is controlled by pressing the button which corresponds to a
command.
Most software systems today provide a GUI as the main interface to deliver
functionality for the customer. While many developers consider the GUI to be a less critical
part of the system, it is essential to customers, who must use it whenever they need to interact
with the system. In relation to the design proposal, the GUI will serve as the main control of
the scoreboard, the command software of GUI will serve as an input to be transmitted to the
hardware.
The GUI created by the group is the main program that will enable the user to upload
the scores in the scoreboard, to pause and resume the game clock, and to reset the shot clock
if needed. Furthermore, the GUI is very easy to use for the user to upload the data accurately
and correctly.
12
Chapter 3
PORTABLE SYNCHRONIZED BASKETBALL SCOREBOARD USING ZIGBEE
Abstract
The scoreboard of any sport shows the status of the game by displaying the
significant data like time and the team scores. Players and viewers rely on the numerical
figures that are shown on the scoreboard especially the scores of each team and the game
clock to determine which team is winning. Since the technologies nowadays are accelerating
very fast, the present scoreboard can be improved by reducing its size and making it wireless.
Existing scoreboard is permanently placed at a higher location where viewers can see it.
However, it usually takes time for people to set it up and when it encounters trouble, they
will have difficulty repairing the system. The scoreboard designed in this study is portable
because it can be easily assembled and repaired. It is also wireless. These features are in
keeping with current trends in every new gadget nowadays. The design also synchronizes the
scoreboard to a laptop through a Zigbee signal.
Keywords: Scoreboard, Portability, Zigbee, Synchronize
Introduction
Basketball is a team sport in which two teams of five players try to score points by
throwing or "shooting" a ball through the top of a basketball hoop while following a set
of rules. Basketball is one of the world's most popular and widely viewed sports (Borger,
2008). Looking at Figure 1.1 (Scoring Diagram), one point can be earned when the ball is
thrown by a free throw while two points inside the arc and three points beyond. At the end of
the game, the team with higher earned points will be declared winner. Basketball scoreboard
is very essential to people who understand the game. Commonly the scoreboard is located
near the committee to be able to update the scores via a computer connected to the gadget. In
this manner, the scores are updated using a program that sends the input from the laptop to
the scoreboard. Digital scoreboard applies technology to the scoreboard because in the old
13
times, the scores are written on board which can be erased or even edited that may result to
cheating.
Figure 1.1 Scoring Diagram
Source: http://www.coaching-basketball-for-beginners.com/half-court-basketball
http://www.coaching
basketball-diagram.html
Traditional scoreboard uses a board with the team name pplaced
laced at the top and the
corresponding score below its name. The game time is only declared verbally by the
announcer same with the shot clock. As time evolves, the scoreboard has been innovated and
it became technical by using a seven segment display as illustrated
illustrated in Figure 1.2 (Typical
Scoreboard). The proposed new design in scoreboard is that it will be wireless and portable
through the use of ZigBee. The idea of the project came from the Synchronized Wireless
Clock wherein the clock is displaying the ttime
ime of the computer. Since the clock is operating
wirelessly, the researchers came up with an idea that the concept can be applied in the
Basketball Scoreboard making the old design wireless and portable. So it is poised to become
a very significant enabling
ng technology in many fields, as it is widely used in military
security, environment monitoring, and home automation (Cao et al, 2008). ZigBee is also
considered as a new standard intended for low cost devices in automation, home controls and
14
computer peripherals. It enables the broad-based deployment of wireless networks with low
cost, and low power solutions (Ondrei et al, 2006, Heile, 2004).
Figure 1.2 Typical Scoreboard
Source:http://antipolocity.olx.com.ph/tronix-electronic-basketball-scoreboard-iid-181750357
In any ball game, the use of scoreboard is very important because it is where the
players and audience are informed of the game status such as time elapsed or time left, the
team scores, and other information that the general audience should know. If scoreboards are
available in a game venue, they are normally permanently attached and cannot be moved
from one venue to another. If a venue has no scoreboard available, there are several things
can unwontedly happen and one of there is cheating. If a portable scoreboard is available, the
game can run smoothly. This paper will attempt to solve the aforementioned conditions by
creating a wireless portable scoreboard that can be used in basketball games.
The objectives of the study are the following:
1. to design a wireless and portable basketball scoreboard
2. to synchronize the laptop and scoreboard using Zigbee
15
The significance of the study is for the researchers to have a wider knowledge in
microcontrollers and other peripherals which are included in making the prototype. Data
transmission is also studied since it is wireless. It will be easy to operate and troubleshoot
unlike the existing ones which have wires.
The scoreboard that will be designed has the ability to display the remaining time,
team points, team foul and shot clock as illustrated in Figure 1.2. The system is limited in
using ZigBee as the medium for transferring the data from the laptop to the scoreboard. The
Graphical User Interface is also provided as the software to input the data to be displayed in
the scoreboard. However, like any wireless operating gadget, the expected performance of
the scoreboard is only found satisfactory within a maximum radius of 200 feet from the base
station which is the Zigbee transmitter. The study does not cover how to increase the
maximum allowable distance between the Zigbee transmitter and its receiver. Furthermore, it
does not include troubleshooting the prototype and repairing. The study also follows the old
rule of playing basketball wherein there is no 14 reset shot clock.
16
Previous Study of Wireless Scoreboard
The main study of this wireless scoreboard display system is the use of the radio
transmitter and receiver and a remote controller. The similarity between the radio
transmitter/receiver and ZigBee wireless device is that both have 2.4 GHz transmission
bandwidth, while the difference is the limitation of the displacement and speed that a radio
transmitter can compare to the ZigBee.
In a study(author,year), the designed scoreboard consists of a wireless scoreboard
display system with at least two scoreboard displays, two controllers, a radio transmitter in
each controller, and a radio receiver in each scoreboard display either together or separately
from one or both controllers. This design is quite complicated because it is difficult to control
two scoreboard displays from one controller or two controllers, and it is always necessary to
rewire the controllers. This is especially the case in indoor basketball games where
scoreboard displays are operated for the entire court using one controller or for split courts
using two controllers.
Radio transmitters 16 and 18 and radio receivers 24 and 26 are 2.4 GHZ spread
spectrum radio devices. The radio devices eliminate interference by the use of frequency
hopping from outside sources including cordless phones and other RF devices on the same
frequency (Uehran, 2005).The proponents will use wireless sensor signal which is actually
the ZigBee rather than radio frequency.
The radio receivers 24 and 26 are housed in ABS plastic enclosures, which are easily
mounted inside the scoreboard displays 20 and 22 with a small dipole antenna mounted to the
face of or adjacent to the scoreboard displays 20 and 22. Outdoor scoreboard displays 20 and
17
22 can include rubber gaskets to keep moisture out of the enclosures. The radio receivers 24
and 26 can include a rotary switch or other selection device allowing the user to select
different operating channels, normally set once during installation. The instant invention can
be used in multi-field complexes, such as in baseball, enabling each system to operate
independently without interfering with one another. Currently, there are 16 channels
available to select from with the ability to expand to 77 non-interfering channels (Uehran,
2005).
The prototype design is an improvement of existing design because it uses a wireless
scoreboard with the aide of ZigBee, microcontrollers, and a laptop or personal computer.
Introduction to Zigbee
ZigBee is a low-cost, low-power, wireless mesh network standard. Due to its lowcost, it can be extensively distributed in wireless control and monitoring applications. Thanks
to its low-power consumption, it can use smaller batteries and still last for months or even
years. Mesh networking results a high reliability and greater range. It is cheaper and simpler
than other WPAN (wireless personal area network) like Bluetooth. Zigbee chips vendors
usually sell integrated radios and microcontrollers with between 60 KB and 256 KB flash
memory. The ZigBee Alliance is a group of companies working together to enable reliable,
cost-effective, low-power, wirelessly networked, monitoring and control products based on
an open global standard. Their goal is to provide the consumer with ultimate flexibility,
mobility, and ease of use by building wireless intelligence and capabilities into every day
devices. ZigBee technology will be embedded in a wide range of products and applications
for the needs of remote monitoring and control applications, including simplicity, reliability,
18
low-cost and low-power. With acceptance and implementation of ZigBee, interoperability
will be enabled in multi-purpose, self-organizing mesh networks.
Figure 2.1: Comparison of Existing Signals
Source:http://i.cmpnet.com/eetimes/news/07/02/DC1464_UTH_2_PG_38.jpg
As seen in Figure 2.1 (Comparison of Existing Signals), the Zigbee has a data rate of
100kilobytes per second and operates in 50 meters unlike in Bluetooth which operates at only
10 meters. Wi-fi also operates at 50 meters and has a data rate of 200megabits per second.
Wi-fi has very high data rate compared to Zigbee because it specializes in transferring large
sizes of data such as video and sounds. However, transferring large size requires larger power
to accommodate that high data rate.
19
Studies on ZigbeeWireless Sensor Networks
The Institute of Electrical and Electronics Engineers (IEEE) has a large collection of
studies. Researchers’ designs and projects are related to ZigBee wireless sensor network
technology. There are some studies that are important and somehow related to the design
prototype. These articles and studies are as follow:
IEEE members namely Wan-Ki, Chang-Sic, Han J. and Han I., (2007) implemented
ZigBee-based universal remote control for home appliances. Different consumer electronics
appliances are controlled and managed using remote control units based on Infrared (IR)
signal in home environments. Instead of IR technology, the group used ZigBee technology.
This study is intended for dynamic control scheme controlling and managing IR controllable
multiple legacy consumer electronics appliances based on ZigBee protocol or the
IEEE802.15. The design implementation is critical for clock synchronization as digital clocks
are included in consumer electronics and is widely used in home and workplaces. The paper
relates the controlling of the devices specifically digital clocks to be synchronized using
ZigBee. The design of the Synchronize Portable Scoreboard is similar to this because it has a
game clock which is similar to the remote controls for appliances. Game clock needs to be
stopped at some point in the game if there is a violation called by the referee and it has to be
resumed to continue the game. This mechanism is also related to the paper wherein the laptop
acts as a remote and the scoreboard is the appliances.
20
Applications of ZigBee
ZigBee commonly used as a remote control for equipment that require low level of
complexity such as home lighting systems, refrigerator and washing machines. The earlier
methods of remote control are the proprietary routing algorithms and Radio Frequency
technology (Zheng et al, 2006). Since the main objectives of this paper is to design a wireless
scoreboard Zigbee-controlled home appliances have similar application to the Portable
Synchronize Scoreboard. The laptop will control the scoreboard wirelessly by using the
installed GUI.
Humans are aware on how to fight chronic diseases such as cancer and heart attack.
Hospitals also consider the wireless technology as a tool in scanning patients. Now most
hospitals use a fixed medical monitor to obtain the patient's physiological indicators, which
can take information by printer or LCD. Nurses constantly need to read important monitor
data in the ward and record it. In this method, some writing mistakes may be made and this
will limit the patient’s freedom of activity to some extent (Zhao et al., 2005). Doctors,
monitoring their patients’ condition, can only stay in his office then monitor the patients via
laptop or computer. They do not need to examine their patients. Wireless technologies are
used to rapidly exchange images, data, audio, and other information between remote
locations. These technologies are currently being applied to improve healthcare around the
world (A Framework for SIP-Based Wireless Medical Application, 2005; Jovanov, 2005;
Cypher et al., 2006).
System designs for modern wireless sensor systems are based on low capability
microprocessors and limited range radios since such designs have small physical size and
limited energy budgets. But given the fact that these sensor nodes are based on low-cost
21
components, development supplies for wireless sensor network are somewhat expensive, just
like the sensor nodes. Instead of making the cost a few dollars less, these “low cost” systems
usually cost above a hundred dollars each. Such cost of the system is affected by the wide
variety of sensor nodes available and the limited market size for any one node. The said
concern prompted the researchers to develop this study which aims to develop a low-cost
prototyping platform that is based on existing open-source PCB designs and software
environments. This project used Arduino low-cost microprocessor platform, XBEE low-cost
Zigbee networking modules, and open-source TinyOS software system. (Bergmann et
al.,2010).
A study in Malaysia used Zigbee as a switch in electrical appliances. The purpose of
this project is to design an automation system that can be used to switch ON, OFF and know
the STATUS of the electrical appliances by using personal computer. This project focused on
developing an automation system with Zigbee wireless technology which is controlled by
programmable interface controller (PIC18F14K50). This overall project is divided into two
parts. The first part concerns the hardware development where all electronic components are
connected to a single board. Personal computer is the input component while fluorescent
lamp and fan are the output component which are controlled by controller circuit. Zigbee is a
new technology, which has at its centre the goal of eliminating wired connections between
home appliances and personal computer. Instead of connecting with wires, every appliance
has small transmitters or receivers (Kuppusamy, 2010).
22
Microcontroller
Microcontroller has an input device in order to get the input and an output device
such as LED or LCD display to exhibit the final process. It processes its input resulting to its
output depending on the design of the microcontroller. One example of the application of the
microcontroller is the television. It has a remote control as an Input device and the TV screen
as the output device. The signal that will be sent from the remote control is captured by the
microcontroller. Each button on the remote controller has a function. The microcontroller at
the receiving end, which is inside the television, controls the channel selection, the volume
and picture tube adjustments such as hue, brightness, contrast. In relation to the project
design proposal, the input data will pass by the Zigbee transmitter to its receiver and to the
microcontroller which also serve as a bridge to the scoreboard in transmitting data (Axelson,
1994).
Arduino is a popular open-source single-board microcontroller. This is designed to
make the process of using electronics in multidisciplinary projects more accessible. The
hardware consists of a simple open hardware design for the Arduino board with an Atmel
AVR processor and on-board input/output support. The software consists of a standard
programming language compiler and the boot loader that runs on the board (Shiffman, 2009).
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. In
addition, Arduino projects can be stand-alone and can communicate with software running
on a computer (e.g. Flash, Processing, Max MSP).
23
Graphical User Interface
A Graphical User Interface (GUI) component is a visual object with which the user
interacts via the mouse or the keyboard. An event-driven application can respond to or
handle events the GUI elements generate from an action of the user over them (Robles,
2007). The GUI is used to simplify the commands in a way that can be understood by
common people. The prototype is controlled by pressing the button which corresponds to a
command.
Most software systems today provide a GUI as the main interface to deliver
functionality for the customer. While many developers consider the GUI to be a less critical
part of the system, it is essential to customers, who must use it whenever they need to interact
with the system. In relation to the design proposal, the GUI will serve as the main control of
the scoreboard, the command software of GUI will serve as an input to be transmitted to the
hardware.
The GUI created by the group is the main program that will enable the user to upload
the scores in the scoreboard, to pause and resume the game clock, and to reset the shot clock
if needed. Furthermore, the GUI is very easy to use for the user to upload the data accurately
and correctly.
24
Design Outline
The following is the design outline of the prototype: 1) decide what are the data to be
displayed in the scoreboard; 2) gather existing schematic diagrams of existing electronic
scoreboard; 3) purchase the items to be used in building the project; 4) test the 7segment
led’s to be used; 5) design a GUI for data input; 6) synchronize the Zigbee to the laptop; 7)
test the project; 8) design the enclosure of the scoreboard.
Initial Planning
Before starting to work on the actual prototype, the circuits needed to buildthe
prototype must be decided. A microcontroller is neededto process the output from Zigbee and
for processing the output which will be the source input of the LED as a signal. Arduino
microcontroller which has an output of 64 bits is used. Since the scoreboard uses largeseven
segment display which is rated at 12 volts and a microcontroller that has an output of five
volts, there is a need to increase the voltage rating of the LED. To make this possible, a
Darlington Pair integrated circuit is used to amplify the voltage rating of the LED.
25
Conceptual Diagram
Zigbee Transmitter
User
Laptop
Scoreboard
Zigbee Receiver
Microcontroller
Figure 3.1 Conceptual Diagram
26
Conceptual Framework
The design conceptual diagram, as illustrated in Figure 3.1(Conceptual Diagram)
shows the overall concept and flow of the prototype design. Through the use of laptop, the
user can synchronize the data such as the updating the score and stop or run the game clock
and shot clock using the graphical user interface installed in the computer. The application
software will serve as the interface between the computer and the scoreboard. After receiving
information from the user, the laptop will transmit this information to the wireless
communication devices, which is the ZigBee module. The ZigBee module’s sole function is
the synchronization of the scoreboard..
The design of the portable scoreboard is 750mm X 500mm. Its weight can reach
approximately 1.5kg because the enclosure will contributes more than half of the main
peripherals. The main feature of the scoreboard is its capability to interact with the laptop
wirelessly. It displays shot clock, team scores and game time. The researchers only chose
those to minimize the dimension of the scoreboard and to enhance its portability.
27
Design Procedures
The actual design of the scoreboard is based on the scoreboard as shown in
Figure 1.2(Typical Scoreboard). To have a portable scoreboard, there is a need to reduce the
size of the new design scoreboard. To make this possible, only the necessary data needed in a
scoreboard was retained. The prototype included team scores, game and shot clock, team
fouls, period and time outs. The sizes of the LED display of the scoreboard were minimized.
Since the most important display are team scores and game clock, five inches LED display
was used to show this data while the remaining data used 3.5 inches of LEDs.
Building the Portable Synchronized Basketball Scoreboard Using Zigbee
A flowchart which served as a guide in building the prototypeis illustrated in Figure
3.2(Design Procedure Flow Chart).
The Design Flow Chart seen in Figure 3.2 (Design Flow Chart) is the guide to build
the prototype. First step is to find data sheets and schematic diagrams of the LEDs and
Integrated Circuit (IC) that will be used upon building the prototype. Then the usefulness of
the data gathered was assessed.Then the needed materials for the prototype were
prepared.Materials purchased were resistors, LEDs, ICs, breadboards and Printed Circuit
Board (PCB). These were tested before assembly in breadboard according to the schematic
diagram. The designed prototype underwent a series of testing.When everything was found in
order, the PCBs were prepared. The connections of PCB and breadboard are the same.
Hence, the schematic diagram would be translated in PCB. After which, the components
were assembled using the working components to the PCB and tested to check if the
prototype was working properly. If not, troubleshooting would be done in PCB.The
components were then placed in an enclosure. Then the components were subjected to final
28
testing to assess if the prototype was ready. Problems encountered during the final testing
would lead to troubleshooting on the prototype to measure data. The data to be gathered are
Signal Strength in varying distance and Time Delay in varying distance. After which, the
measured data were analyzed and through this, the conclusions were made.
A
START
TESTING
SEARCH DATASHEETS
AND SHEMATIC
DIAGRAMS
IS THE DATA
USEFUL?
TROUBLESHOOT
IS THE
PROTOTYPE
WORKING?
NO
NO
YES
TRANSLATE THE
SHCEMATIC DIAGRAM IN
PCB
YES
CANVASS/PURCHASE
MATERIALS FOR
PROTOTYPE
ASSEMBLE THE
PROTOTYPE USING THE
SCHEMATIC CIRCUIT IN
PCB
TESTING OF THE
MATERIALS
USE OTHER
MATERIALS
IS THE
MATERIALS
WORKING?
YES
ASSEMBLE THE
PROTOTYPE USING THE
SCHEMATIC CIRCUIT IN
BREADBOARD
A
TESTING
TROUBLESHOOT
NO
IS THE
PROTOTYPE
WORKING?
NO
YES
ASSEMBLE THE
PROTOTYPE IN THE
ENCLOSURE
B
29
B
PROTOTYPE FOR FINAL
TESTING
TROUBLESHOOT
IS THE
PROTOTYPE
READY?
DATA GATHERING
INTERPRETATION AND
ANALYSIS OF DATA
DRAWING OF CONCLUSION
END
Figure 3.2: Design Flow Chart
30
1. Scoreboard Display
Figure 3.3: Scoreboard Display
A Figure 3.3 (Scoreboard Display) shows the necessary data to be displayed
by the scoreboard like game clock, shot clock, team fouls, period or quarter and time
outs as arranged in the said figure. The topmost display is the game clock which
shows the remaining time per quarter. The maximum time of the game clock displays
is 10:00. Team scores are displayed under Home and Visitor. A team’s score can be
displayed in Home or in Visitor depending on the user. Home’s score is displayed in
the left portion of the scoreboard while the Visitor’s score is displayed in the right.
The Period shows the present quarter of the game. In every change in ball possession
the shot clock changes from 24 seconds. Upon this duration the team who has the
possession of the ball has to make a shot within this time. Therefore, the Shot clock
displays the remaining time that a team who has the ball has to make a shot. Both
teams have a Foul and Timeout. Team Foul displays how many foul a team has made.
31
It is important to count this because when a team has incurred five fouls in a quarter,
this team will be penalizedby awarding two free throws to the other team. The
Timeouts displays the remaining timeouts of each team. Five inches of LEDs was
used in displaying team scores and game clock and the remaining displays used 3.5
inches.
2. Inventory and Canvassing
The materials needed for the prototype were purchased after careful inventory
and canvassing from several electronic shops were made. The materials purchased
were seven segment LEDs, resistors, breadboards and wire and other components.
The power supply, shown in the Figure 3.4 (Power Supply), has output voltage of 5
volts and 12 volts. Since LEDs have different pin assignments depending on the
manufacturer, the seven segment LED display was chosen for uniformity.
Figure 3.4: Power Supply
32
3. Testing of 7 Segment LEDs
The LEDs was tested by tracing
tracing the pin assignments using breadboard
breadboard.
Figure 3.5: Testing of LEDs
As seen in Figure 3.5 (Testing of LEDs), both
oth LEDs have different pin
assignment but they are both found to be operating in common voltage at 12V supply.
There is a problem in the microcontroller side because its output is only 5V. There is
a IC found to step up the voltage to 12V which is the Darlington pair or
UNL2003A.The
.The microcontroller has 64 bits output and must be decoded by a 74LS48
which is a BCD to 7 Segment Decoder for the LEDs. The Figure 3.5 (Testing of
LEDs) shows the successful testing of LEDs.
33
4. Translating of Schematic Diagram in PCB
The schematic diagram was generated in the testing of LEDs using
breadboard. Through the schematic diagram shown in Figure 3.6 (Schematic Diagram
of Each LED), the connections can now be translated to a Printed Circuit Board
shown in Figure 3.7(Translating the Schematic Diagram to PCB)and it is also
subjected to testing. The schematic diagram can be translated using PCB software to
be printed and photo in blank Printed Circuit Board and etched. The PCB is also
checked if there are shorted connections. The group also used IC holders for the
Darlington Pair and decoder. After completing a sample circuit, it was also subjected
to a testing by a counter circuit to verify if the LED will have the expected output. If
the sample is verified, then, all LEDs will be translated to PCB and checked.
Figure 3.6: Schematic Diagram of Each LED
In Figure 3.6(Schematic Diagram of Each LED), is another representation of
each LED connected in series with the 100Ω resistor while that resistor is connected
in IC UNL2003A which is a Darlington Pair circuit. The Arduino is the
microcontroller thatprocess the signal received by the Zigbee Receiver. Since the
34
Arduino has an output of binary signal that needs to be decoded by a BCD. 74LS248
is the BCD decoder which decodes the signal coming from the Arduino. That signal
must be decoded because the LEDs uses decimal signal as its input. 74LS48 is
connected to a Darlington Pair IC to regulate the voltage that will be used by the
LEDs. Also, it is typical to connect the pins of each LED to a resistor to lessen the
current in the circuit. The group decides to use a 100Ω resistor. The LEDs used in the
prototype has a input of 12V while the ICs and the microcontroller has a supply of
5V.
Figure 3.7: Translating the Schematic Diagram to PCB
The Figure 3.7 (Translating the Schematic Diagram to PCB)is the PCB used
in LEDs. The PCB in 2.3 inches and 5 inches are similar.
35
5. Creating Graphical User Interface
The Graphical User Interface as shown Figure 3.8 (Graphical User
Interface)will serve as the controlling software for the scoreboard. Microsoft Visual
Studio which be used for the program of the Arduino AT MEGA 2560 while the
language used in program is C#.
Figure 3.8: Graphical User Interface
As seen in Figure 3.8 (Graphical User Interface), the scoreboard and the GUI
have similar arrangement. The buttons are arranged in the upper portion of the GUI.
Each button corresponds to a command that will change the display of the GUI and in
the scoreboard. The detailed command is presented in Table 3.1 (GUI Command
Details).
36
6. Pin Configuration of Arduino
The signal received from the laptop was processed by the Arduino circuit. The
Arduino provides a binary signal and translates to decimal to be used by the LEDs.
The pin configuration is shown in Figure 3.9 (Pin Configuration of Arduino)
Figure 3.9: Pin Configuration of Arduino
Figure 3.9(Pin Configuration of Arduino) is the pin assignment of each LED for
each display. Each LED has four wires, labeled as A, B, C, D as an input to the BCD
IC which is to be connected in microcontroller which is the Arduino. Each wire
corresponds to the connection in microcontroller. For example in Period LED; A is
connected in pin #4, B is connected in pin#3, C is connected in pin#2 and lastly the D
37
is connected in common ground. There is a “pinA#” where “A” is the analog section
found in the Arduino microcontroller. For example in the ones value of the time
which is the right most part where it’s A is connected in pin#A11, B is connected in
pin#A10, C is connected in pin#A9 and D is connected in pin#A8. Each LED’s has
corresponding connection to the Arduino illustrated in the said figure. If there is error
in connecting these wires, there will be error in the display in the scoreboard but the
error will not appear in the GUI.
7. Initial Testing of the Prototype
The testing was done by simply testing the initial condition of the scoreboard.
As long as the scoreboard displays the same data both in the laptop and in the
scoreboard, this test will be accepted. The objective of this test is to determine if there
is a pin shorted to another pin or to the ground. Troubleshooting is done until the
scoreboard is operating at expected condition.
8. Prototype Enclosure
Figure 3.10: Prototype Enclosure
After the scoreboard has been tested, the last procedure is designing its
enclosure. The glass shown in Figure 3.10 (Prototype Enclosure) is used at the front
38
and back portion of the scoreboard while aluminum is used in its corners. This glass
is acrylic in color red that enhances the red light emitted by the each LED. This
enclosure also acts as a protection for the inner components of the scoreboard.
Aluminum is used in corners because aluminum absorbs the heat produced by the
power supply, LEDs and other components of the scoreboard.
Testing of the Prototype
Several testing was done to examine the behavior of the prototype. This includes the
following:
1. Data Precision Test
This test is to determine if the GUI is sending accurately the right command that
corresponds to each button shown. Pressing each button, should lead to acorresponding
changein the display of the GUI and this change must be also reflected in the scoreboard.
Procedure:
1. Connect the Zigbee receiver and transceiver to the scoreboard and to the
computer respectively.
2. Open the Scoreboard application software.
3. Choose the COM setting of the Zigbee for the computer.
4. Click one button for trial testing.
5. Record the result.
6. Repeat procedure 5 and 6 for another button.
7. Repeat procedure 5 to 7 for another trial.
39
Button Name
Command Details
HomeScorePlus1_btn
HomeScorePlus2_btn
HomeScorePlus3_btn
HomeScoreMinus1_btn
HomeFoulsPlus1_btn
HomeFoulsMinus1_btn
HomeTimeoutPlus1_btn
HomeTimeoutMinus1_btn
AwayScorePlus1_btn
AwayScorePlus2_btn
AwayScorePlus3_btn
AwayScoreMinus1_btn
AwayFoulsPlus1_btn
AwayFoulsMinus1_btn
AwayTimeoutPlus1_btn
AwayTimeoutMinus1_btn
Play_btn
Stop_btn
ResetClock_btn
Increases Home Score by 1 point
Increases to Home Score by 2 points
Increases to Home Score by 3 points
Decreases to Home Score by 1 point
Increases the Home Team Foul by 1
Decreases the Home Team Foul by 1
Increases the Home Timeout by 1
Deceases the Home Timeout by 1
Increases Away Score by 1 point
Increases to Away Score by 2 points
Increases to Away Score by 3 points
Decreases to Away Score by 1 point
Increases the Away Team Foul by 1
Decreases the Away Team Foul by 1
Increases the Away Timeout by 1
Deceases the Away Timeout by 1
Run the Game Clock
Stops the Game Clock
Resets the Shot Clock to 24
Table 3.1: GUI Command Details
Table 3.1: (GUI Command Details) is the list functions of each button
seen in the GUI. As results, all of the buttons in the GUI results to correspond in their
certain commands. The HomeScorePlus1_btn adds 1 point to Home’s score,
HomeScorePlus2_btn adds 2 points and HomeScorePlus3_btn adds 3 points while
HomeScoreMinus1_btn deducts 1 point to Home’s score. The AwayScorePlus1_btn
adds 1 point to Away’s score, AwayScorePlus2_btn adds 2 points and
AwayScorePlus3_btn adds 3 points while AwayScoreMinus1_btn deducts 1 point to
Away’s score. HomeFoulsPlus1_btn adds 1 value in Home’s team foul while the
AwayFoulsPlus1_btn adds 1 value in Away’s team foul. HomeTimeoutPlus1_btn
adds 1 value in Home’s Timeout while HomeTimeoutMinus1_btn deducts value by 1.
AwayTimeoutPlus1_btn
adds
1
value
in
Away’s
Timeout
while
40
AwayTimeoutMinus1_btn deducts value by 1. Play_btn lets the time runs awhile the
Stop_btn freezes the time. The ResetClock_btn resets the shot clock to 24 seconds.
Through this test, all buttons correspond to their command in the GUI and the
Scoreboard. Therefore, the GUI and the Scoreboard are synchronized. These details
must be reflected in GUI and in the scoreboard.
Button Name
HomeScorePlus1_btn
HomeScorePlus2_btn
HomeScorePlus3_btn
HomeScoreMinus1_btn
HomeFoulsPlus1_btn
HomeFoulsMinus1_btn
HomeTimeoutPlus1_btn
HomeTimeoutMinus1_btn
AwayScorePlus1_btn
AwayScorePlus2_btn
AwayScorePlus3_btn
AwayScoreMinus1_btn
AwayFoulsPlus1_btn
AwayFoulsMinus1_btn
AwayTimeoutPlus1_btn
AwayTimeoutMinus1_btn
Play_btn
Stop_btn
ResetClock_btn
Initial State
0
0
0
2
0
2
0
2
0
0
0
2
0
2
0
2
10:00
--
0
Final State
GUI
Scoreboard
1
1
2
2
3
3
1
1
1
1
1
1
1
1
1
1
1
1
2
2
3
3
1
1
1
1
1
1
1
1
1
1
09:59…
09:59…
--24
24
Table 3.2: Data Precision Testing
By pressing each button,one sees a change in the scoreboard and in the GUI.
Therefore, the display in the GUI and in the scoreboard must be the same. Otherwise,
troubleshooting must be done. When a button is pressed, it mustcorrespond to the
command details as seen Table 3.1 (GUI Command Details). For further examination
of each of the buttons seen in Table 3.2 (Data Precision Testing), the group created a
41
data wherein there is initial state and final state of the display of the scoreboard and
the GUI. Initial state is the display of the scoreboard and GUI when the button is not
pressed and the final state is the display of the scoreboard and GUI when the button is
pressed.
Assuming the initial state of Home’s score is 0, when HomeScorePlus1_btn is
pressed, the score will be 1, if HomeScorePlus2_btn is pressed, the score will be 2
and if HomeScorePlus3_btn is pressed, the score will be 3. This also corresponds to
Away’s score. Assuming the initial state of the Away’s score is 0, when
AwayScorePlus1_btn is pressed, the score will be 1, if AwayScorePlus2_btn is
pressed, the score will be 2 and if AwayScorePlus3_btn is pressed, the score will be
3. However, when the user needs to deducts a point to a certain team, he must press
HomeScoreMinus1_btn or AwayScoreMinus1_btn. Assuming the initial state of both
team scores is 2 and HomeScoreMinus1_btn is pressed, Home’s score will result to 1.
Also, if AwayScoreMinus1_btn is pressed, Away’s score will result also to 1. When
team fouls are to be increased, HomeFoulsPlus1_btn or AwayFoulsPlus1_btn must be
pressed. Assuming both team fouls is 0, when HomeFoulsPlus1_btn is pressed, it will
result to 1. Also, when AwayFoulsPlus1_btn is pressed, it will also result to 1. When
a team take a timeout, that team’s timeout should be deducted by 1. Assuming both
team timeouts is 2, when HomeTimeoutMinus1_btn is pressed, it will result to 1.
Also, when AwayTimeoutMinus1_btn is pressed, it will also result to 1. When the
user pressed the wrong button like the Away’s timeout instead of Home’s timeout, he
must press AwayTimeoutPlus1_btn to retain the value of the Away’s timeout or vice
versa. Assuming both team timeouts is 0, when HomeTimeoutPlus1_btn it will result
42
to 1. Also if the AwayTimeoutPlus1_btn is pressed, it will result to 1. Assuming the
game clock has initially displayed of 10:00, when Play_btn is pressed the game clock
begins to decrease per second. To reset the shot clock, the ResetClock_btn must be
pressed. Assuming the shot clock is 0, when the ResetClock_btn is pressed, it will
return to 24. To stop the game clock and shot clock, Stop_btn must be pressed.
2. Range Test
The objective of this testing is to determine the maximum distance that the Zigbees
can communicate with each other. The test is done by letting the time run and the
transmitter connected to the laptop is varied.
Procedure:
1. Connect the Zigbee receiver and transceiver to the scoreboard and to the
computer respectively;
2. Open the Scoreboard application software;
3. Choose the COM setting of the Zigbee for the computer;
4. Click one button for trial testing;
5. Let the game clock run and let the laptop and the scoreboard vary their
distance.
6. If the clock is running, create more distance from the laptop to the scoreboard.
7. Repeat the number 6 until the game clock in the scoreboard is not running.
8. Measure the maximum distance.
43
Figure 3.11 Range Testing
Figure 3.11 (Range Testing) shows maximum distance that the scoreboard and
the laptop communicate with each other. The scoreboard and laptop are found to have
communication when the game clock is running. Otherwise, there will be an error in
their communication and the game clock in the scoreboard will stop while the
laptop’s game clock runs. The maximum distance measured between the laptop and
the scoreboard is found to be 60 meters. Beyond this value, there will be an error.
44
Measuring Signal Strength
Circuit A, seen Figure 3.12 (Circuit A), is connectedto the laptop and it sends data to
Circuit B, as shown in Figure 3.13 (Circuit B), then from Circuit B, it loops back to circuit A
checking if the data sent by Circuit A will be sent back by Circuit B. By the use of the
program X-CTU seen in Figure 3.14 (X-CTU Program), the Signal Strength can be
measured. In every trial there is a five-meter difference and this test is composed of 12 trials
in total of 60 meters.
Figure3.12: Circuit A
Figure3.13: Circuit B
Figure 3.14: X-CTU Program
45
Distance
(m)
5
10
15
20
25
30
35
40
45
50
55
60
Signal Strength
Signal Strength Signal Strength
Without
With
Obstruction
Obstruction
(dB)
(dB)
-49
-54
-46
-58
-55
-67
-64
-60
-56
-57
-68
-69
-56
-60
-63
-65
-62
-76
-65
-67
-76
-76
-75
-81
Table 3.3:Signal Strength Test Results
The data shows that the signal is better when the system is operating at closer
distance. Signal strength of a Zigbee is measured in decibels (dB). The Signal
Strength of the Zigbee is better at the value closer to 0. However, the more negative
of the value means that the Signal Strength is weak. Zigbee was testedwith and
without obstruction. The condition “without obstruction” means that the transmitter is
literally in the line of sight of the scoreboard without blockage. While in the other
condition which is “with obstruction”, the transmitter is blocked from seeing the
scoreboard.
Table 3.3 (Signal Strength Test Results) presents the behavior of the signal
strength of the Zigbee with or without obstruction. With the signal strength without
obstruction at the distance 5 meters to 20 meters, the signal strength is seen to weaken
46
from -49 dB to -64dB and improves at 25 meters with -56dB but decreases to -68dB
at 30 meter distance. The signal strength gets better at 35 meter distance then it
decreases slowly until it reaches the 60 meter distance with -75dB.
The signal strength with obstruction starts with -54dB at 5 meters until
decreases to -67dB at 15 meters. After which, the signal improves at -60dB with 20
meter distance and gets better at 25 meters with a signal strength of -57dB. At 30
meters, the measured signal strength is -69dB and improves to -60dB at 35 meters.
The signal strength was -65dB at 40 meter distance and weakens to -76dB at 45
meters. After which, the signal improves at 50 meters with a measurement of -67dB.
At a distance of 55 meters, the signal strength is -76dB and weakens to -81dB at 60
meters.
As the distance increases, the signal strength weakens because it approaches
farther from 0. But when the system operates at closer distance, the resulting signal
strength is better. As seen in the Table 3.3 (Signal Strength Test Results), without
obstruction has better results compared to the other because in wireless technology,
without obstruction has a good signal reception because there is no interfering with
the path of the signal. Therefore, the signal can travel faster at open space. The results
show that most of the data at without obstruction has better signal strength. Therefore,
to have good signal strength, the system is advised to operate with minimum
obstruction. The best signal that the group measured was -49dB.
47
Signal Strength
-40
-45
Distance(m)
5 15 25 35 45 55
-50
-55
Signal
Strenth -60
(dB)
-65
Without
Obstruction
With Obstruction
-70
-75
-80
Graph 3.1: Distance VS Signal Strength
As seen in the Graph 3.1 (Distance VS Signal Strength), the data gathered
shows that if the distance is changed, it will mean a change in signal strength. The
larger the distance, it will produce a lower signal strength. Moreover, the graph also
shows that the prototype has a better Signal Strength at without obstruction. Looking
at the graph, the best signal strength is achieved at 10 meters when there is no
obstruction while the best signal strength with obstruction is experienced at 5 meters.
As expected, the lowest signal strength of the prototype is experienced at the farthest
distance which is 60 meters. The lowest signal strength of the prototype when there is
no obstruction is -75dB while -81dB when there is obstruction. Therefore it is found
that the distance is inversely proportional with the signal strength.
48
Measuring Time Delay
Time delay is very common in wireless transmission of data. Theoretically, the time
delay increases when the distance between the transmitter and receiver increases. The
researchers created a program to measure the time delay. What the program does is it sends
data from the laptop using the Zigbee to the scoreboard then the data loops back from the
scoreboard going back again to the laptop. The measured time by the laptop is the two way
process of sending back and forth of the signal. Therefore, the time delay of the system is
getting the average time of the 5 trials then dividing it by two. The display of the scoreboard
upon this testing is that it shows the time of the execution in 24 hour basis.
Time Received
Time Sent
Figure 3.15: Measurement of Time Delay
As seen in Figure 3.15 (Measurement of Time Delay) the time sent is the
encircled value while the boxed value is the time received.The Time Sent is the
recorded time when the laptop sends data to the scoreboard. Since the scoreboard
49
send back that data, the laptop records the time the moment it received the data. This
value is labeled Time Received. The difference of Time Sent and Time Received is
the two way transmission of data. The average of the Time Difference is divided by
two to obtain the Time Delay.
Time Delay
Distance
(m)
5
10
15
20
25
30
Trials
Time Sent
(sec)
1
2
3
4
5
1
2
3
4
5
1
2
3
4
5
1
2
3
4
5
1
2
3
4
5
1
0.1597992
0.1139795
0.6224184
0.2736329
0.7656076
0.0373133
0.3345609
0.0640364
0.0703246
0.6501308
0.0997028
0.1747385
0.6004915
0.2805358
0.1105944
0.5607538
0.3408179
0.2228898
0.0229469
0.7029898
0.0665037
0.3265447
0.2065893
0.6266277
0.5766682
0.1567516
Time
Received
(sec)
0.2568048
0.2099850
0.7164238
0.3626380
0.8656134
0.1333188
0.4355667
0.1670422
0.1723304
0.7441362
0.2107086
0.2727441
0.7004916
0.3805360
0.2005945
0.6607539
0.4308180
0.3028899
0.1229470
0.8029900
0.1765039
0.4265448
0.3165895
0.7166278
0.6666683
0.2667518
Time
Difference
(sec)
0.0970056
0.0960055
0.0940054
0.0890051
0.1000058
0.0960055
0.1010058
0.1030058
0.1020058
0.0940054
0.1110058
0.0980056
0.1000001
0.1000002
0.0900001
0.1000001
0.0900001
0.0800001
0.1000001
0.1000002
0.1100002
0.1000001
0.1100002
0.0900001
0.0900001
0.1100002
Average
Time
Difference
(sec)
0.09520548
0.09920566
0.09980236
0.09400012
0.10000014
0.09520548
Real
Time
4:45:48
4:49:21
4:51:23
4:53:12
4:55:00
4:56:44
4:57:23
4:58:59
4:59:39
5:00:10
5:01:13
5:02:06
5:03:23
5:03:57
5:04:05
5:05:58
5:05:44
5:07:35
5:08:16
5:08:46
5:14:42
5:15:11
5:15:43
5:16:10
5:16:39
5:17:39
Time
Delay (sec)
0.04760274
0.04960283
0.04990118
0.04700006
0.05000007
0.05100007
50
35
40
45
50
55
60
2
3
4
5
1
2
3
4
5
1
2
3
4
5
1
2
3
4
5
1
2
3
4
5
1
2
3
4
5
1
2
3
4
5
0.8167960
0.8968437
0.2168791
0.7469247
0.3370165
0.8252332
0.3152814
0.2153261
0.8153591
0.7765584
0.0366904
0.6267794
0.2568265
0.4268800
0.7540179
0.1240646
0.4641617
0.8043106
0.7143637
0.0444691
0.2145142
0.1045588
0.3446082
0.6746526
0.7747241
0.7347675
0.8948312
0.6248967
0.6634502
0.4435423
0.0536161
0.3936570
0.2837185
0.6137973
0.9167961
0.9968438
0.3168793
0.8469248
0.4270166
0.9252333
0.4152816
0.3153262
0.9153593
0.8765586
0.1266905
0.7267796
0.3568267
0.5368801
0.8540181
0.2240648
0.5641619
0.8943107
0.8143638
0.1544693
0.3145143
0.2045590
0.4346083
0.7746527
0.8747243
0.8247676
0.9948314
0.7248968
0.7634503
0.5435424
0.1436133
0.4936572
0.3837186
0.7037975
0.1000001
0.1000001
0.1000002
0.1000001
0.0900001
0.1000001
0.1000002
0.1000001
0.1000002
0.1000002
0.0900001
0.1000002
0.1000002
0.1100001
0.1000002
0.1000002
0.1000002
0.0900001
0.1000001
0.1100002
0.1000001
0.1000002
0.0900001
0.1000001
0.1000002
0.0900001
0.1000002
0.1000001
0.1000001
0.1000001
0.0899972
0.1000002
0.1000001
0.0900002
0.09520548
0.09520548
0.09520548
0.09520548
0.09520548
0.09599956
5:18:10
5:18:44
5:19:10
5:19:42
5:20:48
5:23:10
5:23:45
5:24:17
5:24:40
5:26:24
5:28:27
5:29:30
5:30:04
5:30:42
5:32:04
5:32:38
5:33:47
5:32:33
5:36:11
5:37:27
5:37:59
5:38:31
5:39:06
5:39:37
5:40:28
5:40:59
5:41:44
5:42:31
5:49:29
5:50:35
5:52:26
5:51:57
5:52:41
5:53:37
0.04900007
0.05000008
0.04900008
0.05000007
0.04900007
0.04799978
Table 3.4: Time DelayTesting Results
51
As seen in the Table 3.4 (Tine Delay Testing Results), in five meter distance,
the time delay of the prototype is 0.04760274 second. From that value, the time delay
increases to 0.04960283 second which occurs at 10 meter distance. It also increases to
0.04990118 second upon reaching the 15 meter distance. However, at 20 meter
distance of the prototype and scoreboard, the time delay decreases from 0.04990118
second to 0.04700006 second. But it increases at the 25 meter distance which is
0.05000007 second. In 30 meter distance, the time delay went to 0.05100007 second
and decreases to 0.04900007 second upon reaching 35 meter distance. At 40 meters,
the time delay is 0.05000008 second but decreases to 0.04900008 second at 45 meter
distance. At 50 meters, the time delay measured is exactly same at 25 meters which is
0.05000007 second. The time delay decreases as the distance approaches to 55 meters
from 0.05000007 to 0.04900007 second. It also improved when the distance increased
to 60 meters where the time delay measured is 04799978 second.
The smallest time delay occurred at 20 meter distance while the largest
occurred at 30 meter distance. It is also shown that the time delay of the prototype is
varying because the largest time delay measured does not occur in the farthest
distance while the lowest time delay does not happen in shortest distance. Time time
delay at 25 meters and 50 meters are the same whereas the time delay of the 5 meters
and the 60 meters is almost the same for the reason that their difference is roughly
100 microseconds.
52
Time Delay
Average Time (second)
0.05200000
0.05100000
0.05000000
0.04900000
0.04800000
Time Delay
0.04700000
0.04600000
0.04500000
5 10 15 20 25 30 35 40 45 50 55 60
Distance (meter)
Graph 3.2: Distance VS Time Delay
As seen in the Graph 3.2 (Distance VS Time Delay), Time Delay is not
constantly increasing for the reason that in 5 meters to 15 meters, the time delay
increasesthen abruptly decreases down to 20 meter distance. After which, the time
delay increases from 25 to 30 meters then decreases in 35 meter distance. At 40 meter
distance, the delay increases and decreases at 45 meters then increases at 50 meters
then decreases in 60 meters.
Time delay does not have a constant characteristic curve because of its
varying values. The prototype can operate within the said distance with a maximum
time delay of 0.05000007 second and minimum of 0.047000006 second based on the
data gathered by the group.
53
Statistical Treatment
Gathering data in time delay is done by taking five samples or trials per distance. In
statistics, the data will be accurate when there is more samples. After five trials are done, The
results are reviewed by looking if there is a data that is far from the majority. If there is, that
data will be replaced by taking another trial. If it exists again, then this data will be accepted.
Using these five trials, the average is taken and by this parameter, the delay can now be
compared to other distance as long as the system is operating at the optimum distance
determined by the range test.
In measuring the signal strength, the software X_CTU is used. This program helps to
record the signal strength of Zigbee. The less negative the value means the signal strength is
better. However, there are times when the signal strength is better at farther distance. It is
expected to have lower signal strength at farther distance andthe Zigbee conforms to this
condition as seen in Graph 3.1 (Distance VS Signal Strength).
Getting the total time delay of all the trials divided by 12 is the average or mean time
delay of the system along the 60 meters radius. The total time delay is divided by 12 because
there are 12 trials with five samples for each trial. This value can be assumed to be the time
delay within the said distance. However, the results of measuring the time delay has
maximum time delay of 0.05000007 second and minimum of 0.047000006 second.
54
Mean
Mean=(0.04760274+0.04960283+0.04990118+0.04700006+0.05000007+0.05100007
+0.04900007+0.0500008+0.04900008+0.05000007+0.04900007+0.047999978)/12
Mean = 0.049175592 second
The prototype has an average time delay of 0.049175592 second upon
operating the optimum distance of 60 meters. When the distance of the laptop and the
scoreboard is changing time to time, the average time delay will be closer to the mean
value.
Conclusion
The research proved the possibility of designing and building a wireless scoreboard
that is synchronized with a laptop via Zigbee. From the data gathered, it is found out that the
scoreboard will operate within the measured optimal distance with or without obstruction
with the measured maximum time delay. When the prototype gets out of the 60 meter radius
distance, the scoreboard may be found to have miscommunication and produce error in the
laptop. Based on the gathered results upon testing the scoreboard, the signal strength of the
Portable Synchronized Basketball Scoreboard is seen to be better than having obstruction.
The scoreboard is expected to display in higher position where people watching the game
cannot block its display. It is also found to be working without problem whenever there is
obstruction between the transmitter and the receiver. Like in various wireless gadgets, the
scoreboard can only communicate with themselves within the gathered data which is 60
meters. This distance is accepted due to the fact that a typical basketball courtis 50 feet wide
and 94 feet long while the scoreboard and laptop operate at a196.850 feet or 60 meters
55
distance from each other. When the prototype is operating, its averagetime delay
is0.049175592 second within the 60 meter radius.
Recommendation
The security of the transmission of data to the scoreboard is no longer covered by this
research. Other laptops with connected Zigbee transmitter can also send data to the
scoreboard. When this happens, the accuracy of the time may be affected because it can be
changed by an anonymous user. Thus, further studies on the same topic may be about
improvements on transmitting the data such as having a 1:1 connection between laptop and
scoreboard.
One potential study that may be taken is increasing the distance between the laptop
and the scoreboard by using multiple Zigbee to bridge the signal with other Zigbee.
References
Axelson, J. (1994). The Microcontroller Idea Book. 8052-Basic Microcontrollers.
Madison,Alabama: Lakeview Research
Borger, J. (December 6, 2008). "They think it's all over". The Guardian (London). Retrieved
December 24, 2008, from http://www.guardian.co.uk/football/2008/dec/06/footballbrand-globalisation-chinabasketball
Cypher D., Chevrollier N., Montavont N., & Golmie N. (2006, April). Prevailing over Wires
in Healthcare Environments: Benefits and Challenges. IEEE Communications
Magazine, Vol. 44, No. 4, pp. 56-63.
56
Heile B. (2004, June 8). Emerging Standards: Where do ZigBee/UWB fit. Retrieved
November 8, 2011, from
http://www.jzctc.com/Downloads/ZIGB/2006316131536817.pdf
Institute of Electrical and Electronics Engineers. (2003). IEEE Standard for Local and
Metropolitan Area Networks: Specifications for Low- Rate Wireless Personal Area
Networks.
Jovanov E., & Milenkovic A. (2005, September). A WBAN System for Ambulatory
Monitoring of Physical Activity and Health Status: Applications and Challenges.
IEEE Engineering inMedicine and Biology, pp. 3810-3813.
Lakas A. (2005, May). A Framework for SIP-Based Wireless Medical Application.
Vehicular Technology Conference, vol. 5, pp. 2755-2759.
Lee M.J, Jianliang Z., Young-Bae K. & Shrestha, D.M. (2006, April) Emerging standards
for wireless mesh technology. IEEE Wireless Communications Magazine, Vol. 13,
Issue 2, pp.56 – 63.
Liting, C., Wei, J., & Zhaoli, Z. (2008). Networked Wireless Meter-Reading System based
on ZigBee Technology. Control and Decision Conference, pp. 3455 - 3460
Loke L., Robles L. (2007). Self-Study Module: GUI Building in Java, p. 2.
Ondrej, S., Zdenek, B., Petr, F., & Ondrej, H., (2006, April). ZigBee Technology and Device
Design. International Conference on Networking, International Conference on
Systems and International Conference on Mobile Communications and Learning
Technologies, IEEE, pp.129-139.
57
Robinson B., Brooks P. (2009). An Initial Study of Customer-Reported GUI Defects. IEEE
International Conference on Software Testing, Verification, and Validation
Workshops, pp.267-274.
Tanel J., Taavi M., Indrek R. (2006). PIC Microcontroller learning system. Estonia.: Tallinn
University of Technology, Department of Electrical Drives and Power Electronics
Uehran, R. (2005). Wireless Scoreboard Display System. Brookings, SD, US.: Daktronics Inc.
Ze Z., & Li C. (2005, September). EasiMed: A Remote Health Care Solution. IEEE
Engineering in Medicine and Biology, pp. 2145-2148.
ZigBee Alliance. (2004, December). Document 053474r06, ZigBee Specification, v. 1.0
Zucatto, F., Biscassi, C.A., Monsignore, F., Fidelix, F., Coutinho, S., &Rocha, M.L. (2007).
ZigBee for Building Control Wireless Sensor Networks.
58
Chapter IV
CONCLUSION
The research proved the possibility of designing and building a wireless scoreboard
that is synchronized with a laptop via Zigbee. From the data gathered, it is found out that the
scoreboard will operate within the measured optimal distance with or without obstruction
with the measured maximum time delay. When the prototype gets out of the 60 meter radius
distance, the scoreboard may be found to have miscommunication and produce error in the
laptop. Based on the gathered results upon testing the scoreboard, the signal strength of the
Portable Synchronized Basketball Scoreboard is seen to be better than having obstruction.
The scoreboard is expected to display in higher position where people watching the game
cannot block its display. It is also found to be working without problem whenever there is
obstruction between the transmitter and the receiver. Like in various wireless gadgets, the
scoreboard can only communicate with themselves within the gathered data which is 60
meters. This distance is accepted due to the fact that a typical basketball court is 50 feet wide
and 94 feet long while the scoreboard and laptop operate at a 196.850 feet or 60 meters
distance from each other. When the prototype is operating, its average time delay is
0.049175592 second within the 60 meter radius.
59
Chapter V
RECOMMENDATION
The security of the transmission of data to the scoreboard is no longer covered by this
research. Other laptops with connected Zigbee transmitter can also send data to the
scoreboard. When this happens, the accuracy of the time may be affected because it can be
changed by an anonymous user. Thus, further studies on the same topic may be about
improvements on transmitting the data such as having a 1:1 connection between laptop and
scoreboard.
One potential study that may be taken is increasing the distance between the laptop
and the scoreboard by using multiple Zigbee to bridge the signal with other Zigbee.
60
REFERENCES
Axelson, J. (1994). The Microcontroller Idea Book.8052-Basic
Microcontrollers.Madison,Alabama: Lakeview Research
Borger, J. (December 6, 2008). "They think it's all over". The Guardian (London). Retrieved
December 24, 2008, from http://www.guardian.co.uk/football/2008/dec/06/footballbrand-globalisation-chinabasketball
Cypher D., Chevrollier N., Montavont N., &Golmie N. (2006, April).Prevailing over Wires
in Healthcare Environments: Benefits and Challenges.IEEE Communications
Magazine, Vol. 44, No. 4, pp. 56-63.
Heile B. (2004, June 8). Emerging Standards: Where doZigBee/UWB fit. Retrieved
November 8, 2011,
fromhttp://www.jzctc.com/Downloads/ZIGB/2006316131536817.pdf
Institute of Electrical and Electronics Engineers. (2003). IEEE Standard for Local and
Metropolitan Area Networks: Specifications for Low- Rate Wireless Personal Area
Networks.
JovanovE.,&Milenkovic A. (2005, September). A WBAN System for Ambulatory
Monitoring of Physical Activity and Health Status: Applications and Challenges.
IEEE Engineering inMedicine and Biology, pp. 3810-3813.
Lakas A. (2005, May). A Framework for SIP-Based Wireless Medical Application.Vehicular
Technology Conference, vol. 5, pp. 2755-2759.
Lee M.J, Jianliang Z., Young-Bae K. & Shrestha, D.M. (2006, April) Emerging standards
for wireless mesh technology. IEEE Wireless Communications Magazine, Vol. 13,
Issue 2, pp.56 – 63.
61
Liting, C., Wei, J., &Zhaoli, Z. (2008). Networked Wireless Meter-Reading System based on
ZigBee Technology. Control and Decision Conference, pp. 3455 - 3460
Loke L., Robles L. (2007). Self-Study Module: GUI Building in Java, p. 2.
Ondrej, S., Zdenek, B., Petr, F., &Ondrej, H., (2006, April).ZigBee Technology and Device
Design.International Conference on Networking, International Conference on
Systems and International Conference on Mobile Communications and Learning
Technologies, IEEE, pp.129-139.
Robinson B., Brooks P. (2009). An Initial Study of Customer-Reported GUI Defects.IEEE
International Conference on Software Testing, Verification, and Validation
Workshops, pp.267-274.
Tanel J., Taavi M., Indrek R. (2006). PIC Microcontroller learning system.Estonia.:Tallinn
University of Technology, Department of Electrical Drives and Power Electronics
Uehran, R. (2005). Wireless Scoreboard Display System. Brookings, SD, US.: Daktronics
Inc.
ZeZ.,& Li C. (2005, September). EasiMed: A Remote Health Care Solution. IEEE
Engineering in Medicine and Biology, pp. 2145-2148.
ZigBee Alliance.(2004, December). Document 053474r06, ZigBee Specification, v. 1.0
Zucatto, F., Biscassi, C.A., Monsignore, F., Fidelix, F., Coutinho, S., &Rocha, M.L. (2007).
ZigBee for Building Control Wireless Sensor Networks.
62
APPENDICES
Appendix A
OPERATIONS MANUAL
1. System Requirement
o Pentium 4 processor 1.6GHz or equivalent
o 512MB RAM or higher
o Microsoft Windows XP or higher
2. Installation Procedure
o Attach the Zigbee Transceiver to the laptop.
o Attach the Zigbee Receiver to the scoreboard.
o Turn on the Scoreboard.
o Run the scoreboard application on the laptop.
3. Troubleshooting
a. Scoreboard digits are all zeros
o Choose the right COM Port when starting the application
4. Error Definition
a. Check COM Port Settings – Error in com port setting.
63
Appendix B
Picture of Prototype
Figure 6.1: Full Prototype
The figure above shows the full prototype connected to a laptop computer.
64
Appendix C
PROGRAM LISTING
C# Program
frmScoreboard.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows.Forms;
namespace ScoreBoard
{
static class Program
{
/// <summary>
/// The main entry point for the application.
/// </summary>
[STAThread]
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new frmScoreboard());
}
}
}
namespace ScoreBoard
{
partial class frmScoreboard
{
/// <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>
65
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();
this.lblScoreboard = new System.Windows.Forms.Label();
this.gbScoreBoard = new System.Windows.Forms.GroupBox();
this.lblHTFouls = new System.Windows.Forms.Label();
this.lblAwayScore = new System.Windows.Forms.Label();
this.lblHomeScore = new System.Windows.Forms.Label();
this.lblAT = new System.Windows.Forms.Label();
this.lblHT = new System.Windows.Forms.Label();
this.lblAF = new System.Windows.Forms.Label();
this.lblHF = new System.Windows.Forms.Label();
this.lblATimeout = new System.Windows.Forms.Label();
this.lblATFouls = new System.Windows.Forms.Label();
this.lblHTimeout = new System.Windows.Forms.Label();
this.lblPeriodNumber = new System.Windows.Forms.Label();
this.lblPeriod = new System.Windows.Forms.Label();
this.lblSC = new System.Windows.Forms.Label();
this.lblTimerSC = new System.Windows.Forms.Label();
this.gbxTimer = new System.Windows.Forms.GroupBox();
this.lblMiliSeconds = new System.Windows.Forms.Label();
this.label1 = new System.Windows.Forms.Label();
this.lblTimerMinutes = new System.Windows.Forms.Label();
this.lblTimerSeconds = new System.Windows.Forms.Label();
this.lblColon = new System.Windows.Forms.Label();
this.lblAway = new System.Windows.Forms.Label();
this.lblHomeName = new System.Windows.Forms.Label();
this.tmrTime = new System.Windows.Forms.Timer(this.components);
this.msMenuBar = new System.Windows.Forms.MenuStrip();
this.fileToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
this.optionsToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
66
this.exitToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
this.serialPort1 = new System.IO.Ports.SerialPort(this.components);
this.groupBox1 = new System.Windows.Forms.GroupBox();
this.btnPlay = new System.Windows.Forms.Button();
this.btnChangeTime = new System.Windows.Forms.Button();
this.btnOptions = new System.Windows.Forms.Button();
this.btnResetShotClock = new System.Windows.Forms.Button();
this.gbAwayTimeout = new System.Windows.Forms.GroupBox();
this.btnAwayTimeoutSub = new System.Windows.Forms.Button();
this.btnAwayTimeoutAdd = new System.Windows.Forms.Button();
this.gbAyawFoul = new System.Windows.Forms.GroupBox();
this.btnAwayFoulSub = new System.Windows.Forms.Button();
this.btnAwayFoulAdd = new System.Windows.Forms.Button();
this.gbAwayScore = new System.Windows.Forms.GroupBox();
this.btnAwayAdd3 = new System.Windows.Forms.Button();
this.btnAwaySub1 = new System.Windows.Forms.Button();
this.btnAwayAdd2 = new System.Windows.Forms.Button();
this.btnAwayAdd1 = new System.Windows.Forms.Button();
this.gbHomeTimeout = new System.Windows.Forms.GroupBox();
this.btnHomeTimeoutSub = new System.Windows.Forms.Button();
this.btnHomeTimeoutAdd = new System.Windows.Forms.Button();
this.gbHomeFoul = new System.Windows.Forms.GroupBox();
this.btnHomeFoulSub = new System.Windows.Forms.Button();
this.btnHomeFoulAdd = new System.Windows.Forms.Button();
this.gbHomeScore = new System.Windows.Forms.GroupBox();
this.btnHomeAdd3 = new System.Windows.Forms.Button();
this.btnHomeSub1 = new System.Windows.Forms.Button();
this.btnHomeAdd2 = new System.Windows.Forms.Button();
this.btnHomeAdd1 = new System.Windows.Forms.Button();
this.gbScoreBoard.SuspendLayout();
this.gbxTimer.SuspendLayout();
this.msMenuBar.SuspendLayout();
this.groupBox1.SuspendLayout();
this.gbAwayTimeout.SuspendLayout();
this.gbAyawFoul.SuspendLayout();
this.gbAwayScore.SuspendLayout();
this.gbHomeTimeout.SuspendLayout();
this.gbHomeFoul.SuspendLayout();
this.gbHomeScore.SuspendLayout();
this.SuspendLayout();
//
// lblScoreboard
//
this.lblScoreboard.Anchor =
((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top |
System.Windows.Forms.AnchorStyles.Left)
67
| System.Windows.Forms.AnchorStyles.Right)));
this.lblScoreboard.BackColor = System.Drawing.Color.Black;
this.lblScoreboard.BorderStyle = System.Windows.Forms.BorderStyle.Fixed3D;
this.lblScoreboard.Font = new System.Drawing.Font("Microsoft Sans Serif", 48F,
System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.lblScoreboard.ForeColor = System.Drawing.Color.Red;
this.lblScoreboard.Location = new System.Drawing.Point(12, 24);
this.lblScoreboard.Name = "lblScoreboard";
this.lblScoreboard.Size = new System.Drawing.Size(984, 79);
this.lblScoreboard.TabIndex = 0;
this.lblScoreboard.Text = "PC SCOREBOARD";
this.lblScoreboard.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
//
// gbScoreBoard
//
this.gbScoreBoard.Anchor = System.Windows.Forms.AnchorStyles.None;
this.gbScoreBoard.BackgroundImageLayout =
System.Windows.Forms.ImageLayout.None;
this.gbScoreBoard.Controls.Add(this.lblHTFouls);
this.gbScoreBoard.Controls.Add(this.lblAwayScore);
this.gbScoreBoard.Controls.Add(this.lblHomeScore);
this.gbScoreBoard.Controls.Add(this.lblAT);
this.gbScoreBoard.Controls.Add(this.lblHT);
this.gbScoreBoard.Controls.Add(this.lblAF);
this.gbScoreBoard.Controls.Add(this.lblHF);
this.gbScoreBoard.Controls.Add(this.lblATimeout);
this.gbScoreBoard.Controls.Add(this.lblATFouls);
this.gbScoreBoard.Controls.Add(this.lblHTimeout);
this.gbScoreBoard.Controls.Add(this.lblPeriodNumber);
this.gbScoreBoard.Controls.Add(this.lblPeriod);
this.gbScoreBoard.Controls.Add(this.lblSC);
this.gbScoreBoard.Controls.Add(this.lblTimerSC);
this.gbScoreBoard.Controls.Add(this.gbxTimer);
this.gbScoreBoard.Controls.Add(this.lblAway);
this.gbScoreBoard.Controls.Add(this.lblHomeName);
this.gbScoreBoard.Location = new System.Drawing.Point(12, 213);
this.gbScoreBoard.Name = "gbScoreBoard";
this.gbScoreBoard.Size = new System.Drawing.Size(984, 465);
this.gbScoreBoard.TabIndex = 1;
this.gbScoreBoard.TabStop = false;
//
// lblHTFouls
//
this.lblHTFouls.Anchor = System.Windows.Forms.AnchorStyles.Left;
this.lblHTFouls.BackColor = System.Drawing.Color.Black;
this.lblHTFouls.BorderStyle = System.Windows.Forms.BorderStyle.Fixed3D;
68
this.lblHTFouls.Font = new System.Drawing.Font("Microsoft Sans Serif", 51.75F,
System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.lblHTFouls.ForeColor = System.Drawing.Color.Red;
this.lblHTFouls.Location = new System.Drawing.Point(27, 347);
this.lblHTFouls.Margin = new System.Windows.Forms.Padding(0);
this.lblHTFouls.Name = "lblHTFouls";
this.lblHTFouls.Size = new System.Drawing.Size(120, 90);
this.lblHTFouls.TabIndex = 25;
this.lblHTFouls.Text = "0";
this.lblHTFouls.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
//
// lblAwayScore
//
this.lblAwayScore.Anchor = System.Windows.Forms.AnchorStyles.Right;
this.lblAwayScore.BackColor = System.Drawing.Color.Black;
this.lblAwayScore.BorderStyle = System.Windows.Forms.BorderStyle.Fixed3D;
this.lblAwayScore.Font = new System.Drawing.Font("Microsoft Sans Serif", 72F,
System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.lblAwayScore.ForeColor = System.Drawing.Color.Red;
this.lblAwayScore.Location = new System.Drawing.Point(704, 155);
this.lblAwayScore.Margin = new System.Windows.Forms.Padding(0);
this.lblAwayScore.Name = "lblAwayScore";
this.lblAwayScore.Size = new System.Drawing.Size(250, 110);
this.lblAwayScore.TabIndex = 24;
this.lblAwayScore.Text = "0";
this.lblAwayScore.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
//
// lblHomeScore
//
this.lblHomeScore.Anchor = System.Windows.Forms.AnchorStyles.Left;
this.lblHomeScore.BackColor = System.Drawing.Color.Black;
this.lblHomeScore.BorderStyle = System.Windows.Forms.BorderStyle.Fixed3D;
this.lblHomeScore.Font = new System.Drawing.Font("Microsoft Sans Serif", 72F,
System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.lblHomeScore.ForeColor = System.Drawing.Color.Red;
this.lblHomeScore.Location = new System.Drawing.Point(28, 155);
this.lblHomeScore.Margin = new System.Windows.Forms.Padding(0);
this.lblHomeScore.Name = "lblHomeScore";
this.lblHomeScore.Size = new System.Drawing.Size(250, 110);
this.lblHomeScore.TabIndex = 23;
this.lblHomeScore.Text = "0";
this.lblHomeScore.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
//
// lblAT
//
this.lblAT.Anchor = System.Windows.Forms.AnchorStyles.Right;
69
this.lblAT.AutoSize = true;
this.lblAT.Font = new System.Drawing.Font("Microsoft Sans Serif", 18F,
System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.lblAT.ForeColor = System.Drawing.Color.White;
this.lblAT.Location = new System.Drawing.Point(831, 308);
this.lblAT.Name = "lblAT";
this.lblAT.Size = new System.Drawing.Size(123, 29);
this.lblAT.TabIndex = 19;
this.lblAT.Text = "TIMEOUT";
this.lblAT.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
//
// lblHT
//
this.lblHT.Anchor = System.Windows.Forms.AnchorStyles.Left;
this.lblHT.AutoSize = true;
this.lblHT.Font = new System.Drawing.Font("Microsoft Sans Serif", 18F,
System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.lblHT.ForeColor = System.Drawing.Color.White;
this.lblHT.Location = new System.Drawing.Point(153, 308);
this.lblHT.Name = "lblHT";
this.lblHT.Size = new System.Drawing.Size(123, 29);
this.lblHT.TabIndex = 18;
this.lblHT.Text = "TIMEOUT";
this.lblHT.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
//
// lblAF
//
this.lblAF.Anchor = System.Windows.Forms.AnchorStyles.Right;
this.lblAF.AutoSize = true;
this.lblAF.Font = new System.Drawing.Font("Microsoft Sans Serif", 18F,
System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.lblAF.ForeColor = System.Drawing.Color.White;
this.lblAF.Location = new System.Drawing.Point(716, 308);
this.lblAF.Name = "lblAF";
this.lblAF.Size = new System.Drawing.Size(93, 29);
this.lblAF.TabIndex = 17;
this.lblAF.Text = "FOULS";
this.lblAF.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
//
// lblHF
//
this.lblHF.Anchor = System.Windows.Forms.AnchorStyles.Left;
this.lblHF.AutoSize = true;
this.lblHF.Font = new System.Drawing.Font("Microsoft Sans Serif", 18F,
System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.lblHF.ForeColor = System.Drawing.Color.White;
70
this.lblHF.Location = new System.Drawing.Point(41, 308);
this.lblHF.Name = "lblHF";
this.lblHF.Size = new System.Drawing.Size(93, 29);
this.lblHF.TabIndex = 16;
this.lblHF.Text = "FOULS";
this.lblHF.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
//
// lblATimeout
//
this.lblATimeout.Anchor = System.Windows.Forms.AnchorStyles.Right;
this.lblATimeout.BackColor = System.Drawing.Color.Black;
this.lblATimeout.BorderStyle = System.Windows.Forms.BorderStyle.Fixed3D;
this.lblATimeout.Font = new System.Drawing.Font("Microsoft Sans Serif", 51.75F,
System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.lblATimeout.ForeColor = System.Drawing.Color.Red;
this.lblATimeout.Location = new System.Drawing.Point(834, 347);
this.lblATimeout.Margin = new System.Windows.Forms.Padding(0);
this.lblATimeout.Name = "lblATimeout";
this.lblATimeout.Size = new System.Drawing.Size(120, 90);
this.lblATimeout.TabIndex = 15;
this.lblATimeout.Text = "0";
this.lblATimeout.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
//
// lblATFouls
//
this.lblATFouls.Anchor = System.Windows.Forms.AnchorStyles.Right;
this.lblATFouls.BackColor = System.Drawing.Color.Black;
this.lblATFouls.BorderStyle = System.Windows.Forms.BorderStyle.Fixed3D;
this.lblATFouls.Font = new System.Drawing.Font("Microsoft Sans Serif", 51.75F,
System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.lblATFouls.ForeColor = System.Drawing.Color.Red;
this.lblATFouls.Location = new System.Drawing.Point(704, 347);
this.lblATFouls.Margin = new System.Windows.Forms.Padding(0);
this.lblATFouls.Name = "lblATFouls";
this.lblATFouls.Size = new System.Drawing.Size(120, 90);
this.lblATFouls.TabIndex = 14;
this.lblATFouls.Text = "0";
this.lblATFouls.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
//
// lblHTimeout
//
this.lblHTimeout.Anchor = System.Windows.Forms.AnchorStyles.Left;
this.lblHTimeout.BackColor = System.Drawing.Color.Black;
this.lblHTimeout.BorderStyle = System.Windows.Forms.BorderStyle.Fixed3D;
this.lblHTimeout.Font = new System.Drawing.Font("Microsoft Sans Serif", 51.75F,
System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
71
this.lblHTimeout.ForeColor = System.Drawing.Color.Red;
this.lblHTimeout.Location = new System.Drawing.Point(156, 347);
this.lblHTimeout.Margin = new System.Windows.Forms.Padding(0);
this.lblHTimeout.Name = "lblHTimeout";
this.lblHTimeout.Size = new System.Drawing.Size(120, 90);
this.lblHTimeout.TabIndex = 13;
this.lblHTimeout.Text = "0";
this.lblHTimeout.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
//
// lblPeriodNumber
//
this.lblPeriodNumber.Anchor = System.Windows.Forms.AnchorStyles.None;
this.lblPeriodNumber.BackColor = System.Drawing.Color.Black;
this.lblPeriodNumber.BorderStyle = System.Windows.Forms.BorderStyle.Fixed3D;
this.lblPeriodNumber.Font = new System.Drawing.Font("Microsoft Sans Serif", 56.25F,
System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.lblPeriodNumber.ForeColor = System.Drawing.Color.Red;
this.lblPeriodNumber.Location = new System.Drawing.Point(421, 179);
this.lblPeriodNumber.Margin = new System.Windows.Forms.Padding(0);
this.lblPeriodNumber.Name = "lblPeriodNumber";
this.lblPeriodNumber.Size = new System.Drawing.Size(140, 110);
this.lblPeriodNumber.TabIndex = 11;
this.lblPeriodNumber.Text = "00";
this.lblPeriodNumber.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
//
// lblPeriod
//
this.lblPeriod.Anchor = System.Windows.Forms.AnchorStyles.None;
this.lblPeriod.AutoSize = true;
this.lblPeriod.Font = new System.Drawing.Font("Microsoft Sans Serif", 24F,
System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.lblPeriod.ForeColor = System.Drawing.Color.White;
this.lblPeriod.Location = new System.Drawing.Point(422, 140);
this.lblPeriod.Name = "lblPeriod";
this.lblPeriod.Size = new System.Drawing.Size(137, 37);
this.lblPeriod.TabIndex = 10;
this.lblPeriod.Text = "PERIOD";
this.lblPeriod.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
//
// lblSC
//
this.lblSC.Anchor = System.Windows.Forms.AnchorStyles.Bottom;
this.lblSC.AutoSize = true;
this.lblSC.Font = new System.Drawing.Font("Microsoft Sans Serif", 24F,
System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.lblSC.ForeColor = System.Drawing.Color.White;
72
this.lblSC.Location = new System.Drawing.Point(380, 301);
this.lblSC.Name = "lblSC";
this.lblSC.Size = new System.Drawing.Size(225, 37);
this.lblSC.TabIndex = 9;
this.lblSC.Text = "SHOT CLOCK";
this.lblSC.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
//
// lblTimerSC
//
this.lblTimerSC.Anchor = System.Windows.Forms.AnchorStyles.Bottom;
this.lblTimerSC.BackColor = System.Drawing.Color.Black;
this.lblTimerSC.BorderStyle = System.Windows.Forms.BorderStyle.Fixed3D;
this.lblTimerSC.Font = new System.Drawing.Font("Microsoft Sans Serif", 56.25F,
System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.lblTimerSC.ForeColor = System.Drawing.Color.Red;
this.lblTimerSC.Location = new System.Drawing.Point(421, 343);
this.lblTimerSC.Margin = new System.Windows.Forms.Padding(0);
this.lblTimerSC.Name = "lblTimerSC";
this.lblTimerSC.Size = new System.Drawing.Size(140, 110);
this.lblTimerSC.TabIndex = 8;
this.lblTimerSC.Text = "00";
this.lblTimerSC.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
//
// gbxTimer
//
this.gbxTimer.Anchor = System.Windows.Forms.AnchorStyles.Top;
this.gbxTimer.Controls.Add(this.lblMiliSeconds);
this.gbxTimer.Controls.Add(this.label1);
this.gbxTimer.Controls.Add(this.lblTimerMinutes);
this.gbxTimer.Controls.Add(this.lblTimerSeconds);
this.gbxTimer.Controls.Add(this.lblColon);
this.gbxTimer.Font = new System.Drawing.Font("Microsoft Sans Serif", 1.5F,
System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.gbxTimer.Location = new System.Drawing.Point(307, 22);
this.gbxTimer.Name = "gbxTimer";
this.gbxTimer.Size = new System.Drawing.Size(373, 106);
this.gbxTimer.TabIndex = 5;
this.gbxTimer.TabStop = false;
//
// lblMiliSeconds
//
this.lblMiliSeconds.BackColor = System.Drawing.Color.Black;
this.lblMiliSeconds.Font = new System.Drawing.Font("Microsoft Sans Serif", 54.75F,
System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.lblMiliSeconds.ForeColor = System.Drawing.Color.Red;
this.lblMiliSeconds.Location = new System.Drawing.Point(312, 3);
73
this.lblMiliSeconds.Margin = new System.Windows.Forms.Padding(0);
this.lblMiliSeconds.Name = "lblMiliSeconds";
this.lblMiliSeconds.Size = new System.Drawing.Size(60, 100);
this.lblMiliSeconds.TabIndex = 6;
this.lblMiliSeconds.Text = "0";
this.lblMiliSeconds.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
//
// label1
//
this.label1.BackColor = System.Drawing.Color.Black;
this.label1.Font = new System.Drawing.Font("Microsoft Sans Serif", 51.75F,
System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.label1.ForeColor = System.Drawing.Color.Red;
this.label1.Location = new System.Drawing.Point(277, 3);
this.label1.Margin = new System.Windows.Forms.Padding(0);
this.label1.Name = "label1";
this.label1.Size = new System.Drawing.Size(35, 100);
this.label1.TabIndex = 5;
this.label1.Text = ".";
this.label1.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
//
// lblTimerMinutes
//
this.lblTimerMinutes.BackColor = System.Drawing.Color.Black;
this.lblTimerMinutes.Font = new System.Drawing.Font("Microsoft Sans Serif", 54.75F,
System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.lblTimerMinutes.ForeColor = System.Drawing.Color.Red;
this.lblTimerMinutes.Location = new System.Drawing.Point(2, 4);
this.lblTimerMinutes.Margin = new System.Windows.Forms.Padding(0);
this.lblTimerMinutes.Name = "lblTimerMinutes";
this.lblTimerMinutes.Size = new System.Drawing.Size(120, 100);
this.lblTimerMinutes.TabIndex = 2;
this.lblTimerMinutes.Text = "00";
this.lblTimerMinutes.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
//
// lblTimerSeconds
//
this.lblTimerSeconds.BackColor = System.Drawing.Color.Black;
this.lblTimerSeconds.Font = new System.Drawing.Font("Microsoft Sans Serif", 54.75F,
System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.lblTimerSeconds.ForeColor = System.Drawing.Color.Red;
this.lblTimerSeconds.Location = new System.Drawing.Point(157, 3);
this.lblTimerSeconds.Margin = new System.Windows.Forms.Padding(0);
this.lblTimerSeconds.Name = "lblTimerSeconds";
this.lblTimerSeconds.Size = new System.Drawing.Size(120, 100);
this.lblTimerSeconds.TabIndex = 4;
74
this.lblTimerSeconds.Text = "00";
this.lblTimerSeconds.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
//
// lblColon
//
this.lblColon.BackColor = System.Drawing.Color.Black;
this.lblColon.Font = new System.Drawing.Font("Microsoft Sans Serif", 51.75F,
System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.lblColon.ForeColor = System.Drawing.Color.Red;
this.lblColon.Location = new System.Drawing.Point(122, 4);
this.lblColon.Margin = new System.Windows.Forms.Padding(0);
this.lblColon.Name = "lblColon";
this.lblColon.Size = new System.Drawing.Size(35, 100);
this.lblColon.TabIndex = 3;
this.lblColon.Text = ":";
this.lblColon.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
//
// lblAway
//
this.lblAway.Anchor =
((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top |
System.Windows.Forms.AnchorStyles.Right)));
this.lblAway.Font = new System.Drawing.Font("Microsoft Sans Serif", 51.75F,
System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.lblAway.ForeColor = System.Drawing.Color.White;
this.lblAway.Location = new System.Drawing.Point(704, 70);
this.lblAway.Name = "lblAway";
this.lblAway.Size = new System.Drawing.Size(250, 90);
this.lblAway.TabIndex = 1;
this.lblAway.Text = "AWAY";
this.lblAway.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
//
// lblHomeName
//
this.lblHomeName.Font = new System.Drawing.Font("Microsoft Sans Serif", 51.75F,
System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.lblHomeName.ForeColor = System.Drawing.Color.White;
this.lblHomeName.Location = new System.Drawing.Point(28, 70);
this.lblHomeName.Name = "lblHomeName";
this.lblHomeName.Size = new System.Drawing.Size(250, 90);
this.lblHomeName.TabIndex = 0;
this.lblHomeName.Text = "HOME";
this.lblHomeName.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
//
// tmrTime
//
75
this.tmrTime.Tick += new System.EventHandler(this.timer1_Tick);
//
// msMenuBar
//
this.msMenuBar.BackColor = System.Drawing.SystemColors.ActiveCaption;
this.msMenuBar.Items.AddRange(new System.Windows.Forms.ToolStripItem[] {
this.fileToolStripMenuItem});
this.msMenuBar.Location = new System.Drawing.Point(0, 0);
this.msMenuBar.Name = "msMenuBar";
this.msMenuBar.Size = new System.Drawing.Size(1008, 24);
this.msMenuBar.TabIndex = 9;
//
// fileToolStripMenuItem
//
this.fileToolStripMenuItem.DropDownItems.AddRange(new
System.Windows.Forms.ToolStripItem[] {
this.optionsToolStripMenuItem,
this.exitToolStripMenuItem});
this.fileToolStripMenuItem.Name = "fileToolStripMenuItem";
this.fileToolStripMenuItem.ShortcutKeys =
((System.Windows.Forms.Keys)((System.Windows.Forms.Keys.Alt |
System.Windows.Forms.Keys.X)));
this.fileToolStripMenuItem.Size = new System.Drawing.Size(37, 20);
this.fileToolStripMenuItem.Text = "File";
//
// optionsToolStripMenuItem
//
this.optionsToolStripMenuItem.Name = "optionsToolStripMenuItem";
this.optionsToolStripMenuItem.ShortcutKeys =
((System.Windows.Forms.Keys)((System.Windows.Forms.Keys.Alt |
System.Windows.Forms.Keys.O)));
this.optionsToolStripMenuItem.Size = new System.Drawing.Size(155, 22);
this.optionsToolStripMenuItem.Text = "Options";
this.optionsToolStripMenuItem.Click += new
System.EventHandler(this.btnOptions_Click);
//
// exitToolStripMenuItem
//
this.exitToolStripMenuItem.Name = "exitToolStripMenuItem";
this.exitToolStripMenuItem.ShortcutKeys =
((System.Windows.Forms.Keys)((System.Windows.Forms.Keys.Alt |
System.Windows.Forms.Keys.X)));
this.exitToolStripMenuItem.Size = new System.Drawing.Size(155, 22);
this.exitToolStripMenuItem.Text = "Exit";
this.exitToolStripMenuItem.Click += new
System.EventHandler(this.exitToolStripMenuItem_Click);
76
//
// groupBox1
//
this.groupBox1.Anchor = System.Windows.Forms.AnchorStyles.Bottom;
this.groupBox1.Controls.Add(this.btnPlay);
this.groupBox1.Controls.Add(this.btnChangeTime);
this.groupBox1.Controls.Add(this.btnOptions);
this.groupBox1.Controls.Add(this.btnResetShotClock);
this.groupBox1.Font = new System.Drawing.Font("Microsoft Sans Serif", 12F,
System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.groupBox1.ForeColor = System.Drawing.SystemColors.Control;
this.groupBox1.Location = new System.Drawing.Point(345, 78);
this.groupBox1.Name = "groupBox1";
this.groupBox1.Size = new System.Drawing.Size(315, 141);
this.groupBox1.TabIndex = 16;
this.groupBox1.TabStop = false;
this.groupBox1.Text = "Game Control";
//
// btnPlay
//
this.btnPlay.Enabled = false;
this.btnPlay.Font = new System.Drawing.Font("Microsoft Sans Serif", 21.75F,
System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.btnPlay.ForeColor = System.Drawing.SystemColors.ControlText;
this.btnPlay.Location = new System.Drawing.Point(6, 22);
this.btnPlay.Name = "btnPlay";
this.btnPlay.Size = new System.Drawing.Size(90, 110);
this.btnPlay.TabIndex = 31;
this.btnPlay.Text = "Play";
this.btnPlay.UseVisualStyleBackColor = true;
this.btnPlay.Click += new System.EventHandler(this.btnPlay_Click);
//
// btnChangeTime
//
this.btnChangeTime.Enabled = false;
this.btnChangeTime.Font = new System.Drawing.Font("Microsoft Sans Serif", 21.75F,
System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.btnChangeTime.ForeColor = System.Drawing.SystemColors.ControlText;
this.btnChangeTime.Location = new System.Drawing.Point(102, 79);
this.btnChangeTime.Name = "btnChangeTime";
this.btnChangeTime.Size = new System.Drawing.Size(93, 52);
this.btnChangeTime.TabIndex = 30;
this.btnChangeTime.Text = "Time";
this.btnChangeTime.UseVisualStyleBackColor = true;
this.btnChangeTime.Click += new System.EventHandler(this.btnChangeTime_Click);
//
77
// btnOptions
//
this.btnOptions.Font = new System.Drawing.Font("Microsoft Sans Serif", 21.75F,
System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.btnOptions.ForeColor = System.Drawing.SystemColors.ControlText;
this.btnOptions.Location = new System.Drawing.Point(199, 79);
this.btnOptions.Name = "btnOptions";
this.btnOptions.Size = new System.Drawing.Size(110, 52);
this.btnOptions.TabIndex = 29;
this.btnOptions.Text = "Option";
this.btnOptions.UseVisualStyleBackColor = true;
this.btnOptions.Click += new System.EventHandler(this.btnOptions_Click);
//
// btnResetShotClock
//
this.btnResetShotClock.Enabled = false;
this.btnResetShotClock.Font = new System.Drawing.Font("Microsoft Sans Serif",
21.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.btnResetShotClock.ForeColor = System.Drawing.SystemColors.ControlText;
this.btnResetShotClock.Location = new System.Drawing.Point(102, 21);
this.btnResetShotClock.Name = "btnResetShotClock";
this.btnResetShotClock.Size = new System.Drawing.Size(207, 52);
this.btnResetShotClock.TabIndex = 28;
this.btnResetShotClock.Text = "Reset Clock";
this.btnResetShotClock.UseVisualStyleBackColor = true;
this.btnResetShotClock.Click += new
System.EventHandler(this.btnResetShotClock_Click);
//
// gbAwayTimeout
//
this.gbAwayTimeout.Anchor = System.Windows.Forms.AnchorStyles.Bottom;
this.gbAwayTimeout.Controls.Add(this.btnAwayTimeoutSub);
this.gbAwayTimeout.Controls.Add(this.btnAwayTimeoutAdd);
this.gbAwayTimeout.Font = new System.Drawing.Font("Microsoft Sans Serif", 12F,
System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.gbAwayTimeout.ForeColor = System.Drawing.SystemColors.Control;
this.gbAwayTimeout.Location = new System.Drawing.Point(913, 78);
this.gbAwayTimeout.Name = "gbAwayTimeout";
this.gbAwayTimeout.Size = new System.Drawing.Size(80, 141);
this.gbAwayTimeout.TabIndex = 15;
this.gbAwayTimeout.TabStop = false;
this.gbAwayTimeout.Text = "Timeout";
//
// btnAwayTimeoutSub
//
this.btnAwayTimeoutSub.Enabled = false;
78
this.btnAwayTimeoutSub.Font = new System.Drawing.Font("Microsoft Sans Serif",
21.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.btnAwayTimeoutSub.ForeColor = System.Drawing.SystemColors.ControlText;
this.btnAwayTimeoutSub.Location = new System.Drawing.Point(6, 79);
this.btnAwayTimeoutSub.Name = "btnAwayTimeoutSub";
this.btnAwayTimeoutSub.Size = new System.Drawing.Size(67, 52);
this.btnAwayTimeoutSub.TabIndex = 28;
this.btnAwayTimeoutSub.Text = "-1";
this.btnAwayTimeoutSub.UseVisualStyleBackColor = true;
this.btnAwayTimeoutSub.Click += new
System.EventHandler(this.btnAwayTimeoutSub_Click);
//
// btnAwayTimeoutAdd
//
this.btnAwayTimeoutAdd.Enabled = false;
this.btnAwayTimeoutAdd.Font = new System.Drawing.Font("Microsoft Sans Serif",
21.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.btnAwayTimeoutAdd.ForeColor = System.Drawing.SystemColors.ControlText;
this.btnAwayTimeoutAdd.Location = new System.Drawing.Point(6, 22);
this.btnAwayTimeoutAdd.Name = "btnAwayTimeoutAdd";
this.btnAwayTimeoutAdd.Size = new System.Drawing.Size(68, 52);
this.btnAwayTimeoutAdd.TabIndex = 26;
this.btnAwayTimeoutAdd.Text = "+1";
this.btnAwayTimeoutAdd.UseVisualStyleBackColor = true;
this.btnAwayTimeoutAdd.Click += new
System.EventHandler(this.btnAwayTimeoutAdd_Click);
//
// gbAyawFoul
//
this.gbAyawFoul.Anchor = System.Windows.Forms.AnchorStyles.Bottom;
this.gbAyawFoul.Controls.Add(this.btnAwayFoulSub);
this.gbAyawFoul.Controls.Add(this.btnAwayFoulAdd);
this.gbAyawFoul.Font = new System.Drawing.Font("Microsoft Sans Serif", 12F,
System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.gbAyawFoul.ForeColor = System.Drawing.SystemColors.Control;
this.gbAyawFoul.Location = new System.Drawing.Point(827, 78);
this.gbAyawFoul.Name = "gbAyawFoul";
this.gbAyawFoul.Size = new System.Drawing.Size(80, 141);
this.gbAyawFoul.TabIndex = 14;
this.gbAyawFoul.TabStop = false;
this.gbAyawFoul.Text = "Fouls";
//
// btnAwayFoulSub
//
this.btnAwayFoulSub.Enabled = false;
79
this.btnAwayFoulSub.Font = new System.Drawing.Font("Microsoft Sans Serif", 21.75F,
System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.btnAwayFoulSub.ForeColor = System.Drawing.SystemColors.ControlText;
this.btnAwayFoulSub.Location = new System.Drawing.Point(6, 79);
this.btnAwayFoulSub.Name = "btnAwayFoulSub";
this.btnAwayFoulSub.Size = new System.Drawing.Size(68, 52);
this.btnAwayFoulSub.TabIndex = 28;
this.btnAwayFoulSub.Text = "-1";
this.btnAwayFoulSub.UseVisualStyleBackColor = true;
this.btnAwayFoulSub.Click += new System.EventHandler(this.btnAwayFoulSub_Click);
//
// btnAwayFoulAdd
//
this.btnAwayFoulAdd.Enabled = false;
this.btnAwayFoulAdd.Font = new System.Drawing.Font("Microsoft Sans Serif", 21.75F,
System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.btnAwayFoulAdd.ForeColor = System.Drawing.SystemColors.ControlText;
this.btnAwayFoulAdd.Location = new System.Drawing.Point(6, 22);
this.btnAwayFoulAdd.Name = "btnAwayFoulAdd";
this.btnAwayFoulAdd.Size = new System.Drawing.Size(68, 52);
this.btnAwayFoulAdd.TabIndex = 26;
this.btnAwayFoulAdd.Text = "+1";
this.btnAwayFoulAdd.UseVisualStyleBackColor = true;
this.btnAwayFoulAdd.Click += new
System.EventHandler(this.btnAwayFoulAdd_Click);
//
// gbAwayScore
//
this.gbAwayScore.Anchor = System.Windows.Forms.AnchorStyles.Bottom;
this.gbAwayScore.Controls.Add(this.btnAwayAdd3);
this.gbAwayScore.Controls.Add(this.btnAwaySub1);
this.gbAwayScore.Controls.Add(this.btnAwayAdd2);
this.gbAwayScore.Controls.Add(this.btnAwayAdd1);
this.gbAwayScore.Font = new System.Drawing.Font("Microsoft Sans Serif", 12F,
System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.gbAwayScore.ForeColor = System.Drawing.SystemColors.Control;
this.gbAwayScore.Location = new System.Drawing.Point(666, 78);
this.gbAwayScore.Name = "gbAwayScore";
this.gbAwayScore.Size = new System.Drawing.Size(155, 141);
this.gbAwayScore.TabIndex = 13;
this.gbAwayScore.TabStop = false;
this.gbAwayScore.Text = "Away Score";
//
// btnAwayAdd3
//
this.btnAwayAdd3.Enabled = false;
80
this.btnAwayAdd3.Font = new System.Drawing.Font("Microsoft Sans Serif", 21.75F,
System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.btnAwayAdd3.ForeColor = System.Drawing.SystemColors.ControlText;
this.btnAwayAdd3.Location = new System.Drawing.Point(80, 22);
this.btnAwayAdd3.Name = "btnAwayAdd3";
this.btnAwayAdd3.Size = new System.Drawing.Size(68, 52);
this.btnAwayAdd3.TabIndex = 29;
this.btnAwayAdd3.Text = "+3";
this.btnAwayAdd3.UseVisualStyleBackColor = true;
this.btnAwayAdd3.Click += new System.EventHandler(this.btnAwayAdd3_Click);
//
// btnAwaySub1
//
this.btnAwaySub1.Enabled = false;
this.btnAwaySub1.Font = new System.Drawing.Font("Microsoft Sans Serif", 21.75F,
System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.btnAwaySub1.ForeColor = System.Drawing.SystemColors.ControlText;
this.btnAwaySub1.Location = new System.Drawing.Point(80, 79);
this.btnAwaySub1.Name = "btnAwaySub1";
this.btnAwaySub1.Size = new System.Drawing.Size(68, 52);
this.btnAwaySub1.TabIndex = 28;
this.btnAwaySub1.Text = "-1";
this.btnAwaySub1.UseVisualStyleBackColor = true;
this.btnAwaySub1.Click += new System.EventHandler(this.btnAwaySub1_Click);
//
// btnAwayAdd2
//
this.btnAwayAdd2.Enabled = false;
this.btnAwayAdd2.Font = new System.Drawing.Font("Microsoft Sans Serif", 21.75F,
System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.btnAwayAdd2.ForeColor = System.Drawing.SystemColors.ControlText;
this.btnAwayAdd2.Location = new System.Drawing.Point(6, 80);
this.btnAwayAdd2.Name = "btnAwayAdd2";
this.btnAwayAdd2.Size = new System.Drawing.Size(68, 52);
this.btnAwayAdd2.TabIndex = 27;
this.btnAwayAdd2.Text = "+2";
this.btnAwayAdd2.UseVisualStyleBackColor = true;
this.btnAwayAdd2.Click += new System.EventHandler(this.btnAwayAdd2_Click);
//
// btnAwayAdd1
//
this.btnAwayAdd1.Enabled = false;
this.btnAwayAdd1.Font = new System.Drawing.Font("Microsoft Sans Serif", 21.75F,
System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.btnAwayAdd1.ForeColor = System.Drawing.SystemColors.ControlText;
this.btnAwayAdd1.Location = new System.Drawing.Point(6, 21);
81
this.btnAwayAdd1.Name = "btnAwayAdd1";
this.btnAwayAdd1.Size = new System.Drawing.Size(68, 52);
this.btnAwayAdd1.TabIndex = 26;
this.btnAwayAdd1.Text = "+1";
this.btnAwayAdd1.UseVisualStyleBackColor = true;
this.btnAwayAdd1.Click += new System.EventHandler(this.btnAwayAdd1_Click);
//
// gbHomeTimeout
//
this.gbHomeTimeout.Anchor = System.Windows.Forms.AnchorStyles.Bottom;
this.gbHomeTimeout.Controls.Add(this.btnHomeTimeoutSub);
this.gbHomeTimeout.Controls.Add(this.btnHomeTimeoutAdd);
this.gbHomeTimeout.Font = new System.Drawing.Font("Microsoft Sans Serif", 12F,
System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.gbHomeTimeout.ForeColor = System.Drawing.SystemColors.Control;
this.gbHomeTimeout.Location = new System.Drawing.Point(98, 78);
this.gbHomeTimeout.Name = "gbHomeTimeout";
this.gbHomeTimeout.Size = new System.Drawing.Size(80, 141);
this.gbHomeTimeout.TabIndex = 12;
this.gbHomeTimeout.TabStop = false;
this.gbHomeTimeout.Text = "Timeout";
//
// btnHomeTimeoutSub
//
this.btnHomeTimeoutSub.Enabled = false;
this.btnHomeTimeoutSub.Font = new System.Drawing.Font("Microsoft Sans Serif",
21.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.btnHomeTimeoutSub.ForeColor = System.Drawing.SystemColors.ControlText;
this.btnHomeTimeoutSub.Location = new System.Drawing.Point(7, 80);
this.btnHomeTimeoutSub.Name = "btnHomeTimeoutSub";
this.btnHomeTimeoutSub.Size = new System.Drawing.Size(67, 52);
this.btnHomeTimeoutSub.TabIndex = 28;
this.btnHomeTimeoutSub.Text = "-1";
this.btnHomeTimeoutSub.UseVisualStyleBackColor = true;
this.btnHomeTimeoutSub.Click += new
System.EventHandler(this.btnHomeTimeoutSub_Click);
//
// btnHomeTimeoutAdd
//
this.btnHomeTimeoutAdd.Enabled = false;
this.btnHomeTimeoutAdd.Font = new System.Drawing.Font("Microsoft Sans Serif",
21.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.btnHomeTimeoutAdd.ForeColor = System.Drawing.SystemColors.ControlText;
this.btnHomeTimeoutAdd.Location = new System.Drawing.Point(6, 22);
this.btnHomeTimeoutAdd.Name = "btnHomeTimeoutAdd";
this.btnHomeTimeoutAdd.Size = new System.Drawing.Size(68, 52);
82
this.btnHomeTimeoutAdd.TabIndex = 26;
this.btnHomeTimeoutAdd.Text = "+1";
this.btnHomeTimeoutAdd.UseVisualStyleBackColor = true;
this.btnHomeTimeoutAdd.Click += new
System.EventHandler(this.btnHomeTimeoutAdd_Click);
//
// gbHomeFoul
//
this.gbHomeFoul.Anchor = System.Windows.Forms.AnchorStyles.Bottom;
this.gbHomeFoul.Controls.Add(this.btnHomeFoulSub);
this.gbHomeFoul.Controls.Add(this.btnHomeFoulAdd);
this.gbHomeFoul.Font = new System.Drawing.Font("Microsoft Sans Serif", 12F,
System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.gbHomeFoul.ForeColor = System.Drawing.SystemColors.Control;
this.gbHomeFoul.Location = new System.Drawing.Point(12, 78);
this.gbHomeFoul.Name = "gbHomeFoul";
this.gbHomeFoul.Size = new System.Drawing.Size(80, 141);
this.gbHomeFoul.TabIndex = 11;
this.gbHomeFoul.TabStop = false;
this.gbHomeFoul.Text = "Fouls";
//
// btnHomeFoulSub
//
this.btnHomeFoulSub.Enabled = false;
this.btnHomeFoulSub.Font = new System.Drawing.Font("Microsoft Sans Serif", 21.75F,
System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.btnHomeFoulSub.ForeColor = System.Drawing.SystemColors.ControlText;
this.btnHomeFoulSub.Location = new System.Drawing.Point(6, 80);
this.btnHomeFoulSub.Name = "btnHomeFoulSub";
this.btnHomeFoulSub.Size = new System.Drawing.Size(68, 52);
this.btnHomeFoulSub.TabIndex = 28;
this.btnHomeFoulSub.Text = "-1";
this.btnHomeFoulSub.UseVisualStyleBackColor = true;
this.btnHomeFoulSub.Click += new System.EventHandler(this.btnHomeFoulSub_Click);
//
// btnHomeFoulAdd
//
this.btnHomeFoulAdd.Enabled = false;
this.btnHomeFoulAdd.Font = new System.Drawing.Font("Microsoft Sans Serif", 21.75F,
System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.btnHomeFoulAdd.ForeColor = System.Drawing.SystemColors.ControlText;
this.btnHomeFoulAdd.Location = new System.Drawing.Point(6, 22);
this.btnHomeFoulAdd.Name = "btnHomeFoulAdd";
this.btnHomeFoulAdd.Size = new System.Drawing.Size(68, 52);
this.btnHomeFoulAdd.TabIndex = 26;
this.btnHomeFoulAdd.Text = "+1";
83
this.btnHomeFoulAdd.UseVisualStyleBackColor = true;
this.btnHomeFoulAdd.Click += new
System.EventHandler(this.btnHomeFoulAdd_Click);
//
// gbHomeScore
//
this.gbHomeScore.Anchor = System.Windows.Forms.AnchorStyles.Bottom;
this.gbHomeScore.Controls.Add(this.btnHomeAdd3);
this.gbHomeScore.Controls.Add(this.btnHomeSub1);
this.gbHomeScore.Controls.Add(this.btnHomeAdd2);
this.gbHomeScore.Controls.Add(this.btnHomeAdd1);
this.gbHomeScore.Font = new System.Drawing.Font("Microsoft Sans Serif", 12F,
System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.gbHomeScore.ForeColor = System.Drawing.SystemColors.Control;
this.gbHomeScore.Location = new System.Drawing.Point(184, 78);
this.gbHomeScore.Name = "gbHomeScore";
this.gbHomeScore.Size = new System.Drawing.Size(155, 141);
this.gbHomeScore.TabIndex = 10;
this.gbHomeScore.TabStop = false;
this.gbHomeScore.Text = "Home Score";
//
// btnHomeAdd3
//
this.btnHomeAdd3.Enabled = false;
this.btnHomeAdd3.Font = new System.Drawing.Font("Microsoft Sans Serif", 21.75F,
System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.btnHomeAdd3.ForeColor = System.Drawing.SystemColors.ControlText;
this.btnHomeAdd3.Location = new System.Drawing.Point(82, 21);
this.btnHomeAdd3.Name = "btnHomeAdd3";
this.btnHomeAdd3.Size = new System.Drawing.Size(68, 52);
this.btnHomeAdd3.TabIndex = 29;
this.btnHomeAdd3.Text = "+3";
this.btnHomeAdd3.UseVisualStyleBackColor = true;
this.btnHomeAdd3.Click += new System.EventHandler(this.btnHomeAdd3_Click);
//
// btnHomeSub1
//
this.btnHomeSub1.Enabled = false;
this.btnHomeSub1.Font = new System.Drawing.Font("Microsoft Sans Serif", 21.75F,
System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.btnHomeSub1.ForeColor = System.Drawing.SystemColors.ControlText;
this.btnHomeSub1.Location = new System.Drawing.Point(82, 79);
this.btnHomeSub1.Name = "btnHomeSub1";
this.btnHomeSub1.Size = new System.Drawing.Size(68, 52);
this.btnHomeSub1.TabIndex = 28;
this.btnHomeSub1.Text = "-1";
84
this.btnHomeSub1.UseVisualStyleBackColor = true;
this.btnHomeSub1.Click += new System.EventHandler(this.btnHomeSub1_Click);
//
// btnHomeAdd2
//
this.btnHomeAdd2.Enabled = false;
this.btnHomeAdd2.Font = new System.Drawing.Font("Microsoft Sans Serif", 21.75F,
System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.btnHomeAdd2.ForeColor = System.Drawing.SystemColors.ControlText;
this.btnHomeAdd2.Location = new System.Drawing.Point(8, 79);
this.btnHomeAdd2.Name = "btnHomeAdd2";
this.btnHomeAdd2.Size = new System.Drawing.Size(68, 52);
this.btnHomeAdd2.TabIndex = 27;
this.btnHomeAdd2.Text = "+2";
this.btnHomeAdd2.UseVisualStyleBackColor = true;
this.btnHomeAdd2.Click += new System.EventHandler(this.btnHomeAdd2_Click);
//
// btnHomeAdd1
//
this.btnHomeAdd1.Enabled = false;
this.btnHomeAdd1.Font = new System.Drawing.Font("Microsoft Sans Serif", 21.75F,
System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.btnHomeAdd1.ForeColor = System.Drawing.SystemColors.ControlText;
this.btnHomeAdd1.Location = new System.Drawing.Point(8, 21);
this.btnHomeAdd1.Name = "btnHomeAdd1";
this.btnHomeAdd1.Size = new System.Drawing.Size(68, 52);
this.btnHomeAdd1.TabIndex = 26;
this.btnHomeAdd1.Text = "+1";
this.btnHomeAdd1.UseVisualStyleBackColor = true;
this.btnHomeAdd1.Click += new System.EventHandler(this.btnHomeAdd1_Click);
//
// frmScoreboard
//
this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
this.AutoSize = true;
this.BackColor = System.Drawing.Color.Blue;
this.ClientSize = new System.Drawing.Size(1008, 730);
this.ControlBox = false;
this.Controls.Add(this.groupBox1);
this.Controls.Add(this.gbAwayTimeout);
this.Controls.Add(this.gbAyawFoul);
this.Controls.Add(this.gbAwayScore);
this.Controls.Add(this.gbHomeTimeout);
this.Controls.Add(this.gbHomeFoul);
this.Controls.Add(this.gbHomeScore);
85
this.Controls.Add(this.gbScoreBoard);
this.Controls.Add(this.lblScoreboard);
this.Controls.Add(this.msMenuBar);
this.MainMenuStrip = this.msMenuBar;
this.MaximumSize = new System.Drawing.Size(1024, 768);
this.MinimumSize = new System.Drawing.Size(1024, 766);
this.Name = "frmScoreboard";
this.Text = "SCOREBOARD";
this.Load += new System.EventHandler(this.frmScoreboard_Load);
this.gbScoreBoard.ResumeLayout(false);
this.gbScoreBoard.PerformLayout();
this.gbxTimer.ResumeLayout(false);
this.msMenuBar.ResumeLayout(false);
this.msMenuBar.PerformLayout();
this.groupBox1.ResumeLayout(false);
this.gbAwayTimeout.ResumeLayout(false);
this.gbAyawFoul.ResumeLayout(false);
this.gbAwayScore.ResumeLayout(false);
this.gbHomeTimeout.ResumeLayout(false);
this.gbHomeFoul.ResumeLayout(false);
this.gbHomeScore.ResumeLayout(false);
this.ResumeLayout(false);
this.PerformLayout();
}
#endregion
private System.Windows.Forms.Label lblScoreboard;
private System.Windows.Forms.GroupBox gbScoreBoard;
private System.Windows.Forms.Label lblAway;
private System.Windows.Forms.Label lblHomeName;
private System.Windows.Forms.Label lblPeriod;
private System.Windows.Forms.Label lblSC;
private System.Windows.Forms.GroupBox gbxTimer;
private System.Windows.Forms.Label lblColon;
private System.Windows.Forms.Label lblHF;
private System.Windows.Forms.Label lblHT;
private System.Windows.Forms.Label lblAF;
private System.Windows.Forms.Timer tmrTime;
private System.Windows.Forms.Label lblAT;
private System.Windows.Forms.Label lblHomeScore;
private System.Windows.Forms.Label lblAwayScore;
public System.Windows.Forms.Label lblTimerSC;
public System.Windows.Forms.Label lblTimerMinutes;
public System.Windows.Forms.Label lblTimerSeconds;
86
public System.Windows.Forms.Label lblATimeout;
public System.Windows.Forms.Label lblHTFouls;
private System.Windows.Forms.Label lblATFouls;
private System.Windows.Forms.Label lblHTimeout;
private System.Windows.Forms.MenuStrip msMenuBar;
private System.Windows.Forms.ToolStripMenuItem fileToolStripMenuItem;
private System.Windows.Forms.ToolStripMenuItem exitToolStripMenuItem;
private System.Windows.Forms.ToolStripMenuItem optionsToolStripMenuItem;
public System.Windows.Forms.Label lblPeriodNumber;
private System.IO.Ports.SerialPort serialPort1;
public System.Windows.Forms.Label lblMiliSeconds;
private System.Windows.Forms.Label label1;
private System.Windows.Forms.GroupBox groupBox1;
private System.Windows.Forms.Button btnChangeTime;
private System.Windows.Forms.Button btnOptions;
private System.Windows.Forms.Button btnResetShotClock;
private System.Windows.Forms.GroupBox gbAwayTimeout;
private System.Windows.Forms.Button btnAwayTimeoutSub;
private System.Windows.Forms.Button btnAwayTimeoutAdd;
private System.Windows.Forms.GroupBox gbAyawFoul;
private System.Windows.Forms.Button btnAwayFoulSub;
private System.Windows.Forms.Button btnAwayFoulAdd;
private System.Windows.Forms.GroupBox gbAwayScore;
private System.Windows.Forms.Button btnAwayAdd3;
private System.Windows.Forms.Button btnAwaySub1;
private System.Windows.Forms.Button btnAwayAdd2;
private System.Windows.Forms.Button btnAwayAdd1;
private System.Windows.Forms.GroupBox gbHomeTimeout;
private System.Windows.Forms.Button btnHomeTimeoutSub;
private System.Windows.Forms.Button btnHomeTimeoutAdd;
private System.Windows.Forms.GroupBox gbHomeFoul;
private System.Windows.Forms.Button btnHomeFoulSub;
private System.Windows.Forms.Button btnHomeFoulAdd;
private System.Windows.Forms.GroupBox gbHomeScore;
private System.Windows.Forms.Button btnHomeAdd3;
private System.Windows.Forms.Button btnHomeSub1;
private System.Windows.Forms.Button btnHomeAdd2;
private System.Windows.Forms.Button btnHomeAdd1;
private System.Windows.Forms.Button btnPlay;
}
}
87
C# Program
Delay Program
namespace Delay
{
partial class frmMain
{
/// <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();
this.gbCOMPort = new System.Windows.Forms.GroupBox();
this.cbCOMPort = new System.Windows.Forms.ComboBox();
this.btnSave = new System.Windows.Forms.Button();
this.lblCOMPort = new System.Windows.Forms.Label();
this.sp = new System.IO.Ports.SerialPort(this.components);
this.groupBox1 = new System.Windows.Forms.GroupBox();
this.btnSendBytes = new System.Windows.Forms.Button();
this.lblEndTime = new System.Windows.Forms.Label();
this.lblStartTime = new System.Windows.Forms.Label();
this.txtEndTime = new System.Windows.Forms.TextBox();
this.txtStartTime = new System.Windows.Forms.TextBox();
88
this.gbCOMPort.SuspendLayout();
this.groupBox1.SuspendLayout();
this.SuspendLayout();
//
// gbCOMPort
//
this.gbCOMPort.Controls.Add(this.cbCOMPort);
this.gbCOMPort.Controls.Add(this.btnSave);
this.gbCOMPort.Controls.Add(this.lblCOMPort);
this.gbCOMPort.Font = new System.Drawing.Font("Microsoft Sans Serif", 9.75F,
System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.gbCOMPort.Location = new System.Drawing.Point(12, 12);
this.gbCOMPort.Name = "gbCOMPort";
this.gbCOMPort.Size = new System.Drawing.Size(560, 59);
this.gbCOMPort.TabIndex = 16;
this.gbCOMPort.TabStop = false;
this.gbCOMPort.Text = "COM Port Options";
//
// cbCOMPort
//
this.cbCOMPort.DropDownStyle =
System.Windows.Forms.ComboBoxStyle.DropDownList;
this.cbCOMPort.Font = new System.Drawing.Font("Microsoft Sans Serif", 9.75F,
System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.cbCOMPort.FormattingEnabled = true;
this.cbCOMPort.Items.AddRange(new object[] {
"24",
"30"});
this.cbCOMPort.Location = new System.Drawing.Point(208, 22);
this.cbCOMPort.Name = "cbCOMPort";
this.cbCOMPort.Size = new System.Drawing.Size(240, 24);
this.cbCOMPort.TabIndex = 0;
this.cbCOMPort.SelectedIndexChanged += new
System.EventHandler(this.cbCOMPort_SelectedIndexChanged);
//
// btnSave
//
this.btnSave.Font = new System.Drawing.Font("Microsoft Sans Serif", 9.75F,
System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.btnSave.Location = new System.Drawing.Point(454, 21);
this.btnSave.Name = "btnSave";
this.btnSave.Size = new System.Drawing.Size(100, 24);
this.btnSave.TabIndex = 15;
this.btnSave.Text = "SAVE";
this.btnSave.UseVisualStyleBackColor = true;
this.btnSave.Click += new System.EventHandler(this.btnSave_Click);
89
//
// lblCOMPort
//
this.lblCOMPort.AutoSize = true;
this.lblCOMPort.Font = new System.Drawing.Font("Microsoft Sans Serif", 9.75F,
System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.lblCOMPort.Location = new System.Drawing.Point(6, 25);
this.lblCOMPort.Name = "lblCOMPort";
this.lblCOMPort.Size = new System.Drawing.Size(196, 16);
this.lblCOMPort.TabIndex = 13;
this.lblCOMPort.Text = "What COM port should be used:";
this.lblCOMPort.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
//
// sp
//
this.sp.DataReceived += new
System.IO.Ports.SerialDataReceivedEventHandler(this.sp_DataReceived);
//
// groupBox1
//
this.groupBox1.Controls.Add(this.btnSendBytes);
this.groupBox1.Controls.Add(this.lblEndTime);
this.groupBox1.Controls.Add(this.lblStartTime);
this.groupBox1.Controls.Add(this.txtEndTime);
this.groupBox1.Controls.Add(this.txtStartTime);
this.groupBox1.Font = new System.Drawing.Font("Microsoft Sans Serif", 9.75F,
System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.groupBox1.Location = new System.Drawing.Point(12, 77);
this.groupBox1.Name = "groupBox1";
this.groupBox1.Size = new System.Drawing.Size(560, 89);
this.groupBox1.TabIndex = 17;
this.groupBox1.TabStop = false;
this.groupBox1.Text = "COM Port Options";
//
// btnSendBytes
//
this.btnSendBytes.Enabled = false;
this.btnSendBytes.Font = new System.Drawing.Font("Microsoft Sans Serif", 9.75F,
System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.btnSendBytes.Location = new System.Drawing.Point(327, 19);
this.btnSendBytes.Name = "btnSendBytes";
this.btnSendBytes.Size = new System.Drawing.Size(227, 49);
this.btnSendBytes.TabIndex = 22;
this.btnSendBytes.Text = "SEND 5 BYTES TO ZIGBEE";
this.btnSendBytes.UseVisualStyleBackColor = true;
this.btnSendBytes.Click += new System.EventHandler(this.btnSendBytes_Click);
90
//
// lblEndTime
//
this.lblEndTime.AutoSize = true;
this.lblEndTime.Font = new System.Drawing.Font("Microsoft Sans Serif", 9.75F,
System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.lblEndTime.Location = new System.Drawing.Point(6, 52);
this.lblEndTime.Name = "lblEndTime";
this.lblEndTime.Size = new System.Drawing.Size(66, 16);
this.lblEndTime.TabIndex = 21;
this.lblEndTime.Text = "End Time";
this.lblEndTime.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
//
// lblStartTime
//
this.lblStartTime.AutoSize = true;
this.lblStartTime.Font = new System.Drawing.Font("Microsoft Sans Serif", 9.75F,
System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.lblStartTime.Location = new System.Drawing.Point(6, 24);
this.lblStartTime.Name = "lblStartTime";
this.lblStartTime.Size = new System.Drawing.Size(69, 16);
this.lblStartTime.TabIndex = 20;
this.lblStartTime.Text = "Start Time";
this.lblStartTime.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
//
// txtEndTime
//
this.txtEndTime.Location = new System.Drawing.Point(81, 49);
this.txtEndTime.Name = "txtEndTime";
this.txtEndTime.ReadOnly = true;
this.txtEndTime.Size = new System.Drawing.Size(240, 22);
this.txtEndTime.TabIndex = 19;
//
// txtStartTime
//
this.txtStartTime.Location = new System.Drawing.Point(81, 21);
this.txtStartTime.Name = "txtStartTime";
this.txtStartTime.ReadOnly = true;
this.txtStartTime.Size = new System.Drawing.Size(240, 22);
this.txtStartTime.TabIndex = 18;
//
// frmMain
//
this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
this.ClientSize = new System.Drawing.Size(584, 179);
91
this.Controls.Add(this.groupBox1);
this.Controls.Add(this.gbCOMPort);
this.Name = "frmMain";
this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen;
this.Text = "Delay";
this.FormClosing += new
System.Windows.Forms.FormClosingEventHandler(this.frmMain_FormClosing);
this.Load += new System.EventHandler(this.frmMain_Load);
this.gbCOMPort.ResumeLayout(false);
this.gbCOMPort.PerformLayout();
this.groupBox1.ResumeLayout(false);
this.groupBox1.PerformLayout();
this.ResumeLayout(false);
}
#endregion
private System.Windows.Forms.GroupBox gbCOMPort;
public System.Windows.Forms.ComboBox cbCOMPort;
private System.Windows.Forms.Button btnSave;
private System.Windows.Forms.Label lblCOMPort;
private System.IO.Ports.SerialPort sp;
private System.Windows.Forms.GroupBox groupBox1;
private System.Windows.Forms.Button btnSendBytes;
private System.Windows.Forms.Label lblEndTime;
private System.Windows.Forms.Label lblStartTime;
private System.Windows.Forms.TextBox txtEndTime;
private System.Windows.Forms.TextBox txtStartTime;
}
}
92
Appendix D
Datasheet
93
94
95
96
97
98
99
100
101
102
103
104
105
106
Xbee Shield
Overview
The Xbee shield allows an Arduino board to communicate wirelessly using Zigbee. It is based on
the Xbee module from MaxStream. The module can communicate up to 100 feet indoors or 300
feet outdoors (with line-of-sight). It can be used as a serial/usb replacement or you can put it into
a command mode and configure it for a variety of broadcast and mesh networking options. The
shields breaks out each of the Xbee's pins to a through-hole solder pad. It also provides female
pin headers for use of digital pins 2 to 7 and the analog inputs, which are covered by the shield
(digital pins 8 to 13 are not obstructed by the shield, so you can use the headers on the board
itself).
The Xbee shield was created in collaboration with Libelium, who developed it for use in their
SquidBee motes (used for creating sensor networks).
107
Schematic
XbeeShieldSchematic.pdf (Eagle schematics and board layouts available from the Libelium
SquidBee wiki download page.)
Jumper Settings
The Xbee shield has two jumpers (the small removable plastic sleeves that each fit onto two of
the three pins labelled Xbee/USB). These determine how the Xbee's serial communication
connects to the serial communication between the microcontroller (ATmega8 or ATmega168)
and FTDI USB-to-serial chip on the Arduino board.
With the jumpers in the Xbee position (i.e. on the two pins towards the interior of the board), the
DOUT pin of the Xbee module is connected to the RX pin of the microcontroller; and DIN is
connected to TX. Note that the RX and TX pins of the microcontroller are still connected to the
TX and RX pins (respectively) of the FTDI chip - data sent from the microcontroller will be
transmitted to the computer via USB as well as being sent wirelessly by the Xbee module. The
microcontroller, however, will only be able to receive data from the Xbee module, not over USB
from the computer.
With the jumpers in the USB position (i.e. on the two pins nearest the edge of the board), the
DOUT pin the Xbee module is connected to the RX pin of the FTDI chip, and DIN on the Xbee
module is connected to the TX pin of the FTDI chip. This means that the Xbee module can
communicate directly with the computer - however, this only works if the microcontroller has
108
been removed from the Arduino board. If the microcontroller is left in the Arduino board, it will
be able to talk to the computer normally via USB, but neither the computer nor the
microcontroller will be able to talk to the Xbee module.
Networking
The Arduino XBee shield can be used with different XBee modules. The instructions below are
for the XBee 802.15.4 modules (sometimes called "Series 1" to distinguish them from the Series
2 modules, although "Series 1" doesn't appear in the official name or product description).
Addressing
There are multiple parameters that need to be configured correctly for two modules to talk to
each other (although with the default settings, all modules should be able to talk to each other).
They need to be on the same network, as set by the ID parameter (see "Configuration" below for
more details on the parameters). The modules need to be on the same channel, as set by the CH
parameter. Finally, a module's destination address (DH and DL parameters) determine which
modules on its network and channel will receive the data it transmits. This can happen in a few
ways:
•
If a module's DH is 0 and its DL is less than 0xFFFF (i.e. 16 bits), data transmitted by
that module will be received by any module whose 16-bit address MY parameter equals
DL.
109
•
If DH is 0 and DL equals 0xFFFF, the module's transmissions will be received by all
modules.
•
If DH is non-zero or DL is greater than 0xFFFF, the transmission will only be received
by the module whose serial number equals the transmitting module's destination address
(i.e. whose SH equals the transmitting module's DH and whose SL equals its DL).
Again, this address matching will only happen between modules on the same network and
channel. If two modules are on different networks or channels, they can't communicate
regardless of their addresses.
Configuration
Here are some of the more useful parameters for configuring your Xbee module. For step-bystep instructions on reading and writing them, see the guide to the Xbee shield. Make sure to
prepend AT to the parameter name when sending a command to the module (e.g. to read the ID
parameter, you should send the command ATID).
Command
Description
Valid Values
Default Value
ID
The network ID of the Xbee module.
0 - 0xFFFF
3332
CH
The channel of the Xbee module.
0x0B - 0x1A
0X0C
110
SH and
The serial number of the Xbee module (SH
0 - 0xFFFFFFFF different for each
SL
gives the high 32 bits, SL the low 32 bits).
(for both SH and module
Read-only.
SL)
MY
The 16-bit address of the module.
0 - 0xFFFF
DH and
The destination address for wireless
DL
BD
0
0 - 0xFFFFFFFF 0 (for both DH
communication (DH is the high 32 bits, DL the (for both DH and and DL)
low 32).
DL)
The baud rate used for serial communication
0 (1200 bps)
with the Arduino board or computer.
1 (2400 bps)
3 (9600 baud)
2 (4800 bps)
3 (9600 bps)
4 (19200 bps)
5 (38400 bps)
6 (57600 bps)
7 (115200 bps)
Note: although the valid and default values in the table above are written with a prefix of "0x" (to
indicate that they are hexadecimal numbers), the module will not include the "0x" when
reporting the value of a parameter, and you should omit it when setting values.
111
Here are a couple more useful commands for configuring the Xbee module (you'll need to
prepend AT to these too).
Command
Description
RE
Restore factory default settings (note that like
parameter changes, this is not permanent
unless followed by the WR command).
WR
Write newly configured parameter values to
non-volatile (long-term) storage. Otherwise,
they will only last until the module loses
power.
CN
Exit command mode now. (If you don't send
any commands to the module for a few
seconds, command mode will timeout and exit
even without a CN command.)
112