Upload
api-19979847
View
267
Download
0
Embed Size (px)
Citation preview
Project Report On
OPTICAL SENSOR BASED
DYNAMIC SIGNATURE
RECOGNITION AND
VERIFICATION TOOL
Siddharth Shashidharan
Himanshu Madan
Sneha Rangdal
Sanika Mokashi
2
COLLEGE OF ENGINEERING, PUNE
Shivajinagar, Pune - 411 005
(Formerly Government College of Engineering, Pune)
CERTIFICATE
This is to certify that SIDDHARTH SHASHIDHARAN of
T.Y.B.Tech, E&TC, has satisfactorily completed the Electronic Design
Mini-Project –
OPTICAL SENSOR BASED DYNAMIC SIGNATURE
RECOGNITION AND VERIFICATION TOOL
for the year 2006-2007.
S. P. Mahajan
Dept. of E&TC
College of Engineering, Pune
3
ACKNOWLEDGEMENT
We take this opportunity to express our heartfelt gratitude to the professors
and staff of College of Engineering, Pune for their constant inspiration and
guidance. We would, in particular, like to thank Professors Mahajan,
Bartakke and Vyas for their support and are deeply indebted to them for
their technical advice derived from the vast pool of their experience and
knowledge.
We could not have conceived of undertaking a project on such a massive
scale without the encouragement and blessings of our professors and
parents.
4
INDEX
SECTION 1: Introduction 05
SECTION 2: Block Diagram 08
SECTION 3: Hardware 10
CH.1: Mouse And PS/2 Standard 11
CH.2: Microcontroller 28
CH.3: EEPROM 34
CH.4: Serial Port Communication 38
CH.5: Interfacing 41
SECTION 4: PCB Design 42
CH.1: PCB Design Rules 44
CH.2: PCB Software 47
CH.3: PCB Layout 49
SECTION 5: Mechanical Design 52
SECTION 6: Software 61
CH.1: Software Description 62
CH.2: Graphics User Interface 63
CH.3: Dynamic Signature Verification 67
CH.4: Character Recognition 93
CH.5: Design Aid 97
SECTION 7: Costing 102
SECTION 8: Conclusion 104
SECTION 9: References 106
SECTION 10: Appendix 109
5
SECTION 1
INTRODUCTION
6
INTRODUCTION
It is said that necessity is the mother of all invention. History has taught us that
what epitomises an advanced civilization is its ability to harness the power of the
human mind. Built on the foundations of reason and logic, creativity and re-
invention, we have come to understand this in modern terms as the technology
that fuels the global economy.
As engineers especially, we are burdened with the responsibility of constantly
improving upon, and finding alternate solutions to, old problems that are
inevitably tossed up by both science and nature.
Real vision however lies in recognising and capitalising on opportunities that hide
deep only in the mysterious realms of our imagination. To turn old adages on
their heads, an invention can sometimes precede its worth in society.
Global markets today are flooded with products and solutions for nearly every
conceivable need of man. How then, does one hope to stand out and carve a
niche of this expanse in his favour? The answer again is innovation. And this is
the very philosophy that motivates us to go in search of a vision to produce
something original whilst always considering the commercial aspect of the
design.
Customers today demand reassurances from banks and other financial
institutions when it comes to monetary transactions and account control. A
simple pin code may not be a very ideal form of security in ATM machines.
Official documents may be forged and reproduced thereby causing losses in
millions of dollars for corporations and individuals every year. The day is not far
when we will see the implementation of Biometric systems as an additional
security entity.
7
But as is often the problem with many emerging technologies, the high prohibitive
initial costs act as a deterrent in the way of inculcation of these biometric systems
into mainstream marketplaces.
This however, is exactly where an opportunity lies, that maybe be capitalised
upon via cost-leadership solutions.
Take the case of signature verification and identification systems - The present
market scenario shows a prevalence of touchpad systems that are extremely
expensive for one, and rather bulky for another. Additionally, it is rather difficult
to use these systems where a very high degree of security is needed.
Through the course of the next few chapters, you will see how we have tried to
bridge this gap between cost and technology, while focusing on security,
functionality and mobility.
In order to overcome the inherent problems faced by the touchpad-based
systems, we had to conceive of a solution that worked on a completely different
principle, and we found our answer in something that has become an integral
part of our lives – the computer mouse.
An optical mouse sensor circuit is extremely cheap and highly reliable, not to
mention its’ easy of availability.
We shall also attempt to demonstrate its versatility through other applications that
can perform character recognition and act as a design aid for civil and
mechanical engineers.
This report shall first explain the system of working of the common optical mouse
and the PS/2 standards on which it can be operated. It then proceeds to
demonstrate it’s interfacing with a microcontroller and other aspect of hardware
design. The software part follows, and the project concludes with the basic
costing and scope for the project as a whole, while also attempting to illustrate
additional possibilities in the future.
8
SECTION 2
BLOCK DIAGRAM
9
M
I
C
R
O
C
O
N
T
R
O
L
L
E
R
AT24c512
AT24c512
AT24c512
BLOCK DIAGRAM
The block diagram here gives an overall idea of the system used.
An optical mouse sensor circuit is interfaced with a microcontroller that reads the
data co-ordinates in the form of X and Y position bytes, sent to it by the mouse
and uses externally connected EEPROMs to store the data offline. In order to
process this data, we interface the microcontroller with the computer by means of
the RS – 232 serial port.
The computer reads the data from the microcontroller and processes on the
MATLAB software platform. Let us now turn out attention to the various hardware
components and their interfacing in the following few sections.
Mouse
D
S
P
ADNS2610
TTL to MAX 232
RS -232
10
SECTION 3
HARDWARE
11
CHAPTER 1: MOUSE AND PS/2 STANDARD
1.1 A Brief History Of The Optical Mouse:
An optical mouse uses a light-emitting diode and photodiodes to detect
movement relative to the underlying surface, rather than moving some of its parts
— as in a mechanical mouse.
Early optical mice, circa 1980, came in two different varieties:
1. Some, such as those invented by Steve Kirsch of Mouse Systems
Corporation, used an infrared LED and a four-quadrant infrared sensor to detect
grid lines printed with infrared absorbing ink on a special metallic surface.
Predictive algorithms in the CPU of the mouse calculated the speed and direction
over the grid.
2. Others, invented by Richard F. Lyon and sold by Xerox, used a 16-pixel
visible-light image sensor with integrated motion detection on the same chip and
tracked the motion of light dots in a dark field of a printed paper or similar mouse
pad.
These two mouse types had very different behaviors, as the Kirsch mouse used
an x-y coordinate system embedded in the pad, and would not work correctly
when rotated, while the Lyon mouse used the x-y coordinate system of the
mouse body, as mechanical mice do.
As computing power grew cheaper, it became possible to embed more powerful
special-purpose image-processing chips in the mouse itself. This advance
enabled the mouse to detect relative motion on a wide variety of surfaces,
translating the movement of the mouse into the movement of the pointer and
eliminating the need for a special mouse-pad. This advance paved the way for
widespread adoption of optical mice.
Developed by Agilent Technologies and introduced to the world in late 1999, the
Modern surface-independent optical mice use a small, red light-emitting diode
(LED) that bounces light off the surface onto a complimentary metal-oxide
semiconductor (CMOS) sensor to take successive pictures of the surface. For
12
example, the Agilent Technologies ADNS-2610 optical mouse sensor processes
1512 frames per second: each frame is a rectangular array of 18×18 pixels, and
each pixel can sense 64 different levels of gray. The CMOS sensor sends each
image to a digital signal processor (DSP) for analysis. The DSP, operating at 18
MIPS (million instructions per second), is able to detect patterns in the images
and by comparing with the previous Images able to translate the pattern into
movement on the two axes using optical flow estimation algorithm. This
estimated differential motion co-ordinates are then send to the computer. The
computer moves the cursor on the screen based on the coordinates received
from the mouse. This happens hundreds of times each second, making the
cursor appear to move very smoothly.
1.2 Use Of The Optical Mouse Sensor Circuit:
The optical mouse has been around for quite a few years now during which time
it has been perfected to be reliable and highly accurate. Mass production of
these devices also makes them incredibly cheap. Power requirements for the
proper working of the mouse circuitry are also sufficiently low. The sensor circuits
inside the mouse casing and rather compact. These facets of such a readily
available device help facilitate a cheap, though efficient alternative to expensive
touchpad systems. In addition, the ease with which we can interface the circuitry
with virtually any microcontroller, speaks volumes of the versatility of the system.
In essence, the mouse’s DSP chip provides the basic X,Y co-ordinates (two
bytes of data) in addition to a status byte that helps further simply its interfacing.
In order to understand this interfacing, we shall now go into the details of the
PS/2 standards that are used by the mouse to communicate with its master
device.
13
1.3 PS/2 – The Standard:
The Personal System/2 or PS/2 was IBM's second generation of personal
computers. The PS/2 line, released to the public in 1987, was created by IBM in
an attempt to recapture control of the PC market by introducing an advanced
proprietary architecture. Although IBM's considerable market presence ensured
the PS/2 would sell in relatively large numbers, the PS/2 architecture ultimately
failed in its bid to return control of the PC market to IBM. Due to the higher costs
of the closed architecture, customers preferred competing PCs that extended the
existing PC architecture instead of abandoning it for something new. However,
many of the PS/2s innovations, such as the 1,440 kB 3.5-inch floppy disk format,
72-pin SIMM, the PS/2 keyboard and mouse ports, and the VGA video standard,
went on to become standards in the broader PC market. A PS/2 port is an
electronic receptacle or plug found on computers. It accepts a PS/2 cable with a
mini-DIN connector, and is most often used to plug in a keyboard or mouse.
The PS/2 port is female while the mini-DIN cable is male. The connector is small
with a diameter of about 1/3 inch (9.5mm). It features a metal sleeve that is
notched to ensure proper alignment when inserting it into the PS/2 port. This
protects the circular pins inside the DIN connector from becoming bent.
The PS/2 port was initially a large DIN plug used for a keyboard, while the mouse
was commonly plugged into a serial port. However, as modems also used serial
Pin 1 +DATA Data
Pin 2 Not Connected Not Connected*
Pin 3 GND Ground
Pin 4 Vcc +5 V DC at 100 mA
Pin 5 +CLK Clock
Pin 6 Not Connected Not Connected**
* On some laptops mouse data for splitter cable.
** On some laptops mouse clock for splitter cable.
14
ports, configuration conflicts between mouse and modem became a common
problem as each tried to share the same IRQ or memory address. The PS/2
mouse was a popular solution because it worked independent of the serial port
and avoided configuration problems. Eventually, computers incorporated two
built-in PS/2 ports, one for the keyboard and one for a mouse.
1.4 PS/2 – Connections:
The Data and Clock lines are both open-collector with pull-up resistors to Vcc.
An ‘open-collector’ interface has two possible states: low or high impedance. In
the ‘low’ state, a transistor pulls the line to ground level. In the ‘high impedance’
state, the interface acts as an open circuit and doesn't drive the line low or high.
Furthermore, a ‘pull-up’ resistor is connected between the bus and Vcc so the
bus is pulled high if none of the devices on the bus are actively pulling it low.
The exact value of this resistor isn't too important (1~10 kOhms); larger
resistances result in less power consumption and smaller resistances result in a
faster rise time. A general open-collector interface is shown below:
15
1.5 PS/2 – The Protocol:
The PS/2 is a bidirectional synchronous serial protocol. The bus is ‘idle’ when
both lines are high (open-collector). This is the only state where the device is
allowed to begin transmitting data. The host has ultimate control over the bus
and may inhibit communication at any time by pulling the Clock line low.
The device always generates the clock signal. If the host wants to send data, it
must first inhibit communication from the device by pulling Clock low. The host
then pulls Data low and releases Clock. This is the ‘Request-to-Send’ state and
signals the device to start generating clock pulses.
Summary of Bus States
Data = high, Clock = high: Idle state.
Data = high, Clock = low: Communication Inhibited.
Data = low, Clock = high: Host Request-to-Send.
All data is transmitted one byte at a time and each byte is sent in a frame
consisting of 11-12 bits. These bits are:
! 1 start bit. This is always 0.
! 8 data bits, least significant bit first.
! 1 parity bit (odd parity).
! 1 stop bit. This is always 1.
! 1 acknowledge bit (host-to-device communication only)
The parity bit is set (1) if there is an even number of 1's in the data bits and reset
(0) if there is an odd number of 1's in the data bits. The number of 1's in the data
bits plus the parity bit always add up to an odd number (odd parity). This is used
for error detection. The device must check this bit and if incorrect it should
respond as if it had received an invalid command.
Data sent from the device to the host is read on the falling edge of the clock
signal; data sent from the host to the device is read on the rising edge. The clock
frequency must be in the range 10 - 16.7 kHz. This means clock must be high for
30 - 50 microseconds and low for 30 - 50 microseconds.
16
1.6 PS/2 – Communication:
Device-to-Host
The Data and Clock lines are both open collector. A resistor is connected
between each line and +5V, so the idle state of the bus is high. When the device
wants to send information, it first checks the Clock line to make sure it's at a high
logic level. If it's not, the host is inhibiting communication and the device must
buffer any to-be-sent data until the host releases Clock. The Clock line must be
continuously high for at least 50 microseconds before the device can begin to
transmit its data.
Device to host communication uses a serial protocol with 11-bit frames. These
bits are:
• 1 start bit. This is always 0.
• 8 data bits, least significant bit first.
• 1 parity bit (odd parity).
• 1 stop bit. This is always 1.
The device writes a bit on the Data line when Clock is high, and it is read by the
host when Clock is low.
Figure 2: Device-to-host communication. The Data line changes state when
Clock is high and that data is valid when Clock is low.
Figure 3: Scan code for the ‘Q’ key (15h) being sent from a keyboard to the
computer. Channel A is the Clock signal; channel B is the Data signal.
17
The clock frequency is 10-16.7 kHz. The time from the rising edge of a clock
pulse to a Data transition must be at least 5 microseconds. The time from a data
transition to the falling edge of a clock pulse must be at least 5 microseconds and
no greater than 25 microseconds.
The host may inhibit communication at any time by pulling the Clock line low for
at least 100 microseconds. If a transmission is inhibited before the 11th clock
pulse, the device must abort the current transmission and prepare to retransmit
the current chunk of data when host releases Clock. A chunk of data could be a
make code, break code, device ID, mouse movement packet, etc. For example, if
a keyboard is interrupted while sending the second byte of a two-byte break
code, it will need to retransmit both bytes of that break code, not just the one that
was interrupted.
If the host pulls clock low before the first high-to-low clock transition, or after the
falling edge of the last clock pulse, the keyboard/mouse does not need to
retransmit any data. However, if new data is created that needs to be
transmitted, it will have to be buffered until the host releases Clock. Keyboards
18
have a 16-byte buffer for this purpose. If more than 16 bytes worth of keystrokes
occur, further keystrokes will be ignored until there's room in the buffer. Mice only
store the most current movement packet for transmission.
Host-to-Device
The packet is sent a little differently in host-to-device communication. Firstly, the
PS/2 device always generates the clock signal. If the host wants to send data, it
must first put the Clock and Data lines in a ‘Request-to-send’ state as follows:
• Inhibit communication by pulling Clock low for at least 100 microseconds.
• Apply ‘Request-to-send’ by pulling Data low, then release Clock.
The device should check for this state at intervals not to exceed 10 milliseconds.
When the device detects this state, it will begin generating Clock signals and
clock in eight data bits and one stop bit. The host changes the Data line only
when the Clock line is low, and data is read by the device when Clock is high.
This is opposite of what occurs in device-to-host communication.
After the stop bit is received, the device will acknowledge the received byte by
bringing the Data line low and generating one last clock pulse. If the host does
not release the Data line after the 11th clock pulse, the device will continue to
generate clock pulses until the Data line is released (the device will then
generate an error).
The host may abort transmission at time before the 11th clock pulse
(acknowledge bit) by holding Clock low for at least 100 microseconds.
To make this process a little easier to understand, here are the steps the host
must follow to send data to a PS/2 device:
1) Bring the Clock line low for at least 100 microseconds.
2) Bring the Data line low.
3) Release the Clock line.
4) Wait for the device to bring the Clock line low.
5) Set/reset the Data line to send the first data bit
6) Wait for the device to bring Clock high.
7) Wait for the device to bring Clock low.
8) Repeat steps 5-7 for the other seven data bits and the parity bit.
19
9) Release the Data line.
10) Wait for the device to bring Data low.
11) Wait for the device to bring Clock low.
12) Wait for the device to release Data and Clock.
Figure 3 shows this graphically and Figure 4 separates the timing to show which
signals are generated by the host, and which are generated by the PS/2 device.
Notice the change in timing for the ‘ack’ bit - The data transition occurs when the
Clock line is high (rather than when it is low as is the case for the other 11 bits).
Figure 3: Host-to-Device Communication
Figure 4: Detailed host-to-device communication
Referring to Figure 4, there are two time quantities the host looks for.
(a) is the time it takes the device to begin generating clock pulses after the host
initially takes the Clock line low, which must be no greater than 15 ms.
(b) is the time it takes for the packet to be sent, which must be no greater than
2ms. If either of these time limits is not met, the host should generate an error.
20
Immediately after the ‘ack’ is received, the host may bring the Clock line low to
inhibit communication while it processes data. If the command sent by the host
requires a response, that response must be received no later than 20 ms after
the host releases the Clock line. If this does not happen, the host generates an
error.
1.7 PS/2 Mouse Protocol :
The standard PS/2 mouse interface supports the following inputs: X (right/left)
movement, Y (up/down) movement, left button, middle button, and right button.
The mouse reads these inputs at a regular frequency and updates various
counters and flags to reflect movement and button states.
The standard mouse has two counters that keep track of movement: the X-
movement counter and the Y-movement counter. These are 9-bit 2's complement
values and each has an associated overflow flag. Their contents, along with the
state of the three mouse buttons, are sent to the host in the form of a 3-byte
movement data packet. The movement counters represent the amount of
movement that has occurred since the last movement data packet was sent to
the host.
When the mouse reads its inputs, it records the current state of its buttons and
checks for movement. If movement has occurred it increments (for +X or +Y
movement) or decrements (for -X or -Y movement) its X and/or Y movement
counters. If either of the counters has overflowed, it sets the appropriate overflow
flag.
The parameter that determines the amount by which the movement counters are
incremented/decremented is the resolution. The default resolution is 4
counts/mm and the host may change that value using the ‘Set Resolution’ (0xE8)
command.
There is a parameter that does not affect the movement counters, but does affect
the reported value of these counters. This parameter is scaling. By default, the
21
mouse uses 1:1 scaling, which has no effect on the reported mouse movement.
However, the host may select 2:1 scaling by sending the ‘Set Scaling 2:1’ (0xE7)
command. If 2:1 scaling is enabled, the mouse will apply the following algorithm
to the counters before sending their contents to the host:
Movement Counter Reported Movement
0 0
1 1
2 1
3 3
4 6
5 9
N > 5 2 * N
Data Packet Movement
The standard PS/2 mouse sends movement/button information to the host using
the following 3-byte packet:
Byte 1
Bit 7 Bit 6 Bit 5 Bit 4 Bit 3 Bit 2 Bit 1 Bit 0
Y overflow X overflow Y sign bit X sign bit Always 1 Middle Btn Right Btn Left Btn
Byte 2 X Movement
Byte 3 Y Movement
The movement counters are 9-bit 2's complement integers, where the most
significant bit appears as a sign bit in Byte 1 of the movement data packet. These
counters are updated when the mouse reads its input and finds movement has
occurred. Their value is the amount of movement that has occurred since the last
movement data packet was sent to the host (i.e. after a packet is sent to the host,
the movement counters are reset). The range of values that can be expressed by
the movement counters is -255 to +255. If this range is exceeded, the
appropriate overflow bit is set.
22
The movement counters are reset whenever a movement data packet is
successfully sent to the host. They are also reset after the mouse receives any
command from the host other than the ‘Resend’ (0xFE) command.
Modes of Operation:
Data reporting is handled according to the mode in which the mouse is operating.
There are four standard modes of operation:
• Reset - The mouse enters Reset mode at power-up or after receiving the
’Reset’ (0xFF) command.
• Stream - This is the default mode (after Reset finishes executing) and is
the mode in which most software uses the mouse. If the host has
previously set the mouse to Remote mode, it may re-enter Stream mode
by sending the ‘Set Stream Mode’ (0xEA) command to the mouse.
• Remote - In this mode the mouse reads its inputs and updates its
counters/flags at the current sample rate, but it does not automatically
issue data packets when movement has occurred. Instead, the host must
poll the mouse using the ‘Read Data’ command. Upon receiving this
command the mouse will send a single movement data packet and reset
its movement counters.
• Wrap - This mode isn't particularly useful except for testing the connection
between the mouse and its host. Wrap mode may be entered by sending
the ‘Set Wrap Mode’ (0xEE) command to the mouse. To exit Wrap mode,
the host must issue the ‘Reset’ (0xFF) command or ‘Reset Wrap Mode’
(0xEC) command. If the ‘Reset’ (0xFF) command is received, the mouse
will enter Reset mode. If the ‘Reset Wrap Mode’ (0xEC) command is
received, the mouse will enter the mode it was in prior to Wrap Mode.
For our purpose, we shall be using the mouse in remote mode.
23
Command Set:
The following are the set of commands accepted by the standard PS/2 mouse:
! FFh (Reset) - The mouse responds to this command with ‘acknowledge’
(FAh) then enters Reset Mode.
! FEh (Resend) - The host sends this command whenever it receives
invalid data from the mouse. The mouse responds by resending the last
packet it sent to the host. If the mouse responds to the ‘Resend’
command with another invalid packet, the host may either issue another
‘Resend’ command, issue an ‘Error’ command, cycle the mouse's power
supply to reset the mouse, or it may inhibit communication (by bringing the
Clock line low). The action taken depends on the host.
! F6h (Set Defaults) - The mouse responds with ‘acknowledge’ (FAh) then
loads the following values: Sampling rate = 100, Resolution = 4
counts/mm, Scaling = 1:1, Disable Data Reporting. The mouse then
resets its movement counters and enters stream mode.
! F5h (Disable Data Reporting) - The mouse responds with ‘acknowledge’
(FAh) then disables data reporting and resets its movement counters.
This only effects data reporting in Stream mode and does not disable
sampling. Disabled stream mode functions the same as remote mode.
! F4h (Enable Data Reporting) - The mouse responds with ‘acknowledge’
(FAh) then enables data reporting and resets its movement counters. This
command may be issued while the mouse is in Remote Mode (or Stream
mode), but it will only effect data reporting in Stream mode.
• F3h (Set Sample Rate) - The mouse responds with ‘acknowledge’ (FAh)
then reads one more byte from the host. The mouse saves this byte as
the new sample rate. After receiving the sample rate, the mouse again
24
responds with ‘acknowledge’ (0xFA) and resets its movement counters.
Valid sample rates are 10, 20, 40, 60, 80, 100, and 200 samples/sec.
! F2h (Get Device ID) - The mouse responds with ‘acknowledge’ (FAh)
followed by its device ID (00h for the standard PS/2 mouse). The mouse
should also reset its movement counters.
! F0h (Set Remote Mode) - The mouse responds with ‘acknowledge’ (FAh)
then resets its movement counters and enters remote mode.
! EEh (Set Wrap Mode) - The mouse responds with ‘acknowledge’ (FAh)
then resets its movement counters and enters wrap mode.
! ECh (Reset Wrap Mode) - The mouse responds with ‘acknowledge’ (FAh)
then resets its movement counters and enters the mode it was in prior to
wrap mode (Stream Mode or Remote Mode).
! EBh (Read Data) - The mouse responds with acknowledge (FAh) then
sends a movement data packet. This is the only way to read data in
Remote Mode. After the data packets has been successfully sent, it
resets its movement counters.
! EAh (Set Stream Mode) - The mouse responds with ‘acknowledge’ then
resets its movement counters and enters steram mode.
! E9h (Status Request) - The mouse responds with ‘acknowledge’, then
sends the following 3-byte status packet (then resets its movement
counters).
Byte 1
Bit 7 Bit 6 Bit 5 Bit 4 Bit 3 Bit 2 Bit 1 Bit 0
Always 0 Mode Enable Scaling Always 0 Left Btn Middle Btn Right Btn
Byte 2 Resolution
Byte 3 Sample Rate
Right, Middle, Left Btn = 1 if button pressed; 0 if button is not pressed.
25
Scaling = 1 if scaling is 2:1; 0 if scaling is 1:1. (See commands E7h and E6h)
Enable = 1 if data reporting is enabled; 0 if data reporting is disabled. (See
commands F5h and F4h)
Mode = 1 if Remote Mode is enabled; 0 if Stream mode is enabled. (See
commands F0h and EAh)
• E8h (Set Resolution) - The mouse responds with acknowledge (FAh) then
reads one byte from the host and again responds with acknowledge (FAh)
then resets its movement counters. The byte read from the host
determines the resolution as follows:
Byte Read from Host Resolution
0x00 1 count/mm
0x01 2 count/mm
0x02 4 count/mm
0x03 8 count/mm
! E7h (Set Scaling 2:1) - The mouse responds with acknowledge (FAh) then
enables 2:1 scaling (discussed earlier in this document).
! E6h (Set Scaling 1:1) - The mouse responds with acknowledge (FAh) then
enables 1:1 scaling (discussed earlier in this document).
The only commands the standard PS/2 mouse will send to the host are the
‘Resend’ (FEh) and ‘Error’ (FCh). They both work the same as they do as host-
to-device commands.
26
Initialisation:
The following is the communication between a computer (running Win98SE) and
the mouse when it boots up with a standard PS/2 mouse attached. It is fairly
typical of how a PS/2 mouse is initialised and if you want to emulate a PS/2
mouse it must (at minimum) be able to support the following sequence of
commands:
Power-on Reset:
Mouse: AA Self-test passed
Mouse: 00 Mouse ID
Host: FF Reset command
Mouse: FA Acknowledge
Mouse: AA Self-test passed
Mouse: 00 Mouse ID
Host: FF Reset command
Mouse: FA Acknowledge
Mouse: AA Self-test passed
Mouse: 00 Mouse ID
Host: FF Reset command
Mouse: FA Acknowledge
Mouse: AA Self-test passed
Mouse: 00 Mouse ID
Host: F3 Set Sample Rate : Attempt to Enter Microsoft
Mouse: FA Acknowledge : Scrolling Mouse mode
Host: C8 decimal 200 :
Mouse: FA Acknowledge :
Host: F3 Set Sample Rate :
Mouse: FA Acknowledge :
Host: 64 decimal 100 :
Mouse: FA Acknowledge :
Host: F3 Set Sample Rate :
Mouse: FA Acknowledge :
Host: 50 decimal 80 :
Mouse: FA Acknowledge :
Host: F2 Read Device Type :
Mouse: FA Acknowledge :
27
Mouse: 00 Mouse ID : Response 03
Host: F3 Set Sample Rate : if Microsoft scrolling mouse
Mouse: FA Acknowledge
Host: 0A decimal 10
Mouse: FA Acknowledge
Host: F2 Read Device Type
Mouse: FA Acknowledge
Mouse: 00 Mouse ID
Host: E8 Set resolution
Mouse: FA Acknowledge
Host: 03 8 Counts/mm
Mouse: FA Acknowledge
Host: E6 Set Scaling 1:1
Mouse: FA Acknowledge
Host: F3 Set Sample Rate
Mouse: FA Acknowledge
Host: 28 decimal 40
Mouse: FA Acknowledge
Host: F4 Enable
Mouse: FA Acknowledge
Initialization complete...
Note that this is similar sequence of commands that need to be passed on to the
mouse in our project as well. There is the option of selecting our own sample rate
and scaling factor.
28
CHAPTER 2: MICROCONTROLLER
We have chosen to use the ATTINY2313 Microcontroller for interfacing with the
mouse, the external EEPROM and the computer. It has the following features
which not only satisfies, but is virtually optimised for our requirements:
! Utilises the AVR RISC architecture – 120 instructions, most of which are
single clock cycle executable. This ensures quick execution speeds.
! 2 kilobytes of In-System Self Programmable Flash provides adequate
program memory space.
! 128 Bytes of In-System Programmable internal EEPROM and another
128 Bytes of Internal SRAM. For offline data storage therefore, we need
to interface the microcontroller with external EEPROMs, so as to make
the whole unit truly mobile.
! USI – Universal Serial Interface enabled which allows for TWI – Two Wire
Interface (or I2C) communication. This makes it possible to connect three
external EEPROMs in parallel to just two wires, saving hardware and
physical space.
! Full Dulpex USART allows communication between the device and the
computer via a RS-232 serial port.
! In-System Programmable via SPI port making it easy to test, debug and
update programs.
! 20 pin PDIP package with 18 programmable port pins making it compact.
! Speed grade of 4.5 – 5.5 V, when operated with a crystal of 20Mhz.
29
Pin Description
VCC Digital supply voltage.
GND Ground.
Port A
(PA2…PA0) Port A is a 3-bit bi-directional I/O port with internal pull-up
resistors (selected for each bit). The Port A output buffers
have symmetrical drive characteristics with both high sink
and source capability. As inputs, Port A pins that are
externally pulled low will source current if the pull-up
resistors are activated. The Port A pins are tri-stated when a
reset condition becomes active, even if the clock is not
running.
Port B
(PB7...PB0) Port B is an 8-bit bi-directional I/O port with internal pull-up
resistors (selected for each bit). The Port B output buffers
have symmetrical drive characteristics with both high sink
and source capability. As inputs, Port B pins that are
30
externally pulled low will source current if the pull-up
resistors are activated. The Port B pins are tri-stated when a
reset condition becomes active, even if the clock is not
running.
Port D
(PD6...PD0) Port D is a 7-bit bi-directional I/O port with internal pull-up
resistors (selected for each bit). The Port D output buffers
have symmetrical drive characteristics with both high sink
and source capability. As inputs, Port D pins that are
externally pulled low will source current if the pull-up
resistors are activated. The Port D pins are tri-stated when a
reset condition becomes active, even if the clock is not
running.
RESET Reset input. A low level on this pin for longer than the
minimum pulse length will generate a reset, even if the clock
is not running. Shorter pulses are not guaranteed to
generate a reset. The Reset Input is an alternate function for
PA2 and dW.
XTAL1 Input to the inverting Oscillator amplifier and input to the
internal clock operating circuit. XTAL1 is an alternate
function for PA0.
XTAL2 Output from the inverting Oscillator amplifier. XTAL2 is an
alternate function for PA1.
Refer to datasheet for alternate port and pin functions.
31
I2C
I2C is an acronym for Inter Integrated Circuit bus. I2C is a 2-wire serial
interface standard defined by Philips Semiconductor in the early 1980's. Its
purpose was to provide an easy way to connect a CPU to peripheral chips in
a TV-set. The BUS physically consists of 2 active wires and a ground
connection. The active wires, SDA and SCL, are both bidirectional. Where
SDA is the Serial DAta line and SCL is the Serial CLock line.
The key advantage of this interface is that only two lines (clock and data) are
required for full duplexed communication between multiple devices. The
interface typically runs at a fairly low speed (100 kHz to 400 kHz). With I2C,
each IC on the bus has a unique address. Chips can act as a receiver and/or
transmitter depending on its functionality.
Bi-directional communication is facilitated through the use of wire and
connection (the lines are either active-low or passive high). The I2C Bus
protocol also allows collision detection, clock synchronisation and hand-
shaking for multi-master systems. The clock is always generated by the
master, but the slave may hold it low to generate a wait state. In most
systems the microcontroller is the master and the external peripheral devices
are slaves.
The maximum number of devices connected to the I2C bus is dictated by the
maximum allowable capacitance on the lines, 400 pF, and the protocol's
addressing limit of 16k; typical device capacitance is 10 pF. The I2C protocol
has 127 addresses available.
32
To begin communication, the bus master (typically a microcontroller) places
the address of the device with which it intends to communicate (the slave) on
the bus. All ICs monitor the bus to determine if the master device is sending
their address. Only the device with the correct address communicates with
the master.
The I2C master is generally implemented with special I2C controller
(sometimes integrated to microcontroller) or sometimes using a
microcontroller and some software running on it. Both approaches are
possible in typical one master I2C system. The multi-master system is not
generally implemented with microcontroller software because it is extremely
difficult to meet all the I2C Bus timing specifications using software. For a true
slave or multi-master system, some interface hardware is necessary (like
START & STOP bit detection). Each slave on the bus is identified by a unique
address. In Standard mode, 7-bit addressing is used.
Hence, using this I2C protocol, we have interfaced the ATINY2313
Microcontroller with three AT24c512 external EEPROMs connected in
parallel.
This connection ensures that we have one EEPROM each to store the X and
Y position co-ordinates, and one for storing the mouse status byte.
This parallel connection also ensures that time is not wasted in the internal
writing process of one EEPROM IC as we are writing into a single IC only
once in every pass of polling the mouse.
Such a parallel connection also enables us to optimise the mouse to give the
highest sampling rate and the finest resolution. This large amount of position
data bytes means better overall accuracy.
Now that the data can be stored in large quantities, what remains is to be able
to transfer this data to a computer for processing. In order to make this a
convenient procedure for the end user, we have made use of the USART
facility to send data serially via the RS-232 serial port.
33
USART
The Universal Synchronous and Asynchronous serial Receiver and
Transmitter. (USART) is a highly flexible serial communication device. The
main features are:
• Full Duplex Operation (Independent Serial Receive and Transmit
Registers)
• Asynchronous or Synchronous Operation
• Master or Slave Clocked Synchronous Operation
• High Resolution Baud Rate Generator
• Supports Serial Frames with 5, 6, 7, 8, or 9 Data Bits and 1 or 2 Stop Bits
• Odd or Even Parity Generation and Parity Check Supported by Hardware
• Data OverRun Detection
• Framing Error Detection
• Noise Filtering Includes False Start Bit Detection and Digital Low Pass
Filter
• Three Separate Interrupts on TX Complete, TX Data Register Empty and
RX Complete
• Multi-processor Communication Mode
• Double Speed Asynchronous Communication Mode
We use the USART for serial communication with the computer. We have carried
out this transmission at a baud rate of 2400, with 2 stop bits and no parity bits.
The data packet size is 8 bits long. This setting ensures reliable data transfer
with small error probabilities.
34
CHAPTER 3: EEPROM
For the externally connected EEPROM, we have selected Atmel Corporation’s
AT24C512 Two Wire Serial EEPROM. Some of the features of this IC are:
• Low-voltage and Standard-voltage Operation 2.7 (VCC = 2.7V to 5.5V),
1.8 (VCC = 1.8V to 3.6V)
• Bidirectional Data Transfer Protocol using Two-wire Serial Interface
• Internally Organized 65,536 x 8 bits of data i.e. 64kB of memory
• Schmitt Triggers, Filtered Inputs for Noise Suppression
• 1 MHz (5V) Compatibility
• Write Protect Pin for Hardware and Software Data Protection
• 128-byte Page Write Mode (Partial Page Writes Allowed)
• Self-timed Write Cycle (5 ms Max.)
• High Reliability with endurance of 100,000 Write Cycles and Data
Retention of 40 Years
• 8-lead PDIP, allowing for easy component placement.
The AT24C512 provides 524,288 bits of serial electrically erasable and
programmable read only memory (EEPROM) organized as 65,536 words of 8
bits each. The device’s cascadable feature allows up to four devices to share a
common two-wire bus. The device is optimized for use in many industrial and
commercial applications where low-power and low-voltage operation are
essential. The 512K is internally organized as 512 pages of 128-bytes each.
Random word addressing requires a 16-bit data word address.
Pin Description
SERIAL CLOCK (SCL): The SCL input is used to positive edge clock data into
each EEPROM device and negative edge clock data
out of each device.
35
SERIAL DATA (SDA): The SDA pin is bidirectional for serial data transfer.
This pin is open-drain driven and may be wire-ORed
with any number of other open-drain or open collector
devices.
DEVICE/ADDRESSES
(A1, A0): The A1 and A0 pins are device address inputs that
are hardwired or left not connected for hardware
compatibility with other AT24Cxx devices. When the
pins are hardwired, as many as four 512K devices
may be addressed on a single bus system. If the pins
are left floating, the A1 and A0 pins will be internally
pulled down to GND.
WRITE PROTECT (WP): The write protect input, when connected to GND,
allows normal write operations. When WP is
connected high to VCC, all write operations to the
memory are inhibited. If the pin is left floating, the WP
pin will be internally pulled down to GND Switching
WP to VCC prior to a write operation creates a
software write protect function.
36
Device Addressing
The 512K EEPROM requires an 8-bit device address word following a start
condition to enable the chip for a read or write operation (see Figure 7 on
page 10). The device address word consists of a mandatory “1”, “0” sequence
for the first five most significant bits as shown. This is common to all two-wire
EEPROM devices. The 512K uses the two device address bits A1, A0 to
allow as many as four devices on the same bus. These bits must compare to
their corresponding hardwired input pins.
The A1 and A0 pins use an internal circuit that biases them to a logic low
condition if the pins are allowed to float. The eighth bit of the device address
is the read/write operation select bit. A read operation is initiated if this bit is
high and a write operation is initiated if this bit is low. Upon a compare of the
device address, the EEPROM will output a “0”. If a compare is not made, the
device will return to a standby state.
Write Operations
BYTE WRITE: A write operation requires two 8-bit data word addresses
following the device address word and acknowledgment. Upon receipt of this
address, the EEPROM will again respond with a “0” and then clock in the first
8-bit data word. Following receipt of the 8-bit data word, the EEPROM will
output a “0”. The addressing device, such as a microcontroller, then must
terminate the write sequence with a stop condition. At this time the EEPROM
enters an internally-timed write cycle, tWR, to the nonvolatile memory. All
inputs are disabled during this write cycle and the EEPROM will not respond
until the write is complete
PAGE WRITE: The 512K EEPROM is capable of 128-byte page writes.
A page write is initiated the same way as a byte write, but the microcontroller
does not send a stop condition after the first data word is clocked in. Instead,
after the EEPROM acknowledges receipt of the first data word, the
microcontroller can transmit up to 127 more data words. The EEPROM will
respond with a “0” after each data word received. The microcontroller must
37
terminate the page write sequence with a stop condition. The data word
address lower 7 bits are internally incremented following the receipt of each
data word. The higher data word address bits are not incremented, retaining
the memory page row location. When the word address, internally generated,
reaches the page boundary, the following byte is placed at the beginning of
the same page. If more than 128 data words are transmitted to the EEPROM,
the data word address will “roll over” and previous data will be overwritten.
The address roll over during write is from the last byte of the current page to
the first byte of the same page.
ACKNOWLEDGE POLLING: Once the internally-timed write cycle has started
and the EEPROM inputs are disabled, acknowledge polling can be initiated.
This involves sending a start condition followed by the device address word.
The Read/Write bit is representative of the operation desired. Only if the
internal write cycle has completed will the EEPROM respond with a “0”,
allowing the read or write sequence to continue.
Read Operations
Read operations are initiated the same way as write operations with the
exception that the Read/Write select bit in the device address word is set to
“1”. There are three read operations: current address read, random address
read and sequential read:
CURRENT ADDRESS READ: The internal data word address counter
maintains the last address accessed during the last read or write operation,
incremented by “1”. This address stays valid between operations as long as
the chip power is maintained. The address roll over during read is from the
last byte of the last memory page, to the first byte of the first page.
Once the device address with the Read/Write select bit set to “1” is clocked in
and acknowledged by the EEPROM, the current address data word is serially
clocked out. The microcontroller does not respond with an input “0” but does
generate a following stop condition.
38
RANDOM READ: A random read requires a “dummy” byte write sequence to
load in the data word address. Once the device address word and data word
address are clocked in and acknowledged by the EEPROM, the
microcontroller must generate another start condition. The microcontroller
now initiates a current address read by sending a device address with the
Read/Write select bit high. The EEPROM acknowledges the device address
and serially clocks out the data word. The microcontroller does not respond
with a “0” but does generate a following stop condition.
SEQUENTIAL READ: Sequential reads are initiated by either a current
address read or a random address read. After the microcontroller receives a
data word, it responds with an acknowledgement. As long as the EEPROM
receives an acknowledgement, it will continue to increment the data word
address and serially clock out sequential data words. When the memory
address limit is reached, the data word address will roll over and the
sequential read will continue. The sequential read operation is terminated
when the microcontroller does not respond with a “0” but does generate a
following stop condition.
For waveforms to illustrate the same, please refer to the datasheet.
We are using the EEPROM to store upto 64 kB of data on each EEPROM.
Thus, we may store upto 65,536 X,Y position co-ordinates and status bytes.
This translates to virtually 13 minutes of continuous movement of the mouse,
assuming around 83 readings taken every second by the mouse sensor
circuit.
This provides us with sufficient space for signatures and possible future
expansions.
39
CHAPTER 4: SERIAL COMMUNICATION
Communication as defined in the RS232 standard is an asynchronous serial
communication method. The word serial means that the information is sent one
bit at a time. Asynchronous tells us that the information is not sent in predefined
time slots. Data transfer can start at any given time and it is the task of the
receiver to detect when a message starts and ends.
We chose to sue a readily available 9 pin serial cable which has the following
pins:
Transmitted Data (TD): One of two separate data signals, this signal is
generated by the DTE and received by the DCE.
Received Data (RD): The second of two separate data signals, this signals is
generated by the DCE and received by the DTE.
Request to Send (RTS): When the host system (DTE) is ready to transmit data
to the peripheral system (DCE), RTS is turned ON. In simplex and duplex
systems, this condition maintains the DCE in receive mode. In half-duplex
systems, this condition maintains the DCE in receive mode and disables transmit
mode. The OFF condition maintains the DCE in transmit mode. After RTS is
asserted, the DCE must assert CTS before communication can commence.
Clear to Send (CTS): CTS is used along with RTS to provide handshaking
between the DTE and the DCE. After the DCE sees an asserted RTS, it turns
CTS ON when it is ready to begin communication.
Data Set Ready (DSR): This signal is turned on by the DCE to indicate that it is
connected to the telecommunications line.
40
Data Carrier Detect (DCD): This signal is turned ON when the DCE is receiving
a signal from a remote DCE, which meets its suitable signal criteria. This signal
remains ON as long as a suitable carrier signal can be detected.
Data Terminal Ready (DTR): DTR indicates the readiness of the DTE. This
signal is turned ON by the DTE when it is ready to transmit or receive data from
the DCE. DTR must be ON before the DCE can assert DSR.
Ring Indicator (RI): RI, when asserted, indicates that a ringing signal is being
received on the communications channel.
We use a MAX-232 IC to interface the TTL mouse-microcontroller circuit with the
serial port over which we
communicate.
Shown alongside is the
basic connections needed
for the MAX-232 IC.
Please refer to datasheet for
proper connection diagrams.
The circuit diagrams shows
that it is rather convenient to
select pin numbers 11
through 14 for serial
communication. This can be
seen in the circuit diagram.
41
CHAPTER 5: INTERFACING
The circuit diagram shown below shows the interfacing of the various
components of the circuit.
42
SECTION 4
PCB DESIGN
43
Design Description:
In this section we shall cover the PCB or Printed Circuit Board design. The
fundamental challenge we encountered practically was to minimize the space
required for mounting the entire circuit as shown previously.
The solution to this problem was to design four PCBs instead of just the one that
can fit compactly into a box, thereby making the whole module very mobile.
Displayed in the following pages are the PCB layouts. These individual PCBs are
connected to one another with the help of right-angled connectors, thus in
essence, making up four sides of a cube.
In order to ensure the accuracy of the mouse sensor, we have retained the
plastic base from the mouse and designed the base PCB to fit exactly on top of
it.
On one of the sides, we have placed the microprocessor and its crystal, providing
an interrupt and a selection mode. We have also ensured that the microcontroller
is re-programmable by providing connectors (SPI).
On the side facing this microcontroller side, we have mounted the DSP as well as
the three EEPROMs, some optional mouse buttons and the indicator LED.
The connector side PCB connects these two sides together through tracks, in
addition to providing structural stability.
The software used for our purpose is EagleDraw, a popular and free design tool.
The following chapters illustrate the guidelines while designing the PCB followed
by a brief insight into the EagleDraw software. This section is then summed up
by the PCB layout we have chosen to implement.
44
CHAPTER 1: PCB DESIGN RULES
A number of rules are to be followed while designing PCBs. The following
chapter gives us an idea of a few design rules which ought to be kept in mind
while designing a PCB layout.
Board Size
PCB manufacturers have a maximum size board they can handle. Typically this
is also their panel size. The PCB panel size is also important when mass
producing boards. In this situation, one would want to fit as many boards as
possible on a panel with as little wasted board space as possible (in order to
reduce costs). Normal board spacing for routing (how boards are separated on a
panel) is 0.3", plus there is typically a 1.0" to 2.0" border on the board for
handling it during processing.
Board thickness may also be specified. A standard thickness and type of board is
.062" FR4. Other typical board thicknesses are .010", .020", .031", and .092".
Trace Width and Spacing
The chemical and photographic processes used to produce a PCB put
requirements on the minimum width of trace and the minimum spacing between
traces. If a trace is made smaller than this minimum width there is some chance
it will open (no connection) when manufactured. If two traces are closer together
than the minimum spacing, there is some chance they will short when
manufactured. These parameters are usually specified as "x/y rules", where x is
the minimum trace width and y is the minimum trace spacing. For example, "8/10
rules" would indicate 8 mil minimum trace width and 10 mil minimum trace
spacing. These rules (especially spacing) apply to any metal on the PCB,
including pad to track spacing and line widths for strings on the PCB.
Typical modern process rules are 8/8 rules with values as small as 2/2 rules
being available (for a significant premium). Keep in mind that the board must be
45
soldered and a trace within 8 mils (8/8 rules) of a pad is easier to short than one
with greater spacing when hand soldered. For hand soldering 10/10 rules are
much easier to solder (if the design density can allow spacing this large).
Pad Sizes
The biggest issues with pad size are solderability and manufacturability.
Manufacturability is concerned with whether or not the pad will be broken when
the hold is drilled in it. This is mainly a function of the accuracy of the PCB
manufacturer's drilling. If a drill hole is slightly off center the pad may be broken
at one edge possibly leading to an open in the circuit. A standard requirement for
pad sizes is a 5 mil annulus. This means there must be .005" all around the hole
(i.e. a 28 mil hole would require a 38 mil pad). Something a little larger than this
(maybe 10 mils) is recommended for solderability.
Hole Sizes
Most PCB manufacturers have a wide selection of drill (hole) sizes available.
Some charge per drill size used, others offer a standard set of drill sizes for no
charge and then charge for any non-standard drill sizes.
Standard Drill Sizes for Circuits:
Drill Number Hole Size Finished Hole Size
70 .028" .025"
65 .035" .032"
58 .042" .039"
55 .052" .049"
53 .0595" .056"
44 .086" .083"
1/8" .125" .122"
24 .152" .149"
46
Hole Density
Hole density is purely a cost issue. The more holes there are on a board, the
more wear and tear manufacturing will put on the equipment (and thus the more
the board will cost). Most PCB manufacturers have a maximum hole density and
boards with greater density are charged more.
47
CHAPTER 2: PCB SOFTWARE
Eagle Draw Software:
General
• maximum drawing area 64 x 64 inches
• resolution 1/10,000 mm (0.1 microns)
• mm or inch grid
• up to 255 layers, user definable colors
• command (script) files
• C-like User Language for data export and import and the realization
of self-defined commands
• easy library editing
• composition of self-defined libraries by Drag&Drop
• simple generation of new package variants from other libraries by
Drag&Drop
• free rotation of package variants (0.1-degree steps)
• library browser and convenient component search function
• technology support (e. g. 74L00, 74LS00..)
• output of manufacturing data on plotter, photo plotter and drilling
machine or as a graphic data format
• print via the operating systems’ printer devices
• user definable, free programmable User Language for generating
data for mounting machines, in-circuit tester and milling machines
• Drag&Drop in the Control Panel
• Automatic backup function
Layout Editor
• full SMD support
• support of blind and buried vias
• rotation of elements in arbitrary angles (0.1-degree steps)
48
• texts can be placed in any orientation
• dynamic calculation of signal lines while routing the layout
• tracks can be layed out with rounded corners in any radius
• mitering to smooth wire joints
• Design Rule Check for board layouts
• copper pouring
• support of different package variants
Schematic Module
• up to 99 sheets per schematic
• simple copying of parts
• online Forward&Back Annotation between schematic and board
• automatic board generation
• automatic generation of supply signals (for IC’s)
• Electrical Rule Check (checks logic in the schematic and the consistency
of schematic and layout)
Autorouter Module
• fully integrated into basic program
• uses the set of Design Rules user defines for the layout
• swap between manual and automatic routing at any time
• ripup & retry algorithm
• user-definable strategy (based on cost factors)
• routing grid down to 0.8 mil (0.02 mm)
• no placement restrictions
• up to 16 signal layers (with user definable preferred directions)
• up to 14 supply layers
• full support of blind and buried VIAs
• recognizes signal classes that define special settings for wire with
and minimum distances
49
CHAPTER 3: PCB LAYOUT
The design employs four separate PCBs connected together by means of
perpendicular connectors. Shown below are the four PCBs:
Microcontroller side PCB
Component side layout
Solder side PCB
Solder side layout
Component side PCB
Component Layout
50
Base PCB
Connecting Side PCB
Solder side
Solder side
Component Layout
Component Layout
51
DSP Side PCB
Solder side layoutComponent side Layout
Component side layout Solder side layout
Component Layout
52
SECTION 6
MECHANICAL ASSEMBLY
53
MECHANICAL ASSEMBLY
Acrylic sheets are thin, transparent and sturdy all at once. They can be cut into
desired shapes and joined together at perpendicular angles. The images of the
module as displayed below show how the user is able to write with a pen, while
the mouse sensor at the base of the unit takes X,Y position co-ordinates. The
pen is held fast to the module by aesthetically cut pieces of acrylic that form an
extension from the main body of the module itself. Buttons on the pen are infact
the left and middle buttons of the mouse, and are used to provide additional
functionality to the device.
Provisions have been made for programming the microcontroller inside the
module, as well as wired supply and serial transmission connections. The LED is
used to demonstrate the state of numerous tasks and as a visual indicator
enabling the device to be used in myriad ways.
54
Note the two push buttons placed on the sides of the pen. They are used to
differentiate between segmensts in the design aid mode.
One can also see the 20 pin microcontroller IC inside.
The connections for these push buttons are routed through the upper surface of
the console. The LED that’s visible on the pen-side is used as an indicator.
55
The processor side of the console shows the fault red fault switch. This is used to
select the mode of operation. Once selected by making appropriate settings on
the fault switch, we can feed the setting into the microcontroller by pressing the
reset button shown above the fault switch. This generates an interrupt to the
controller.
The fault switch can therefore be used to operate the console in 16 possible
modes. For an understanding of the modes of oeration we have employed, look
up the software section of this report.
The blue on-off button enables the user to disable certain pull-up resistors and
re-program the microcontroller, via the 6-pin connectors as shown on the left
side.
56
Front profile showing the mouse sensor at the base and the red LED used for
position detection. Note the optimal utilisation of space inside the console.
The top view with wires for the pen buttons. As they are stuck on the surface,
they allow for interference free writing.
57
The indicator LED on the DSP side is used to serve as a visual guide to the user.
It blinks several tiems before readings are taken and turns off once the readings
are done so as to give the user and idea of the time formats. It also glows when
the microcontroller is serially read, so as to inform the user that the whole unit is
busy at the moment.
Showsn here also are the power wires that are thin multi-strand wires shich do
not abstruct the free motion of the hand.
58
Profile views.
59
This unit is attached with a serial cable on one end that goes to a computer, and
the console at the other end.
It serves two purposes actually. When the slide switch as shown is kept on the
left side, it activates the MAX-232 circuit and thus serial transmission of the data
to the computer is achieved.
The components on the right side are used as a serial programmer, should users
need to edit or change their their microcontroller program.
60
Hardware Operation
! On reset, the device initialises i2c communication. Thus, power on reset
will start the process of obtaining readings.
! It then initialises the mouse sensor circuit and resetsit to enable readings
to be taken.
! The read pointer, which is a pointer ine the microcontroller software, is set
to the default value. This read pointer gives the number of X, Y
coordinates to be taken.
! Indicator LED blinks thrice and readings are recorded.
! The mouse sensor is polled and data is requested.
! In response, the mouse DSP sends Status, Y-coordiante and X-coordinate
bytes.
! As soon as the byte is received, it is written into the EEPROM before the
next byte is read.
! After the readings are over, the indicator LED turns off.
! Whenever the interrupt push button is pressed, the i2c and mouse are
reintialised and the read count is set according to mode of operation
selected by the fault switch and the data is recorded again.
Fault switch position with corresponding mode of operation and ‘read’ count
value:
! 0001 Design Aid Read = 0x800
! 0010 Character Recognition Read = 0x50
! 0100 Signature Recognition Read = 0x150
! 1000 Serial Read
61
SECTION 6
SOFTWARE
62
CHAPTER 1: SOFTWARE DESCRIPTION
In order to demonstrate the full range of functionalities possible with this module,
we have developed software, on the MATLAB platform selected as it can handle
large arrays and process it effectively. MATLAB was the intuitive choice for an
application like signature verification since it supports the varied statistical and
signal processing needs of our application. Development of a Graphical User
Interface (GUI) is also very convenient on MATLAB. We have included the
following three functionalities:
Signature Verification And Identification:
In this mode, the user may make prototypes of his signature and store it in
the database. Additionally, the user can get a signature identified as
belonging to a particular entity in the database, or he/she may chose to
have his/her own signature verified by matching with the prototype
template stored in the database. This system holds great promise in the
high-risk financial world of today.
Character Recognition:
Users can employ the use of character recognition software to digitize
data, as we plunge headfirst into a digital domain. Demonstrated in this
project is the ability to recognize all the numbers and letters of the
alphabet from ‘a’ through ‘f’. Covering the constituents of the hexadecimal
number system, it is representative of the numerous possibilities that can
be availed of in written text to digital text conversion.
Design Aid:
This function is especially useful in civil and mechanical engineering and
architecture. Designers may avail of a wide range of expandable
functionalities that can help in drawing precise lines and curves, useful in
construction plans or machine drawings.
63
CHAPTER 2: GRAPHICAL USER INTERFACE
Introduction:
The graphical user interface for the first page is as shown below. It allows the
user to select the application depending on his need. It has the following
buttons:
! Signature Verification: This button enables the user to use the
application for signature identification and verification. It has a callback
function which closes the current GUI, and opens the one for signature
verification.
! Character Recognition: This button allows the user to use the
application for character and digit recognition. It closes the current GUI
and opens the one used for character recognition.
! Design Aid: This button closes the current GUI and opens the one for
design aid. The user can access a variety of useful features like
plotting the figure in different styles and colours, making point to point
plots, arcs, etc
! Exit: This button verifies that the user wants to exit the application
using a modal dialogue box, and then closes the GUI.
64
65
66
67
CHAPTER 3: DYNAMIC SIGNATURE VERIFICATION
Introduction:
The main advantage of using the optical sensor to read data is that dynamic data
is available as against static data. In dynamic signature verification, we use time
based x-y co-ordinates of data and not static image of the signature. Thus
dynamic properties of the signature such as time, rhythm, etc can be measured
easily and effectively used for identification as well as detection of forgeries.
Regular static properties such as mean, correlation, covariance standard
deviation are calculated as well.
Automated signature verification systems have widespread applications in banks,
documents and checks among others. Most signature verification systems work
on the principal of finding out specific properties or features of a signature and
comparing these with the sample signature, to decide whether it is genuine or a
forgery.
Signature verification systems can basically be classified into two types
depending on their mode of operation and available data. Offline (static)
signature verification takes the image of a signature as input and processes it for
different features. In dynamic signature verification, we use time based x-y co-
ordinates of data and not static image of the signature. Thus dynamic properties
of the signature such as time, rhythm, etc can be measured easily and effectively
used for identification as well as detection of forgeries. The data that we obtain
from the optical mouse is dynamic data in the form of sequential X-Y coordinates
at a specified rate.
68
Data Acquisition And Processing:
Data is acquired from the microcontroller using serial communication protocol,
supported by MATLAB. A serial object is created in MATLAB and data is
transferred using commands such as ‘fread’ and ‘fwrite’. This data acquired is in
the form of x-y co-ordinate arrays and a third data array consisting of the status
bytes. This is used to convert the differential X-Y co-ordinates into absolute co-
ordinates depending upon the sign bit in the status byte. We store this data in the
form of the processed X-Y arrays in text files, which are used for further
processing.
Before using this data, we remove redundant zeroes at the beginning and the
end of the acquired data. These zeroes represent no useful data but just reflect
static position of the pen when the user has yet to begin signing or has finished
with the signature.
We change the range of the data to make the entire data positive. We also
normalize the data to a pre-decided range, so that it makes further comparison
effective, making it independent of size of the signature which often differs for the
same user by a small degree.
Feature Extraction:
The basic principal of signature verification lies in finding out the unique
properties of the signature prototype and comparing these features with those of
the acquired signature sample. A user dependent or user independent threshold
can then be used to classify the acquired sample as an original or as a forgery.
We considered the following features for our signature identification and
verification application:
69
! Statistical Mean
This is the simplest statistical property of the signature. We can
calculate the X and Y co-ordinate means using the inbuilt MATLAB
function ‘mean()’.
! Standard deviation
Standard deviation is the average deviation of any signal about its
mean. We use this property to find out and quantify how much a
user’s signature varies along the Y as well as X direction. The
MATLAB function ‘std()’ is used to determine the standard deviation
of any one-dimensional array.
! Total length
This property simply computes the total length of the signature
using the normal distance formula summed over the entire
signature path. The data we are using has a very good resolution;
hence this simple summation gives an accurate value of the total
length of the signature.
! Total time
This is one of the dynamic properties that we calculate. The total
time taken by any person to sign usually remains the same, since it
is a practiced motion. We get data at regular intervals from the
optical mouse. Hence the total array size after removing the zeroes
reflects the total time taken by the user to sign.
! Correlation
In statistics, correlation, also called correlation coefficient, indicates
the strength and direction of a linear relationship between two
random variables. Simply put, it reflects the degree of similarity
between any two functions. The sample of correlation graphs
obtained for the auto-correlation of a signature, correlation between
70
samples of the same person’s signature, and that of two different
signatures is shown in the figures below. As we can see from the
graphs, the auto-correlation graph shows a distinct peak and
symmetry. The graph of correlation between two signature samples
of the same person has a reduced symmetry and a less prominent
peak, but has a distinguishable property nevertheless. The
correlation of two different signatures fails to show either the peak
or any symmetry whatsoever. These features of evident from the
graph can be quantified by either taking a simple ratio of the peak
values in each of the graphs, or by using the ‘polyfit’ function which
gives coefficients of a polynomial fit to the graph. The highest order
coefficient remains approximately the same for a correlation graph
between two similar signature samples.
71
Auto correlation.
Correlation of two samples of signatures by the same user.
72
Correlation of a signature with its skilled forgery.
Correlation of two different signatures.
73
! Covariance
In statistics, covariance is the measure of how much two random
variables vary together (as distinct from variance, which measures how
much a single variable varies). If two variables tend to vary together
(that is, when one of them is above its expected value, then the other
variable tends to be above its expected value too), then the covariance
between the two variables will be positive. On the other hand, if when
one of them is above its expected value, the other variable tends to be
below its expected value, then the covariance between the two
variables will be negative.
The covariance function ‘cov’ in MATLAB requires the two signal
samples to be of equal size. We interpolate the smaller signature to
make it equal in length to the longer one. We perform covariance on
two Y coordinate arrays and divide them by the standard deviation of
each of the arrays. The procedure is repeated for the X coordinates,
though in any signature the Y coordinates reflect much more
information about the signature than do the X coordinates. We obtain a
2X2 matrix using this procedure which gives us the mean independent
covariance between the two signature samples. The matrix elements
(2,1) and (1,2) are the same and have a value between -1 to 1, where
a value tending to 1 represents a good covariance, a value
approximately 0 represents no correlation between the signals, and a
value tending to -1 represents a negative covariance.
! Peaks and Valleys Detection
Finding out the peaks and valleys of any signature provides us with an
array of useful features such as number of strokes, stroke lengths and
times, and the more obvious ones of actual peak and valley positions.
We perform peak and valley detection process only on the Y
coordinates. For a particular user, the number of peaks and valleys
remains approximately the same, and their locations also remain fairly
74
constant. Thus this feature is one of the most important features we
have used in identification and verification of signatures.
The algorithm used to detect peaks and valleys first smoothes the
signal by the use of a convolution filter. We then proceed to compare
consecutive points and determine whether it is a valley or peak, i.e.
local minima or maxima. We obtain the position or time coordinate of
the location of peaks and valleys using this function. The graph shown
below displays the peaks and valleys detected for a signature.
We used the peaks and valleys so obtained in a variety of useful feature
detection algorithms mentioned below.
75
! Number of strokes, stroke times and stroke lengths
Calculating number of strokes is the simplest application of peaks and
valleys. We can further use this to find out length of each stroke which
remains approximately the same for each user. The array size of each
stroke individually taken gives us the time for each stroke. This is
especially useful in detecting forgeries since dynamic properties like
stroke time cannot be imitated by someone who has access to a static
image of the original signature. We obtain correlation of the stroke
lengths and times to compare them with those of the original.
Stroke time correlation for two different signatures.
76
! Dynamic Time Warping
DTW finds for each sample in one of the curves, the correspondent
sample in the other curve that is closest to the original sample using
some predefined metric. Given this correspondence, it is possible to
calculate a “distance” between the curves under comparison.
Consider two arrays y1 and y2 representing the Y coordinates of two
signatures to be compared. We form a matrix C where:
C(i,j) = y1(i) – y2(j)
Consider one example,
Y1= [1 0 1 2 1]
Y2= [1 0 2 1]
Then the cost matrix generated will be:
77
Thus, the two figures to be matched are given by:
Local Cost Grid obtained is given as:
78
The optimal path for the grid can be shown in the figure below:
After calculating cost function for all paths, the path with minimum cost function is
selected:
79
To minimize the cost function, we need to find the path between points C(1,1) to
C(m,n) such that the summation along the path is minimum. Here m and n are
lengths of y1 and y2 respectively. This algorithm yields a compression or
expansion of the data along the signal in order to find the best possible match
between the two samples.
We used the method of recursion in order to evaluate each path cost and
minimize it. However the program was not optimized for time, and especially in
MATLAB, was taking a long time to execute even for small arrays of the order
10X10. We then adapted the algorithm in C language, and put a number of
optimization constraints on the warping path. These included restricting the path
to near diagonal area. This eliminated approximately half of the elements of the
C matrix from consideration, thus reducing the calculations. We also included
slightly different algorithms depending on the relative lengths of the two matrices,
thus defining whether the path should take a right or a down after a default
diagonal path. We evaluated cost at each step, and if it exceeded the minimum
cost obtained till that point, we discarded the entire path.
With these optimized techniques, we were able to handle matrices of the order of
20X20. Thus we used this technique for warping of stroke lengths and times,
rather than entire signature warping and much more extensively in the character
recognition algorithm.
80
GUI for signature verification:
The graphical user interface that we had formed had the following appearance
for signature identification and verification system.
! Read Signature: This button allows the user to read currently stored
data serially from the pen. This button calls the function serialread()
through which MATLAB serially reads data from the pen. It also calls a
function remove0() which removes the redundant zeroes at the
beginning and the end.
! Display Signature: This button becomes active only after the user has
taken atleast one data reading. The callback for this button simply plots
the current data acquired from the pen onto the axes on the GUI.
! Signature Identification: This button has a callback which executes a
function sign_identify. This function calls the various functions which
find out the feature vector for each signature in the database, and
match it with the sample signature. The function finds out all different
features of the sample signature, and matches them with all signatures
in the database. It returns the one with the highest matching
percentage, and displays the result in the result text box.
! User name text box: The user is supposed to enter the user name
here against whom the signature verification is to be done. Only if the
user name entered is a valid name, the signature verification button
becomes active.
! Signature Verification: The verify button has a callback which
executes the function sign_verify function. This function evaluates the
entire feature vector, and depending on the user dependent threshold,
assigns the sample signature as a genuine or a forgery.
! Result Panel: The resul panel consists of the result text box and the
bar graph result. The user name and confidence level is shown in this
while identifying the signature, and the whether verified or not, along
with matching percentage while verification. The bar graph adjoining it
81
displays the verification resul graphically. It shows the result in red if it
does not match and in green if it does match. It shows the matching
percentage and also the threshold with a single line.
! Admin: The user can log in as administrator from this button.
! Main menu: This button enables the user to return to the main menu
to choose another application. It basically closes this GUI and opens
the first one.
82
83
84
Administrator Password GUI:
To log in to the administrator page, the user needs to provide the correct
username and password, failing which he will be redirected to the main page. A
popup is shownif the user enters incorrect information, and asks the user to retry,
go to main menu, or exit entirely. If the correct login and password are provided,
user can view the administrator GUI, as shown below.
85
Administrtaor GUI:
The admin GUI gives options to add/edit and delete accounts. An entire pop-up
list of all users in the database can be viewed. The entire signature verification
procedure can be graphically seen on this page.
! Add/Edit account: This button closes this current GUI opens the
Add_admin GUI.
! Delete Account: This button simply deletes the selected entry from
the pop up menu.
! Popup menu: This is initialized during the opening function of the GUI.
It shows a popup list of all valid users. The entire signature verification
procedure is carried out between the current selected user and the
sample signature.
! Display Statistical Properties: The statistical properties such as
mean, standard deviation, etc are displayed in the textbox.
! Display Prototype: This button allows the user to see the prototype
signature of the currently selected user.
! Display Signature: This allows the user to view the recent signature
sample.
! Correlation: This button shows the auto correlation of the prototype
signature in the left side axis, and the correlation of the sample with the
prototype in the right hand side axis.
! Peaks and Valleys: The peaks and valleys button is used to
graphically demonstrate peaks and valleys for both the prototype and
the sample signature.
! Warping: The warping function allows us to visualize dynamic time
warping of the stroke lengths.
! Stroke Correlation: The stroke time correlation can be seen using the
stroke correlation button.
86
Each of these buttons has a callback which results in the execution of the
respective function, selection of the proper axis, clearing the axis and
displaying the corresponding graph.
! Main Menu: This page also has a main menu button allowing the user
to go back to the main page.
The screen shots below display the various function for one of the sample
signatures.
87
88
Displaying prototype and sample signature
Correlation graphs
89
Peaks and Valleys
Warping of stroke distances
90
Stroke time correlation
Statistical Properties
91
Add Users:
The add_admin GUI allows the administrator to add a user to the database. The
appearance of the GUI is shown below. The administrator can add a user by
taking 5 sample signatures and making a prototype out of them. Information
about the user such as city and telephone number can be added here.
! Add: This button allows the administrator to add an account to the
database.
! Edit: This allows the administrator to edit the details of any of the user in
the database.
! Popup menu: Itts shows the list of all users already in the database. This
list is formed in the opening function of the GUI.
! Text boxes for name, city and telephone number: These allow the
administrator to change these fields for the selected user.
! Confidence level: This scroll bar allows the administrator to set the
confidence level for any particular user.
! Read: This button allows the user to read a sample signature.
! Display: This button allows the user to view the currently read signature.
! Accept: The user can accept the sample signature to make the prototype.
! Make Prototype: This button makes a prototype for a new user after the
count in the text box is 5. The callback for this button execues a function
which correlates the five samples, and selects the sample with the highest
correlation with all others as the prototype. It writes this prototype into the
database along with the other details for the user.
! Admin Menu: The administrator can return to the admin menu withthis
button.
! Main Menu: The administrator can return to the main menu using this
button.
92
!
93
CHAPTER 4: CHARACTER RECOGNITION
Character Recognition
We decided to implement digit recognition from ‘0’ to ‘9’ and character
recognition from ‘a’ to ‘f’. After extensive experimentation we concluded that
dynamic time warping was the most effective, giving accuracy of approximately
95%.
The resolution of the data acquired is very high, moreover the warping algorithm
can effectively handle 20X20 matrices only, thus we considered every fourth or
fifth element of the data in the actual warping program. The high accuracy was
obtained when 60% weightage was given to warping of X-coordinated and 40%
to that of Y.
A sample of the warping is shown in the figure below.
94
GUI:
The character recognition GUI allows the user to select one of the two modes,
viz., character recognition (from a to f) or digit recognition. The read, display and
recognize buttons respectively read the data, display the digit or number draw,
and find out the closest match to it. The call back of the recognize button calls a
function which performs dynamic time warping on the sample data and each of
the prototype digits or numbers as selected. The digit or character with the
minimum cost function is displayed as the result in the text box. The DTW graphs
are displayed in the four axes.
! Read: This button allows the user to read the data from the pen, and
stores it into the temporary folder we have created.
! Display: This button enables the user to display the data just read.
! Recognize: This button executes the actual recognition program, and
returns the result in the text box, as well as shows the warping plots on
the 4 axes. This button has a callback function which runs the warping
program on all digits/character, and evaluates the cost function in each
case. The result is the digit/character with the lowest cost.
! Recognition Mode: This allows the user to select the mode, either
digit recognition or character recognition(a-f)
! Result Textbox: The result of the recognition program is displayed in
this textbox.
! Axes: The two upper upper axes display X and Y warping of the
match. The two lower axes display the X and Y warping of the least
match. This demonstrates the effectivelness of the warping function
and how it recognizes the digit or character by comparing the cost
function.
! Main Menu: his button allows the user to access the main menu again.
95
96
97
CHAPTER 5: DESIGN AID
Basic Engineering and Design applications can be implemented using this
hardware. The various application we implemented include point to point plot,
tracing the actual movement of the pen, curves with user defined angles and
semicircles. This can find numerous applications in the field of architecture, civil
engineering, etc. For ease of use and convenience of plotting, various colours
and line styles were implemented.
The user presses the button mounted on the pen and this click is detected by the
software. The simple program generates an array representing X and Y
coordinates of the click, using the information reflected by the status bit. These
arrays can be used further for various plotting options. We implemented the
following plotting options:
! Free plot : Plot the points in between the button clicks as they were traced.
! Point to point plot: Plot the points in between the two points as a straight
line.
! Arc(clockwise/anticlockwise): This allows the user to draw an arc with the
user specified subtended angle between the two points.
98
GUI:
The graphical user interface for the design aid had an appearance as shown on
the following page.
! Read: This button allows the user to read the data. The callback function
stores the X, Y coordinates alongwith the button click data.
! Display: This button allows the user to plot the data in a variety of styles
and forms, as explained from the popup menus.
! Plotting Tool: This allows the user to select a specific colour, and a style
for plotting the data, such as ‘*’ (asterix), squares, dots, etc.
! Design Aid: This allows the user to plot each segment as either a free
plot, a point to point plot, or an arc with a specified angle. A function
findarray() is first executed, which identifies the points at which button
press occurred, and stores them in a text file. This is then used by the
callback of the display button to calculate the path to be plotted in between
the two corresponding points.
! Save: This button allows the user to save the data just loaded to any
location on the computer.
! Load: This button enables the user to load any previously stored data.
! Main Menu: This allows the user to navigate back to he main menu.
99
100
101
102
SECTION 7
COSTING
103
COSTING
Component No. Of Units Total Cost In Rupees.
AtTiny2313 ("C) 1 90/-
AT24C512
Internal EEPROM 3 195/-
Intex Mouse 1 200/-
MAX-232 1 30/-
PCB Fabrication - N.A - 85/-
Resistors, Capacitors,
LEDs- N.A - 20/-
Acrylic Sheet - N.A - 20/-
Pen 1 10/-
Sum Total Cost = Rs.650/- Approximately
104
SECTION 8
CONCLUSION
105
CONCLUSION
The imaginative use of the mouse sensor circuit has made possible signature
verification and identification, character recognition and design. However, the
possible scope of the project doesn’t end there.
Applications in areas as diverse as robotics, biometrics and handwriting analysis
can be envisioned. The current system itself may be improved upon.
For one, the use to IRDA technology can enable completely wireless
communication between the module and the computer. This may have great
scope in bank ATMs or for official document signatures. For further security in
the case of signature verification system, the use of pressure transducers can set
extremely low false acceptance results. A possible interface with SD cards can
further reduce the size, improving the speed and reducing cost all at once.
Additional functionality may be developed in the case of design aid tool, viz.
inclusion of polynomials, curves and angles etc. Area calculation and distance
measurements become rather easy to achieve, but may be of great use to civil
engineers, designers and architects.
In summary, the whole purpose behind undertaking such a project is to
demonstrate, for one, the breathtaking possibilities that technology has to offer,
as well as our own understanding of the needs of the real world and our ability to
utilize the skill set mastered over the rigorous courses.
106
SECTION 9
REFERENCES
107
REFERENCES
! Claudio Lanconelli Avr-Pg1b (Serial Port) 10 Pin Icsp Avr Microcontroller
Programmer.
! Programmer's Reference to Genius Mouse & # Mice: How do they work?
by Richard Torrens.
! Adam Chapweske, The PS/2 Mouse/Keyboard Protocol, www.Computer-
Engineering.org
! Solid-State Optical Mouse Sensor with PS/2 and Quadrature Outputs,
Agilent Technologies.
! Paint Program with Mouse Control, Steven Keiper and Ragavan
Mahedevan, Cornell University.
! ADNK-5023-CY02 Optical Mouse Designer’s Kit, Avago Technologies.
! Programming In MATLAB, A Manual.
! MATLAB 7, Creating Graphical User Interfaces, MathWorks.
! Handwriting Recognition Using MATLAB by Jonathan Terleski.
! Modeling In Applied Mathematics, Bengt Fornberg & Ben Herbst.
! Analyses and Tests of Handwritten Digit Recognition Algorithms, Berkant
Savas.
108
! EAGLE - Easily Applicable Graphical Layout Editor Manual Version 4.1.
! MATLAB Documentation And Help Files.
! CodeVision AVR, Code Wizard and AVR studio Documentation.
! ATTINY2313, AT24C512, MAX232 datasheets.
! www.mathworks.com
! www.semiconductors.phillips.com
! www.alldatasheets.com
! www.atmel.com
! www.microchip.com
! www.lancos.com
! www.google.com
109
SECTION 10
APPENDIX
110
APPENDIX A
Given below is the software program in ‘C’ language that’s loaded on the
AtTiny2313. It’s task is to operate the module in the different modes as explained
in the main text.
/*****************************************************
This program was produced by the
CodeWizardAVR V1.24.8d Professional
Automatic Program Generator
© Copyright 1998-2006 Pavel Haiduc, HP InfoTech s.r.l.
http://www.hpinfotech.com
Project : Optical Sensor Based Signature Recognition Tool
Version : 1
Date : 4/15/2007
Author : Siddharth Shashidharan, Himanshu Madan, Sanika Mokashi & Sneha Rangdal
Company : C.O.E.P
Comments:
Chip type : ATtiny2313
Clock frequency : 1.000000 MHz
Memory model : Tiny
External SRAM size : 0
Data Stack size : 32
*****************************************************/
#include <tiny2313.h>
#include <stdio.h> // sprintf
#include <delay.h> // delay_ms
#include <stdlib.h>
#define DATA_IN PIND.4 //data line from mouse
#define CLK_IN PIND.5 //clock line from mouse
#define DATA_OUT PORTD.4 //data line from mouse
#define LOW 0
111
#define HIGH 1
#define DDR_USI DDRB
#define PORT_USI PORTB
#define PIN_USI PINB
#define PORT_USI_SDA 5
#define PORT_USI_SCL 7
#define PIN_USI_SDA 5
#define PIN_USI_SCL 7
#define itime2 3
#define itime4 3
//#define daddress 0xA2
#define RXB8 1
#define TXB8 0
#define UPE 2
#define OVR 3
#define FE 4
#define UDRE 5
#define RXC 7
#define FRAMING_ERROR (1<<FE)
#define PARITY_ERROR (1<<UPE)
#define DATA_OVERRUN (1<<OVR)
#define DATA_REGISTER_EMPTY (1<<UDRE)
#define RX_COMPLETE (1<<RXC)
#define sig_read 0x400;
#define char_read 0x100;
#define des_read 0x800;
register unsigned char data @4;
#asm
.equ PORTD=0x12
.equ DDRD=0x11
112
.MACRO DATALOW
sbi DDRD,4 ;DDRD.4=1
cbi PORTD,4 ;PORTD.4=0
.ENDM
.MACRO RELDATA
cbi DDRD,4 ;DDRD.4=0
sbi PORTD,4 ;PORTD.4=1
.ENDM
.MACRO CLKLOW
sbi DDRD,5 ;DDRD.5=1
cbi PORTD,5 ;PORTD.5=0
.ENDM
.MACRO RELCLK
cbi DDRD,5 ;DDRD.5=0
sbi PORTD,5 ;PORTD.5=1
.ENDM
#endasm
unsigned char
mouse_x,mouse_y,mouse_status,ack0,oflag=1,sflag=1,opmode,powerflag,powerflag1=0,cflag=0;
unsigned int read=0,limit_read=0x50,sread;
unsigned int address=0x00;
bit power=0;
void USI_TWI_Master_Initialise( void )
{
PORT_USI |= (1<<PIN_USI_SDA); // Enable pullup on SDA, to set high as released state.
PORT_USI |= (1<<PIN_USI_SCL); // Enable pullup on SCL, to set high as released state.
113
DDR_USI |= (1<<PIN_USI_SCL); // Enable SCL as output.
DDR_USI |= (1<<PIN_USI_SDA); // Enable SDA as output.
USIDR = 0xFF; // Preload dataregister with "released level" data.
USICR = 0b00101010;
// Disable Interrupts.
// Set USI in Two-wire mode.
// Software stobe as counter clock source
USISR = 0b11110000; // Clear flags and reset counter.
}
/*---------------------------------------------------------------
Function for generating a TWI Stop Condition. Used to release
the TWI bus.
---------------------------------------------------------------*/
void USI_TWI_Master_Stop( void )
{
PORT_USI &= ~(1<<PIN_USI_SDA); // Pull SDA low.
PORT_USI |= (1<<PIN_USI_SCL); // Release SCL.
while(!(PIN_USI & (1<<PIN_USI_SCL)));
delay_us(itime4);
PORT_USI |= (1<<PIN_USI_SDA); // Release SDA.
delay_us(itime2);
}
/*---------------------------------------------------------------
Core function for shifting data in and out from the USI.
Data to be sent has to be placed into the USIDR prior to calling
this function. Data read, will be return'ed from the function.
114
---------------------------------------------------------------*/
unsigned char USI_TWI_Master_Transfer( unsigned char temp )
{
USISR = temp; // Set USISR according to temp.
// Prepare clocking.
temp = 0b00101011; // Interrupts disabled
// Set USI in Two-wire mode.
// Software clock strobe as source.
// Toggle Clock Port.
do
{
delay_us(itime2);
USICR = temp; // Generate positve SCL edge.
while( !(PIN_USI & (1<<PIN_USI_SCL)) ); // Wait for SCL to go high.
delay_us(itime4);
USICR = temp; // Generate negative SCL edge.
}
while( !(USISR & 0x40) ); // Check for transfer complete.
delay_us(itime2);
temp = USIDR; // Read out data.
USIDR = 0xFF; // Release SDA.
DDR_USI |= (1<<PIN_USI_SDA); // Enable SDA as output.
return temp; // Return the data from the USIDR
}
char i2c( unsigned char idata, unsigned char dmode, unsigned char rw)
{
unsigned char tempUSISR_8bit = 0b11110000; // Prepare register value to: Clear flags, and
// set USI to shift 8 bits i.e. count 16 clock edges.
115
unsigned char tempUSISR_1bit = 0b11111110; // Prepare register value to: Clear flags, and
// set USI to shift 1 bit i.e. count 2 clock edges.
unsigned char daddress;
unsigned char maddress_low;
unsigned char maddress_high;
char rdata;
daddress = (0xA0|dmode) ;
/* Release SCL to ensure that (repeated) Start can be performed */
PORT_USI |= (1<<PIN_USI_SCL); // Release SCL.
while(!(PORT_USI & (1<<PIN_USI_SCL))); // Verify that SCL becomes high.
delay_us(itime2); // Delay
maddress_low=(address);
maddress_high=(address>>8);
/* Generate Start Condition */
PORT_USI &= ~(1<<PIN_USI_SDA); // Force SDA LOW.
delay_us(itime4);
PORT_USI &= ~(1<<PIN_USI_SCL); // Pull SCL LOW.
PORT_USI |= (1<<PIN_USI_SDA); // Release SDA.
// address write
PORT_USI &= ~(1<<PIN_USI_SCL); // Pull SCL LOW.
USIDR = daddress; // Setup data.
USI_TWI_Master_Transfer( tempUSISR_8bit ); // Send 8 bits on bus.
// ack
DDR_USI &= ~(1<<PIN_USI_SDA); // Enable SDA as input.
USI_TWI_Master_Transfer( tempUSISR_1bit );
// memory address_high write
PORT_USI &= ~(1<<PIN_USI_SCL); // Pull SCL LOW.
USIDR = maddress_high; // Setup data.
USI_TWI_Master_Transfer( tempUSISR_8bit ); // Send 8 bits on bus.
116
// ack
DDR_USI &= ~(1<<PIN_USI_SDA); // Enable SDA as input.
USI_TWI_Master_Transfer( tempUSISR_1bit );
// memory address low write
PORT_USI &= ~(1<<PIN_USI_SCL); // Pull SCL LOW.
USIDR = maddress_low; // Setup data.
USI_TWI_Master_Transfer( tempUSISR_8bit ); // Send 8 bits on bus.
// ack
DDR_USI &= ~(1<<PIN_USI_SDA); // Enable SDA as input.
USI_TWI_Master_Transfer( tempUSISR_1bit );
if (rw==0)
{
// data write
PORT_USI &= ~(1<<PIN_USI_SCL); // Pull SCL LOW.
USIDR = (idata); // Setup data.
USI_TWI_Master_Transfer( tempUSISR_8bit ); // Send 8 bits on bus.
// ack
DDR_USI &= ~(1<<PIN_USI_SDA); // Enable SDA as input.
USI_TWI_Master_Transfer( tempUSISR_1bit );
}
else
{
/* Release SCL to ensure that (repeated) Start can be performed */
PORT_USI |= (1<<PIN_USI_SCL); // Release SCL.
while(!(PORT_USI & (1<<PIN_USI_SCL))); // Verify that SCL becomes high.
delay_us(itime2); // Delay
/* Generate Start Condition */
PORT_USI &= ~(1<<PIN_USI_SDA); // Force SDA LOW.
delay_us(itime4);
PORT_USI &= ~(1<<PIN_USI_SCL); // Pull SCL LOW.
PORT_USI |= (1<<PIN_USI_SDA); // Release SDA.
117
// address write
PORT_USI &= ~(1<<PIN_USI_SCL); // Pull SCL LOW.
USIDR = (daddress+1); // Setup data.
USI_TWI_Master_Transfer( tempUSISR_8bit ); // Send 8 bits on bus.
// ack
DDR_USI &= ~(1<<PIN_USI_SDA); // Enable SDA as input.
USI_TWI_Master_Transfer( tempUSISR_1bit );
// Read a data byte
DDR_USI &= ~(1<<PIN_USI_SDA); // Enable SDA as input.
rdata= USI_TWI_Master_Transfer( tempUSISR_8bit );
// Prepare to generate ACK (or NACK in case of End Of Transmission)
USIDR = 0xFF; // Load NACK to confirm End Of Transmission.
USI_TWI_Master_Transfer( tempUSISR_1bit ); // Generate NACK.
}
USI_TWI_Master_Stop(); // Send a STOP condition on the TWI bus.
if((dmode==0x02)||rw==1)
address++;
return(rdata);
}
//**********************************************************
// Send a byte of data to mouse. It consist of 1 start bit, 8 data bits, 1 parity bit, 1 stop bit.
// After the mouse recieved the data correctly, the mouse will send back an ACK bit.
// "data" is the data to be sent. parity bit is odd parity of the 8 bits data.
// Data is read by mouse at rising edge of CLK.
void mouse_send(char data)
{
unsigned char Bit,parity,i;
118
#asm("RELDATA");
#asm("RELCLK");
delay_us(300);
#asm("CLKLOW"); //Pull CLK Low
delay_us(300); // need to wait for at least 100us
#asm("DATALOW"); // Pull DATA Low when holding CLK Low
delay_us(100);
#asm("RELCLK"); //Release CLK and continue to hold Data Low. This is also the Start
bit.
delay_us(40);
while(CLK_IN!=LOW) { } // wait for CLK to go low
i=0; Bit=0b00000001;
parity=1; // odd parity = 1 ^ bit0 ^ bit1 ^ ... ^ bit7
while(i<=8)
{
if(i==8) // If i=8 send parity bit otherwise, send the next bit of data.
{ if(parity) // DATA_OUT=(i==8? parity : (data & Bit) );
{ #asm("RELDATA"); }
else
{ #asm("DATALOW"); }
}
else
{ if(data & Bit)
{ #asm("RELDATA"); }
else
{ #asm("DATALOW"); }
}
while(CLK_IN!=HIGH) {} // wait for CLK to go high. mouse read data at rising
edge.
while(CLK_IN!=LOW) {} // wait for CLK to go low.
parity=parity ^ DATA_OUT; // update parity bit.
Bit=Bit<<1; // Prepare mask
i++;
}
#asm("RELDATA"); // Release Data line. This is the stop bit.
delay_us(50); // give time for transient to settle.
119
while(DATA_IN!=LOW) {} // wait for Data line to go low
while(CLK_IN!=LOW) {} // wait for CLK to go low. Start of ACK from mouse.
while(DATA_IN==LOW || CLK_IN==LOW) {} // End of ACK from mouse.
#asm("CLKLOW"); // Inhibit the mouse from transmitting data.
}
//**********************************************************
// This function read a byte of data from the mouse and return the byte
unsigned char mouse_read(void)
{
unsigned char i,t[10];
#asm("RELCLK"); //release the CLK
#asm("RELDATA"); //release DATA line.
delay_us(200); // wait for at least 100us
while(CLK_IN==HIGH) {} // wait for falling edge. we read data at falling edge of CLK
i=0;
delay_us(5);
while(CLK_IN==LOW) {} // wait for CLK to go high.
while(i<=8)
{
while(CLK_IN==HIGH) {} // wait for falling edge of CLK
t[i]=DATA_IN; // store each bit
i++;
while(CLK_IN==LOW) {}
}
while(CLK_IN==LOW) {}
data=128*t[7]+64*t[6]+32*t[5]+16*t[4]+8*t[3]+4*t[2]+2*t[1]+t[0]; //combine the collected bits into a
byte
#asm("CLKLOW"); //pull CLK low to prevent mouse from sending data until being asked
return data;
}
120
//*******************************************
// This routine poll the mouse's status and movement data.
void poll_mouse(void)
{
mouse_send(0xeb); //Request data from mouse
mouse_read(); //Read the acknowledge byte
mouse_status=mouse_read(); //Read mouse status
i2c(mouse_status,0x00,0);
mouse_x=mouse_read(); //Read mouse horizontal movement
i2c(mouse_x,0x06,0);
mouse_y=mouse_read(); //Read mouse vertical movement
i2c(mouse_y,0x02,0);
/*
powerflag=(mouse_status & 0x04);
if(powerflag==1)
{
cflag=1;
}
if(cflag==1 && powerflag==0)
{
powerflag1=1;
cflag=0;
}
121
if(powerflag1==1)
{
power=~power;
powerflag1=0;
} */
/* if((mouse_x!=0 && mouse_y!=0) )
{
address++;
read++;
}
*/
}
//**********************************************
// This function is called to reset the mouse and put it into remote mode.
// In remote mode, mouse only send data upon request from the microcontroller.
// This function is called when manual reset of the mouse is required. This is for
// overcoming interference problem from some unknown EM field.
void reset_mouse(void)
{
mouse_send(0xff); // reset mouse
ack0=mouse_read(); // read mouse acknowledge (0xFA)
//i2c(ack0,0);
ack0=mouse_read(); // read some blank bytes.
//i2c(ack0,0);
ack0=mouse_read();
// i2c(ack0,0);
122
mouse_send(0xf3); // SAMPLE RATE
ack0=mouse_read();
// i2c(ack0,0);
mouse_send(0xc8); // rate=200
ack0=mouse_read();
// i2c(ack0,0);
mouse_send(0xE8); // resolution
ack0=mouse_read();
//i2c(ack0,0);
mouse_send(0x03); // 8 counts per mm
ack0=mouse_read();
//i2c(ack0,0);
mouse_send(0xE6); // scaling 1:1
ack0=mouse_read();
//i2c(ack0,0);
mouse_send(0xf0); // Set mouse to remote mode.
ack0=mouse_read();
//i2c(ack0,0);
delay_ms(100);
delay_ms(2000);
}
//**********************************************
123
void initialize(void)
{
#asm("cli");
//init ports
DDRD = 0b01001111; // PD5 DATA IN, PD4 CLOCK IN
DDRD.6=0; // Use for mouse reset
PORTD.6=1; // enable pullup resistor
DDRD.4=1;
PORTD.4=1;
delay_ms(500);
DDRD.4=0;
DDRD.5=1;
PORTD.5=1;
delay_ms(500);
DDRD.5=0;
// init mouse variables
#asm("RELCLK");
#asm("RELDATA");
//init mouse state
reset_mouse();
}
// Write a character to the USART Transmitter
#ifndef _DEBUG_TERMINAL_IO_
#define _ALTERNATE_PUTCHAR_
#pragma used+
void putchar(unsigned char c)
{
124
while ((UCSRA & DATA_REGISTER_EMPTY)==0);
UDR=c;
}
#pragma used-
#endif
// USART Receiver interrupt service routine
interrupt [USART_RXC] void usart_rx_isr(void)
{
//char read=0x7F;
char status,sdata;
unsigned char temp;
//unsigned int address1,address2;
status=UCSRA;
sdata=UDR;
if ((status & (FRAMING_ERROR | PARITY_ERROR | DATA_OVERRUN))==0)
{
sread=read;
if(sdata=='o')
{
DDRB.4=1;
PORTB.4=1;
putchar(opmode);
putchar(read);
putchar(address>>8);
}
if(sdata=='c')
{
address=0x00;
while(sread!=0)
{
temp=i2c(read,0x00,1);
putchar(temp);
sread--;
}
125
}
if(sdata=='x')
{
address=0x00;
while(sread!=0)
{
temp=i2c(read,0x06,1);
putchar(temp);
sread--;
}
}
if(sdata=='y')
{
address=0x00;
while(sread!=0)
{
temp=i2c(read,0x02,1);
putchar(temp);
sread--;
}
DDRB.4=1;
PORTB.4=0;
sflag=0;
}
}
}
// External Interrupt 0 service routine
interrupt [EXT_INT0] void ext_int0_isr(void)
{
DDRB.4=1;
PORTB.4=0;
126
delay_ms(100);
DDRB.0=1;
DDRB.1=1;
DDRB.2=1;
DDRB.3=1;
PORTB.0=0;
PORTB.1=0;
PORTB.2=0;
PORTB.3=0;
DDRB.0=0;
DDRB.1=0;
DDRB.2=0;
DDRB.3=0;
opmode=PINB & 0x0F;
oflag=1;
if(opmode==1)
limit_read=des_read;
if(opmode==2)
limit_read=char_read;
if(opmode==4)
limit_read=sig_read;
if(opmode==8)
{
#asm("sei")
while(sflag!=0){}
sflag=1;
}
127
read=0x00;
address=0x00;
USI_TWI_Master_Initialise();
initialize();
DDRB.4=1;
PORTB.4=1;
delay_ms(500);
PORTB.4=0;
delay_ms(500);
PORTB.4=1;
delay_ms(500);
PORTB.4=0;
delay_ms(500);
// delay_ms(500);
PORTB.4=1;
}
void main(void)
{
// Declare your local variables here
// Crystal Oscillator division factor: 8
#pragma optsize-
CLKPR=0x80;
CLKPR=0x04;
#ifdef _OPTIMIZE_SIZE_
#pragma optsize+
#endif
/*
// Timer/Counter 0 initialization
// Clock source: System Clock
// Clock value: Timer 0 Stopped
128
// Mode: Normal top=FFh
// OC0A output: Disconnected
// OC0B output: Disconnected
TCCR0A=0x00;
TCCR0B=0x00;
TCNT0=0x00;
OCR0A=0x00;
OCR0B=0x00;
// Timer/Counter 1 initialization
// Clock source: System Clock
// Clock value: Timer 1 Stopped
// Mode: Normal top=FFFFh
// OC1A output: Discon.
// OC1B output: Discon.
// Noise Canceler: Off
// Input Capture on Falling Edge
// Timer 1 Overflow Interrupt: Off
// Input Capture Interrupt: Off
// Compare A Match Interrupt: Off
// Compare B Match Interrupt: Off
TCCR1A=0x00;
TCCR1B=0x00;
TCNT1H=0x00;
TCNT1L=0x00;
ICR1H=0x00;
ICR1L=0x00;
OCR1AH=0x00;
OCR1AL=0x00;
OCR1BH=0x00;
OCR1BL=0x00;
*/
// External Interrupt(s) initialization
// INT0: On
// INT0 Mode: Rising Edge
// INT1: Off
129
// Interrupt on any change on pins PCINT0-7: Off
GIMSK=0x40;
MCUCR=0x03;
EIFR=0x40;
// Timer(s)/Counter(s) Interrupt(s) initialization
TIMSK=0x00;
// Universal Serial Interface initialization
// Mode: Disabled
// Clock source: Register & Counter=no clk.
// USI Counter Overflow Interrupt: Off
USICR=0x00;
// USART initialization
// Communication Parameters: 8 Data, 2 Stop, No Parity
// USART Receiver: On
// USART Transmitter: On
// USART Mode: Asynchronous
// USART Baud rate: 2400
UCSRA=0x00;
UCSRB=0x98;
UCSRC=0x0E;
UBRRH=0x00;
UBRRL=0x19;
// Analog Comparator initialization
// Analog Comparator: Off
// Analog Comparator Input Capture by Timer/Counter 1: Off
ACSR=0x80;
USI_TWI_Master_Initialise();
initialize();
// Global enable interrupts
130
#asm("sei")
DDRB.4=1;
PORTB.4=1;
delay_ms(500);
PORTB.4=0;
delay_ms(500);
PORTB.4=1;
delay_ms(500);
PORTB.4=0;
delay_ms(500);
PORTB.4=1;
while(1)
{
while ((read!=limit_read) && (oflag==1))
{
poll_mouse();
read++;
if(read==limit_read-1)
{
oflag=0;
DDRB.4=1;
PORTB.4=0;
}
};
}
}