Mech - User contributions [en]

Actuators Available in the Mechatronics Lab

2008-07-08T21:21:47Z

Matt Turpin:

[[image:all-actuators-captions-small.jpg|right]]

We have acquired a number of actuators that are appropriately sized for
many mechatronics projects. These are the "standard" lab actuators.
You are welcome to borrow them for your project and return them when
you are finished. In addition to the actuators mentioned below, we
have a number of other actuators that we have acquired over the years
that you are welcome to borrow.

For your particular project, it may be best to spec out and buy a
particular type and size of actuator. If your specifications are not
too critical, however, the actuators below will allow you to get
started right away.

__TOC__

 

==DC Motors (with gearheads and encoders)==

There are many types of DC motors, but our favorites are brushed
permanent magnet DC motors for their power, price, ubiquity, and
simplicity. Simply put a voltage across the two motor terminals, and
the motor spins. (You can learn about the
theory of how a brushed DC
motor works and suggested methods
for driving a DC motor elsewhere on this wiki.)

One problem is that most DC motors tend to rotate at very high speeds,
typically several thousand RPM or more. This is too fast for most
mechatronics applications. Also, they tend to have too little torque.
Both of these problems can be solved by the use of gears on the output
shaft of the motor. If the motor has an N:1 gearhead on its output
shaft (where N>1, typically), then the output shaft of the gearhead
reduces the speed of the motor by a factor of N and icreases the
torque of the motor by a factor of N. (You can learn more
about how gears work including other issues
they introduce, such as gearhead efficiency and backlash.)

Another issue is how to determine how far the motor has rotated. You need
''feedback'' from the motor. There are many ways to do this; see
here for information on using
encoders, potentiometers, and tachometers. The most common way to get angle
feedback is through the use of encoders. An encoder is typically attached
to a motor shaft and produces pulses that encode the shaft rotation angle.
These pulses can be read in by the encoder inputs of the Mechatronics Lab
PC/104 stacks.

So, perhaps the most versatile kind of actuator is a DC motor with a gearhead and an
encoder. Below are some that we keep in the lab. Sometimes DC motors
with gearheads and encoders can be purchased through surplus outlets at
great prices, for prices less than any of the single components (motor,
gearhead, encoder) could be purchased individually. That's how many
copies of the actuators below were purchased. If you see a great
deal on a nice-sized motor plus gearhead plus encoder, of which many
copies can be purchased, let us know!

===6W Maxon motor with 6:1 gearhead and 100 line encoder===

[[image:maxon-small2.jpg|right]]

'''Summary:'''
* 24 V, 41.5 ohms resistance, max current 0.58 Amps
* max torque: 0.15 Nm (approx)
* max speed: 600 RPM (approx)
* encoder: 600 counts/rev at output shaft, 2400 counts/rev in 4x decoding mode

 

The motor is rated at 24 volts, giving a no-load (maximum)
speed of 3990 RPM (about 418 radians/sec) and a (maximum) stall torque of 31.9 mNm (milli
Newton meters). The terminal resistance (the resistance through the
motor windings) is 41.5 ohms. This means if you put 24 V across it,
the maximum current that it will draw is 24/41.5 = 0.58 Amps. This
maximum current occurs when the motor is stalled and generating its
maximum torque. Motor torque is proportional to the motor current by
the constant of proportionality called the ''torque constant'',
which is different for every motor.

The motor is called a 6 Watt motor because that is the maximum
electrical power (current times voltage) that can be put into the
motor on a continuous basis. Beyond this power level, the amount of
power dissipated by the resistance of the motor windings will cause
the windings to heat up unacceptably. (It is fine to overpower the
motor intermittently, allowing the coils to cool so that the average
power does not exceed the rated power.) At this operating point,
the motor draws 244 mA, giving 24 V x 0.244 A = 5.86 W electrical input
power. At this operating point, the speed of the motor is approximately
1689 RPM, or 177 radians/sec, and the torque of the motor is 13.5 mNm,
giving 177 rad/sec x 0.0135 Nm = 2.39 W of mechanical output power,
giving a power-conversion efficiency of about 41% at this operating point.
The maximum efficiency of the motor is 70%, which occurs at a higher
speed and lower torque. The maximum mechanical power you can get out
of the motor is (1/2 max torque) x (1/2 max speed) = 3.33 W. This is
beyond the continuous operation recommendation, but it is fine to
run it for short periods at this operating point.

Often you will want to run the motor at lower voltages, for instance
at 12 V, instead of the rated 24 V. In this case just multiply the
max current, speed, and torques by the factor 12/24 = 1/2. In particular,
the maximum output power will be only (1/2) x (1/2) = 1/4 the maximum at 24 V.

This actuator comes with a 6:1 spur gearhead, which increases the
torque available at the gearhead's output shaft by a factor of 6 and
decreases the speed by a factor of 6. (In this ideal case, the
power at the gearhead's output shaft is equal to the power at the input.
In practice, gearheads have an efficiency also; the maximum
efficiency of the gearhead here is 81%. This reduces the torque
available.)

In summary, then, if your application requires no more than about 6 x
31.9 mNm = 0.19 Nm maximum torque, 3990 RPM / 6 = 665 RPM max speed,
and 3.3 W max mechanical power, this may be the motor for you.
Reduce those values by a factor of 1/2, 1/2, and 1/4, respectively, if
you are operating the motor with 12 V max instead of 24 V max.

This actuator also comes with 100 line single-ended incremental optical encoder,
with outputs A+ and B+. There is no index channel. The encoder is
attached to the motor. Each of the A+ and B+ channels makes 100 pulses
per revolution of the motor, or 6 x 100 = 600 pulses per revolution of
the output shaft of the gearhead. This means the encoder provides
360 deg / 600 pulses = 0.6 deg/pulse resolution when the pulses are
decoded with the 1x scheme, or 0.15 deg/pulse resolution with the 4x
decoding scheme.

Information about the Maxon motor is given in this [[Media:maxon-2140-specs.pdf|data sheet]] which includes
other motors in this family (ours is the 24V version)
and this [[Media:maxon-our-specific-motor.pdf|data sheet]] which gives only
the information on this motor. (Note the speed-torque curve is a bit misleading,
as it seems to imply the maximum speed of the motor is 6100 RPM, when it should
be 3990 RPM.) Information on the 6:1 gearhead can be found
[[Media:maxon-gearhead.pdf|here]]. The encoder pin-out is indicated below:

 

[[image:encoder-maxon.jpg|right]]

 

The encoder comes with a 4-connector ribbon cable, corresponding to GND, Channel A, Vcc (usually +5V), and Channel B, as
shown on the left. Here the ribbon cable is broken out into a 10-pin connector (which we have in the lab). The connector
above is made to work with the PC/104 stacks, and the pin-out is shown. Always make sure you have the right connections
for your encoder so you don't damage it!

 

===Pittman GM8224 motor with 19.5:1 gearhead and 500 line encoder===

[[image:pittman-small.jpg|right]]

If you need more power than the motor above, this gearmotor may be a good choice.
As an added bonus, it provides much higher encoder resolution.

'''Summary:'''
* 24 V, 4.33 ohms resistance, max current 5.54 Amps
* max torque: 2 Nm (approx)
* max speed: 500 RPM (approx)
* encoder: 9750 counts/rev at output shaft, 39,000 counts/rev in 4x decoding mode

 

This motor is also rated at 24 V, with a terminal resistance of 4.33 ohms,
giving a stall (maximum) current of 5.54 Amps. The stall torque of the motor
itself is 0.1186 Nm
and the no-load (maximum) speed is 10,158 RPM (1064 radians/sec). The
recommended maximum continuous torque is 0.0185 Nm which occurs at
8573 RPM (898 radians/sec). Taken together, the maximum motor mechanical power
is (1/2 Tmax) x (1/2 nmax) = 31.5 W and the maximum recommended continuous
mechanical power is 16.6 W. The maximum electrical input power occurs when
the motor is stalled (or starting) and is 24 V x 5.54 A = 133 W. If you
operate the motor at a smaller voltage V2, then multiply the currents, speeds,
and torques above by a factor V2/24 and the power by a factor of (V2/24)^2.

This motor has a 19.5:1 gearhead with a power conversion efficiency of 73%.
Ignoring the efficiency for the moment, the 19.5:1 gearbox means that this
actuator may be appropriate if our application calls for no more than a
maximum speed of 10,158 RPM / 19.5 = 521 RPM and a maximum torque of
0.1186 Nm x 19.5 = 2.3 Nm. In other words, the output shaft speed is similar
to the Maxon gearmotor above, but with about 10 times the torque.

This motor comes with a 500 line encoder attached to the motor shaft. The
encoder has output channels A+ and B+ (no index pulse). This means that
the encoder provides 500 x 19.5 = 9750 pulses per revolution of the output shaft.
In the 4x decoding mode, this gives 39,000 counts per revolution, or a resolution
of 360/39,000 = 0.00923 degrees.

We also have a limited number of Pittman GM8712 motors with a 19.5:1 gearhead
and 512 line encoder. These motors are also rated at 24V but have a higher
terminal resistance of 12.1 ohms, giving a maximum current of 24/12.1 = 1.99 Amps.
They have a maximum speed of 7847 RPM and maximum torque of 0.052 Nm before the
gearhead, or (ignoring gearhead efficiency) 402 RPM and 1.01 Nm after the
gearhead. This motor is less powerful and draws less current, which may
be appropriate for some applications.
The encoder provides 9984 pulses per revolution of the output shaft
of the gearhead, or 360/(4 x 9984) = 0.009 degrees resolution in 4x decoding mode.

See the [[Media:pittmangearmotor.pdf|data sheet]] for more detailed
information on these Pittman 8224 and 8712 gearmotors. The 8712 is not treated
explicitly, but is believed to be similar to the 8722.

The quadrature encoder has four wires: black (GND), red (+5V), and blue and yellow as
channels A and B.

===Faulhaber 1524E006S motor with 141:1 gearhead and HES164A magnetic quadrature encoder===

[[image:faulhaber.png|right]]

'''Summary:'''
* motor rated at 6V, 12 ohms resistance (motor: 1524E006S123, where 123 is a special order)
* 141:1 gearhead (gearhead: 15/5S141:1K832)
* max speed at 6V: approximately 80 RPM at gearhead output
* quadrature encoder with 1 line per motor revolution, or 141 x 4 = 564 counts/rev at output shaft in 4x decoding mode (encoder: HES164A)
 

This little motor is the right size, speed, and torque for small wheeled mobile robots.
Ours were bought surplus from [http://www.bgmicro.com bgmicro.com]. This
[http://www.robotroom.com/FaulhaberGearmotor.html page] by
David Cook has a lot of great information on this motor + gearhead + encoder combination.
More info can be found in this [[Media:faulhaber-datasheet.pdf|data sheet]] from Faulhaber,
though our exact model encoder and motor are not listed. The gearhead has a right-angle
drive at the output.

 

[[image:faulhaber-pinout.jpg|right]]

The pins on the connector are (see figure at right):

1. Motor + 
2. +5V (or similar) to power the encoder 
3. Encoder channel A 
4. Encoder channel B 
5. GND for the encoder 
6. Motor -

Encoder channels A and B can sink (connect to ground) up to probably 25mA like most Hall sensors. There is only a a weak pull-up resistor inside, perhaps 10K, so they can only source (connect to +5) about 2mA. If you find the logic high signal from the encoder channel is not close enough to +5, which can happen even due to loading by an LED, you may want to add an external pull-up resistor from each encoder channel to +5. 470ohms is a good choice.

 

[[image:faulhaber-wheel.jpg|right]]

These [http://www.solarbotics.com/products/gmpw/ wheels] can be used with the motor (with the
right-angle drive) if you drill out the center of the wheel with a 9/32" bit (approximately). Then you
should get a nice tight press-fit. We have some of these wheels in the lab. This press-fit is not
suitable for high-torque applications, though; the shaft may begin to slip.

 

===Globe motor with 187.68:1 gearhead and 500 line encoder===

[[image:globe-motor.jpg|right|400px]]

'''Summary:'''
* motor rated at 12V, 21 ohms resistance (0.57 A stall current)
* 187.68:1 gearhead for high torque and low speed
* max speed at 12V: approximately 17 RPM at gearhead output (no load speed, motor alone: approx 3000 RPM)
* torque constant (motor alone): approximately 34 mNm/A (or 281 V/RPM)
* stall torque: motor alone: 0.019 Nm; with gearhead 2.4 Nm (based on torque multiplier of 125, less than the 187 gear ratio due to efficiency losses)
* quadrature encoder with 500 lines per motor revolution, or 500 x 4 x 187.68 = 375,360 counts/rev at output shaft in 4x decoding mode (encoder: HEDS-5505 A04)
 

This small motor combines with a high resolution encoder and a high gear ratio gearbox to give a high torque, low speed actuator with high resolution position sensing (and velocity sensing by finite differencing). The stall torque for this gearmotor (at 12 V) is approximately the same as that for the Pittman GM8224 gearmotor (at 24 V), but the max speed for the PIttman gearmotor is 20 times higher. The pin-out for the encoder is shown below. You can attach to the encoder using a Samtec IDSS-05-D-12.00 cable (shown in the middle below; order directly from [http://www.samtec.com Samtec], about $3.50 each) or you can make your own cable using stranded wires (22 AWG or ribbon cable) crimped or soldered in female Molex terminal pins (Molex series KK 2759, part number WM1114CT-ND on digikey) in a Molex 5 position connector housing (Molex series KK 2695, part number WM1578-ND on digikey), shown at right below. (See [[Making a Molex Connector]] for more details.) The [[Media:HEDS5500-encoder.pdf|datasheet]] for the encoder recommends putting a 3.2k pull-up resistor on Channels A and B (i.e., 3.2k resistors from these lines to +5V). The encoder works without these, but the datasheet indicates that you get better rise times on the encoder signals at high speeds when the pull-up resistors are added.

[[image:globe-encoder-annotated.jpg|300px]]
[[image:globe-encoder-cable.jpg|200px]]
[[image:globe-encoder-cable-molex.jpg|200px]]

If you want a higher-speed (up to 3000 RPM at 12V) lower-torque actuator, you can try removing the gearbox. This task takes a bit of work and may require a bit of machining. See [[Accessing_Pinion_of_Globe_Motor|here]].

The two motor power leads are wound through a ferrite toroid to suppress EMI "noise."

Here you can find a [[Media:globe-cad.pdf|cad file]] describing this actuator, a [[Media:HEDS5500-encoder.pdf|datasheet]] for the encoder, and a [[Media:idss-connector.pdf|datasheet]] for the Samtec IDSS-05-D-12.00 connector.

 

===GM3 and GM9 Gearmotors===

[[image:GM3.png|right]]

'''Summary:''' (GM3 pictured at right)
* rated at 6V, approx 10 ohms resistance
* 224:1 gearhead (GM3) or 143:1 gearhead (GM9)
* max speed at 6V approximately 43 RPM (GM3) or 84 RPM (GM9)
* stall torque at 6V approximately 73 oz-in (GM3) or 52 oz-in (GM9)
* no encoder installed, but can be modified to add one; see [[Adding_a_magnetic_encoder_to_a_GM3_Gearmotor|here]]
* size: 70 x 22.5 x 37 mm
 

These highly-geared motors can be bought new at [http://www.solarbotics.com solarbotics.com] or [http://www.hobbyengineering.com hobbyengineering.com]. These motors work with these [http://www.solarbotics.com/products/gmpw/ wheels], which we have in
the lab. The motors do not come with encoders, but you can [[Adding_a_magnetic_encoder_to_a_GM3_Gearmotor|add one yourself]],
similar to the magnetic encoder on the Faulhaber motor above.

 

==Stepper Motors==

Stepper motors move in discrete steps. The controller energizes electromagnet
coils, and the motor's rotor rotates to the nearest equilibrium point. By
proper sequencing of which coils are energized, the motor rotates as desired
(and, if the rotation is fast enough, may simply pass through the equilibrium
points without stopping).

One nice thing about stepper motors is that they do not require
feedback; we know how far the motor has rotated, because we commanded
the motion. This becomes a problem if we try to rotate the motor too
fast, or if the load is larger than expected --- the motor may not
actually do what we commanded. Stepper motors are a
good choice for relatively low-torque applications where the loads
are consistent, so we can be assured our commanded motions are followed.

===Jameco 163395 8.4V bipolar stepper motor===

[[image:small-stepper.jpg|right]]

Although this motor is rated at 8.4V, it is possible
to run it at lower or slightly higher voltages.

* 1.8 deg/step (0.9 deg/half step)
* 8.4V, 2 phases, 30 ohms resistance, 280 mA current
* holding torque: 0.081 Nm (coils energized)
* detent torque: 0.0037 Nm (coils off)
* size: 1.64" motor diameter, 1.2" motor height
* shaft: 0.29" x 0.155" diameter
* mass: 0.24 kg

More information can be found on this
[[Media:jameco-stepper-163395.pdf|data sheet]].
There are four leads, two for each independent coil.

 

===Jameco 162026CX 12V unipolar stepper motor===

[[image:stepper-small.jpg|right]]

If you need more holding torque, this stepper may be a
good choice.

* 1.8 deg/step (0.9 deg/half step)
* 12V, 4 phases, 20 ohms resistance, 600 mA current
* holding torque: 0.588 Nm (coils energized)
* detent torque: 0.071 Nm (coils off)
* size: 2.2" motor diameter, 2.0" motor height
* shaft: 1" x 0.25" diameter
* mass: 0.65 kg

More information can be found on this
[[Media:jameco-stepper-162026.pdf|data sheet]] (ours is the
57BYG084). There are six leads, three for each independent
coil.

 

==RC Servo Motors==

RC servos are convenient for positioning applications that require
significant torque, not much speed, and only moderate positioning
precision. They take three connections, power (+5V, typically),
ground, and a pulsing signal that tells the motor the desired angle (typically a
pulse of 0.5 - 3 ms every 20 ms or so, where the duration of the pulse
indicates the desired angle of the motor).
Inside the motor is a potentiometer that senses the actual angle of
the motor output shaft and a feedback controller that tries to make
the motor angle match that specified by the pulsed signal. There is
also a large gear ratio such that the motor provides high torque at
low speed. Most RC servos have limited angle range, like 180 degrees,
due to the angle-sensing potentiometer.

===Futaba S3004 standard ball bearing RC servo motor===

[[image:RC-servo-small.jpg|right]]

* motor rotation: 180 degrees
* speed: 60 degrees in 0.23 sec at 4.8V, 0.19 sec at 6V
* torque: 0.31 Nm at 4.8V, 0.4 Nm at 6V
* size: 1.4" height, 0.8" width
* mass: 37.2 g

These were purchased from Tower Hobbies, part number LM1954.
Higher torque versions are also available.

 

==Solenoids==

Solenoids are simple on-off actuators consisting of a plunger moving in an
electromagnetic field. If you power the electromagnet, the plunger is
"pushed" or "pulled" a particular stroke length, and if you unpower the
coil, the plunger returns to its original position, usually by a return
spring or gravity. These are simple to control and useful for applications
where the actuator only has to take one of two positions.

We stock two solenoids (in addition to many random ones) which are basically
the same, except one is a "pull type" solenoid and the other is a "push type."

===Jameco 262262 (pull) and 262271 (push) 12V open frame solenoid===

[[image:solenoids-small.jpg|right]]

* 12 V, 36 ohm resistance, 333 mA
* holding force: 0.5 N
* stroke: 6 mm
* size: 1.5" length x 1.0" x 0.8" diameter
* shaft diameter: 0.310"
* mass: 96 g

You can find a data sheet [[Media:jameco-solenoid-262262.pdf|here]].
You can attach a lever (or other mechanical transformer) to the plunger to
get more stroke and less force, or more force and less stroke. If no lever
will meet your specs,
then you will need another solenoid.

==AC Motors==

[[image:ac-servo-small.jpg|right]]

Some projects need more power than any of the actuators above can
provide. In that case, you may be able to use a Yaskawa AC motor.
These are technically in the Laboratory for Intelligent Mechanical
Systems, but they are available for Mechatronics use. These should
not be a first choice, as (1) they can be dangerous due to their high
power, and (2) they limit the mobility of your project as they must be
plugged into the wall to get 110V AC. You can find information
on these motors and their amplifiers
[http://www.mech.northwestern.edu/courses/433/Writeups/YaskawaMotors/YakawaACservomotors.htm here].

Actuators Available in the Mechatronics Lab

2008-07-08T21:13:47Z

Matt Turpin: /* Globe motor with 187.68:1 gearhead and 500 line encoder */

[[image:all-actuators-captions-small.jpg|right]]

We have acquired a number of actuators that are appropriately sized for
many mechatronics projects. These are the "standard" lab actuators.
You are welcome to borrow them for your project and return them when
you are finished. In addition to the actuators mentioned below, we
have a number of other actuators that we have acquired over the years
that you are welcome to borrow.

For your particular project, it may be best to spec out and buy a
particular type and size of actuator. If your specifications are not
too critical, however, the actuators below will allow you to get
started right away.

__TOC__

 

==DC Motors (with gearheads and encoders)==

There are many types of DC motors, but our favorites are brushed
permanent magnet DC motors for their power, price, ubiquity, and
simplicity. Simply put a voltage across the two motor terminals, and
the motor spins. (You can learn about the
theory of how a brushed DC
motor works and suggested methods
for driving a DC motor elsewhere on this wiki.)

One problem is that most DC motors tend to rotate at very high speeds,
typically several thousand RPM or more. This is too fast for most
mechatronics applications. Also, they tend to have too little torque.
Both of these problems can be solved by the use of gears on the output
shaft of the motor. If the motor has an N:1 gearhead on its output
shaft (where N>1, typically), then the output shaft of the gearhead
reduces the speed of the motor by a factor of N and icreases the
torque of the motor by a factor of N. (You can learn more
about how gears work including other issues
they introduce, such as gearhead efficiency and backlash.)

Another issue is how to determine how far the motor has rotated. You need
''feedback'' from the motor. There are many ways to do this; see
here for information on using
encoders, potentiometers, and tachometers. The most common way to get angle
feedback is through the use of encoders. An encoder is typically attached
to a motor shaft and produces pulses that encode the shaft rotation angle.
These pulses can be read in by the encoder inputs of the Mechatronics Lab
PC/104 stacks.

So, perhaps the most versatile kind of actuator is a DC motor with a gearhead and an
encoder. Below are some that we keep in the lab. Sometimes DC motors
with gearheads and encoders can be purchased through surplus outlets at
great prices, for prices less than any of the single components (motor,
gearhead, encoder) could be purchased individually. That's how many
copies of the actuators below were purchased. If you see a great
deal on a nice-sized motor plus gearhead plus encoder, of which many
copies can be purchased, let us know!

===6W Maxon motor with 6:1 gearhead and 100 line encoder===

[[image:maxon-small2.jpg|right]]

'''Summary:'''
* 24 V, 41.5 ohms resistance, max current 0.58 Amps
* max torque: 0.15 Nm (approx)
* max speed: 600 RPM (approx)
* encoder: 600 counts/rev at output shaft, 2400 counts/rev in 4x decoding mode

 

The motor is rated at 24 volts, giving a no-load (maximum)
speed of 3990 RPM (about 418 radians/sec) and a (maximum) stall torque of 31.9 mNm (milli
Newton meters). The terminal resistance (the resistance through the
motor windings) is 41.5 ohms. This means if you put 24 V across it,
the maximum current that it will draw is 24/41.5 = 0.58 Amps. This
maximum current occurs when the motor is stalled and generating its
maximum torque. Motor torque is proportional to the motor current by
the constant of proportionality called the ''torque constant'',
which is different for every motor.

The motor is called a 6 Watt motor because that is the maximum
electrical power (current times voltage) that can be put into the
motor on a continuous basis. Beyond this power level, the amount of
power dissipated by the resistance of the motor windings will cause
the windings to heat up unacceptably. (It is fine to overpower the
motor intermittently, allowing the coils to cool so that the average
power does not exceed the rated power.) At this operating point,
the motor draws 244 mA, giving 24 V x 0.244 A = 5.86 W electrical input
power. At this operating point, the speed of the motor is approximately
1689 RPM, or 177 radians/sec, and the torque of the motor is 13.5 mNm,
giving 177 rad/sec x 0.0135 Nm = 2.39 W of mechanical output power,
giving a power-conversion efficiency of about 41% at this operating point.
The maximum efficiency of the motor is 70%, which occurs at a higher
speed and lower torque. The maximum mechanical power you can get out
of the motor is (1/2 max torque) x (1/2 max speed) = 3.33 W. This is
beyond the continuous operation recommendation, but it is fine to
run it for short periods at this operating point.

Often you will want to run the motor at lower voltages, for instance
at 12 V, instead of the rated 24 V. In this case just multiply the
max current, speed, and torques by the factor 12/24 = 1/2. In particular,
the maximum output power will be only (1/2) x (1/2) = 1/4 the maximum at 24 V.

This actuator comes with a 6:1 spur gearhead, which increases the
torque available at the gearhead's output shaft by a factor of 6 and
decreases the speed by a factor of 6. (In this ideal case, the
power at the gearhead's output shaft is equal to the power at the input.
In practice, gearheads have an efficiency also; the maximum
efficiency of the gearhead here is 81%. This reduces the torque
available.)

In summary, then, if your application requires no more than about 6 x
31.9 mNm = 0.19 Nm maximum torque, 3990 RPM / 6 = 665 RPM max speed,
and 3.3 W max mechanical power, this may be the motor for you.
Reduce those values by a factor of 1/2, 1/2, and 1/4, respectively, if
you are operating the motor with 12 V max instead of 24 V max.

This actuator also comes with 100 line single-ended incremental optical encoder,
with outputs A+ and B+. There is no index channel. The encoder is
attached to the motor. Each of the A+ and B+ channels makes 100 pulses
per revolution of the motor, or 6 x 100 = 600 pulses per revolution of
the output shaft of the gearhead. This means the encoder provides
360 deg / 600 pulses = 0.6 deg/pulse resolution when the pulses are
decoded with the 1x scheme, or 0.15 deg/pulse resolution with the 4x
decoding scheme.

Information about the Maxon motor is given in this [[Media:maxon-2140-specs.pdf|data sheet]] which includes
other motors in this family (ours is the 24V version)
and this [[Media:maxon-our-specific-motor.pdf|data sheet]] which gives only
the information on this motor. (Note the speed-torque curve is a bit misleading,
as it seems to imply the maximum speed of the motor is 6100 RPM, when it should
be 3990 RPM.) Information on the 6:1 gearhead can be found
[[Media:maxon-gearhead.pdf|here]]. The encoder pin-out is indicated below:

 

[[image:encoder-maxon.jpg|right]]

 

The encoder comes with a 4-connector ribbon cable, corresponding to GND, Channel A, Vcc (usually +5V), and Channel B, as
shown on the left. Here the ribbon cable is broken out into a 10-pin connector (which we have in the lab). The connector
above is made to work with the PC/104 stacks, and the pin-out is shown. Always make sure you have the right connections
for your encoder so you don't damage it!

 

===Pittman GM8224 motor with 19.5:1 gearhead and 500 line encoder===

[[image:pittman-small.jpg|right]]

If you need more power than the motor above, this gearmotor may be a good choice.
As an added bonus, it provides much higher encoder resolution.

'''Summary:'''
* 24 V, 4.33 ohms resistance, max current 5.54 Amps
* max torque: 2 Nm (approx)
* max speed: 500 RPM (approx)
* encoder: 9750 counts/rev at output shaft, 39,000 counts/rev in 4x decoding mode

 

This motor is also rated at 24 V, with a terminal resistance of 4.33 ohms,
giving a stall (maximum) current of 5.54 Amps. The stall torque of the motor
itself is 0.1186 Nm
and the no-load (maximum) speed is 10,158 RPM (1064 radians/sec). The
recommended maximum continuous torque is 0.0185 Nm which occurs at
8573 RPM (898 radians/sec). Taken together, the maximum motor mechanical power
is (1/2 Tmax) x (1/2 nmax) = 31.5 W and the maximum recommended continuous
mechanical power is 16.6 W. The maximum electrical input power occurs when
the motor is stalled (or starting) and is 24 V x 5.54 A = 133 W. If you
operate the motor at a smaller voltage V2, then multiply the currents, speeds,
and torques above by a factor V2/24 and the power by a factor of (V2/24)^2.

This motor has a 19.5:1 gearhead with a power conversion efficiency of 73%.
Ignoring the efficiency for the moment, the 19.5:1 gearbox means that this
actuator may be appropriate if our application calls for no more than a
maximum speed of 10,158 RPM / 19.5 = 521 RPM and a maximum torque of
0.1186 Nm x 19.5 = 2.3 Nm. In other words, the output shaft speed is similar
to the Maxon gearmotor above, but with about 10 times the torque.

This motor comes with a 500 line encoder attached to the motor shaft. The
encoder has output channels A+ and B+ (no index pulse). This means that
the encoder provides 500 x 19.5 = 9750 pulses per revolution of the output shaft.
In the 4x decoding mode, this gives 39,000 counts per revolution, or a resolution
of 360/39,000 = 0.00923 degrees.

We also have a limited number of Pittman GM8712 motors with a 19.5:1 gearhead
and 512 line encoder. These motors are also rated at 24V but have a higher
terminal resistance of 12.1 ohms, giving a maximum current of 24/12.1 = 1.99 Amps.
They have a maximum speed of 7847 RPM and maximum torque of 0.052 Nm before the
gearhead, or (ignoring gearhead efficiency) 402 RPM and 1.01 Nm after the
gearhead. This motor is less powerful and draws less current, which may
be appropriate for some applications.
The encoder provides 9984 pulses per revolution of the output shaft
of the gearhead, or 360/(4 x 9984) = 0.009 degrees resolution in 4x decoding mode.

See the [[Media:pittmangearmotor.pdf|data sheet]] for more detailed
information on these Pittman 8224 and 8712 gearmotors. The 8712 is not treated
explicitly, but is believed to be similar to the 8722.

The quadrature encoder has four wires: black (GND), red (+5V), and blue and yellow as
channels A and B.

===Faulhaber 1524E006S motor with 141:1 gearhead and HES164A magnetic quadrature encoder===

[[image:faulhaber.png|right]]

'''Summary:'''
* motor rated at 6V, 12 ohms resistance (motor: 1524E006S123, where 123 is a special order)
* 141:1 gearhead (gearhead: 15/5S141:1K832)
* max speed at 6V: approximately 80 RPM at gearhead output
* quadrature encoder with 1 line per motor revolution, or 141 x 4 = 564 counts/rev at output shaft in 4x decoding mode (encoder: HES164A)
 

This little motor is the right size, speed, and torque for small wheeled mobile robots.
Ours were bought surplus from [http://www.bgmicro.com bgmicro.com]. This
[http://www.robotroom.com/FaulhaberGearmotor.html page] by
David Cook has a lot of great information on this motor + gearhead + encoder combination.
More info can be found in this [[Media:faulhaber-datasheet.pdf|data sheet]] from Faulhaber,
though our exact model encoder and motor are not listed. The gearhead has a right-angle
drive at the output.

 

[[image:faulhaber-pinout.jpg|right]]

The pins on the connector are (see figure at right):

1. Motor + 
2. +5V (or similar) to power the encoder 
3. Encoder channel A 
4. Encoder channel B 
5. GND for the encoder 
6. Motor -

Encoder channels A and B can sink (connect to ground) up to probably 25mA like most Hall sensors. There is only a a weak pull-up resistor inside, perhaps 10K, so they can only source (connect to +5) about 2mA. If you find the logic high signal from the encoder channel is not close enough to +5, which can happen even due to loading by an LED, you may want to add an external pull-up resistor from each encoder channel to +5. 470ohms is a good choice.

 

[[image:faulhaber-wheel.jpg|right]]

These [http://www.solarbotics.com/products/gmpw/ wheels] can be used with the motor (with the
right-angle drive) if you drill out the center of the wheel with a 9/32" bit (approximately). Then you
should get a nice tight press-fit. We have some of these wheels in the lab. This press-fit is not
suitable for high-torque applications, though; the shaft may begin to slip.

 

===Globe motor with 187.68:1 gearhead and 500 line encoder===

[[image:globe-motor.jpg|right|400px]]

'''Summary:'''
* motor rated at 12V, 21 ohms resistance (0.57 A stall current)
* 187.68:1 gearhead for high torque and low speed
* max speed at 12V: approximately 17 RPM at gearhead output (no load speed, motor alone: approx 3000 RPM)
* torque constant (motor alone): approximately 34 mNm/A (or 281 V/RPM)
* stall torque: motor alone: 0.019 Nm; with gearhead 2.4 Nm (based on torque multiplier of 125, less than the 187 gear ratio due to efficiency losses)
* quadrature encoder with 500 lines per motor revolution, or 500 x 4 x 187.68 = 375,360 counts/rev at output shaft in 4x decoding mode (encoder: HEDS-5505 A04)
 

This small motor combines with a high resolution encoder and a high gear ratio gearbox to give a high torque, low speed actuator with high resolution position sensing (and velocity sensing by finite differencing). The stall torque for this gearmotor (at 12 V) is approximately the same as that for the Pittman GM8224 gearmotor (at 24 V), but the max speed for the PIttman gearmotor is 20 times higher. The pin-out for the encoder is shown below. You can attach to the encoder using a Samtec IDSS-05-D-12.00 cable (shown in the middle below; order directly from [http://www.samtec.com Samtec], about $3.50 each) or you can make your own cable using stranded wires (22 AWG or ribbon cable) crimped or soldered in female Molex terminal pins (Molex series KK 2759, part number WM1114CT-ND on digikey) in a Molex 5 position connector housing (Molex series KK 2695, part number WM1578-ND on digikey), shown at right below. (See [[Making a Molex Connector]] for more details.) The [[Media:HEDS5500-encoder.pdf|datasheet]] for the encoder recommends putting a 3.2k pull-up resistor on Channels A and B (i.e., 3.2k resistors from these lines to +5V). The encoder works without these, but the datasheet indicates that you get better rise times on the encoder signals at high speeds when the pull-up resistors are added.

[[image:globe-encoder-annotated.jpg|300px]]
[[image:globe-encoder-cable.jpg|200px]]
[[image:globe-encoder-cable-molex.jpg|200px]]

An inside peek at the gearbox is shown below. If you want a higher-speed (up to 3000 RPM at 12V) lower-torque actuator, you can try removing the gearbox. This task takes a bit of work and depending on what output you want, may require a bit of machining. See [[Accessing_Pinion_of_Globe_Motor|here]].

The two motor power leads are wound through a ferrite toroid to suppress EMI "noise."

Here you can find a [[Media:globe-cad.pdf|cad file]] describing this actuator, a [[Media:HEDS5500-encoder.pdf|datasheet]] for the encoder, and a [[Media:idss-connector.pdf|datasheet]] for the Samtec IDSS-05-D-12.00 connector.

 

===GM3 and GM9 Gearmotors===

[[image:GM3.png|right]]

'''Summary:''' (GM3 pictured at right)
* rated at 6V, approx 10 ohms resistance
* 224:1 gearhead (GM3) or 143:1 gearhead (GM9)
* max speed at 6V approximately 43 RPM (GM3) or 84 RPM (GM9)
* stall torque at 6V approximately 73 oz-in (GM3) or 52 oz-in (GM9)
* no encoder installed, but can be modified to add one; see [[Adding_a_magnetic_encoder_to_a_GM3_Gearmotor|here]]
* size: 70 x 22.5 x 37 mm
 

These highly-geared motors can be bought new at [http://www.solarbotics.com solarbotics.com] or [http://www.hobbyengineering.com hobbyengineering.com]. These motors work with these [http://www.solarbotics.com/products/gmpw/ wheels], which we have in
the lab. The motors do not come with encoders, but you can [[Adding_a_magnetic_encoder_to_a_GM3_Gearmotor|add one yourself]],
similar to the magnetic encoder on the Faulhaber motor above.

 

==Stepper Motors==

Stepper motors move in discrete steps. The controller energizes electromagnet
coils, and the motor's rotor rotates to the nearest equilibrium point. By
proper sequencing of which coils are energized, the motor rotates as desired
(and, if the rotation is fast enough, may simply pass through the equilibrium
points without stopping).

One nice thing about stepper motors is that they do not require
feedback; we know how far the motor has rotated, because we commanded
the motion. This becomes a problem if we try to rotate the motor too
fast, or if the load is larger than expected --- the motor may not
actually do what we commanded. Stepper motors are a
good choice for relatively low-torque applications where the loads
are consistent, so we can be assured our commanded motions are followed.

===Jameco 163395 8.4V bipolar stepper motor===

[[image:small-stepper.jpg|right]]

Although this motor is rated at 8.4V, it is possible
to run it at lower or slightly higher voltages.

* 1.8 deg/step (0.9 deg/half step)
* 8.4V, 2 phases, 30 ohms resistance, 280 mA current
* holding torque: 0.081 Nm (coils energized)
* detent torque: 0.0037 Nm (coils off)
* size: 1.64" motor diameter, 1.2" motor height
* shaft: 0.29" x 0.155" diameter
* mass: 0.24 kg

More information can be found on this
[[Media:jameco-stepper-163395.pdf|data sheet]].
There are four leads, two for each independent coil.

 

===Jameco 162026CX 12V unipolar stepper motor===

[[image:stepper-small.jpg|right]]

If you need more holding torque, this stepper may be a
good choice.

* 1.8 deg/step (0.9 deg/half step)
* 12V, 4 phases, 20 ohms resistance, 600 mA current
* holding torque: 0.588 Nm (coils energized)
* detent torque: 0.071 Nm (coils off)
* size: 2.2" motor diameter, 2.0" motor height
* shaft: 1" x 0.25" diameter
* mass: 0.65 kg

More information can be found on this
[[Media:jameco-stepper-162026.pdf|data sheet]] (ours is the
57BYG084). There are six leads, three for each independent
coil.

 

==RC Servo Motors==

RC servos are convenient for positioning applications that require
significant torque, not much speed, and only moderate positioning
precision. They take three connections, power (+5V, typically),
ground, and a pulsing signal that tells the motor the desired angle (typically a
pulse of 0.5 - 3 ms every 20 ms or so, where the duration of the pulse
indicates the desired angle of the motor).
Inside the motor is a potentiometer that senses the actual angle of
the motor output shaft and a feedback controller that tries to make
the motor angle match that specified by the pulsed signal. There is
also a large gear ratio such that the motor provides high torque at
low speed. Most RC servos have limited angle range, like 180 degrees,
due to the angle-sensing potentiometer.

===Futaba S3004 standard ball bearing RC servo motor===

[[image:RC-servo-small.jpg|right]]

* motor rotation: 180 degrees
* speed: 60 degrees in 0.23 sec at 4.8V, 0.19 sec at 6V
* torque: 0.31 Nm at 4.8V, 0.4 Nm at 6V
* size: 1.4" height, 0.8" width
* mass: 37.2 g

These were purchased from Tower Hobbies, part number LM1954.
Higher torque versions are also available.

 

==Solenoids==

Solenoids are simple on-off actuators consisting of a plunger moving in an
electromagnetic field. If you power the electromagnet, the plunger is
"pushed" or "pulled" a particular stroke length, and if you unpower the
coil, the plunger returns to its original position, usually by a return
spring or gravity. These are simple to control and useful for applications
where the actuator only has to take one of two positions.

We stock two solenoids (in addition to many random ones) which are basically
the same, except one is a "pull type" solenoid and the other is a "push type."

===Jameco 262262 (pull) and 262271 (push) 12V open frame solenoid===

[[image:solenoids-small.jpg|right]]

* 12 V, 36 ohm resistance, 333 mA
* holding force: 0.5 N
* stroke: 6 mm
* size: 1.5" length x 1.0" x 0.8" diameter
* shaft diameter: 0.310"
* mass: 96 g

You can find a data sheet [[Media:jameco-solenoid-262262.pdf|here]].
You can attach a lever (or other mechanical transformer) to the plunger to
get more stroke and less force, or more force and less stroke. If no lever
will meet your specs,
then you will need another solenoid.

==AC Motors==

[[image:ac-servo-small.jpg|right]]

Some projects need more power than any of the actuators above can
provide. In that case, you may be able to use a Yaskawa AC motor.
These are technically in the Laboratory for Intelligent Mechanical
Systems, but they are available for Mechatronics use. These should
not be a first choice, as (1) they can be dangerous due to their high
power, and (2) they limit the mobility of your project as they must be
plugged into the wall to get 110V AC. You can find information
on these motors and their amplifiers
[http://www.mech.northwestern.edu/courses/433/Writeups/YaskawaMotors/YakawaACservomotors.htm here].

File:Globe-machined-motor-head.jpg

2008-07-08T21:05:20Z

Matt Turpin: A machined motor head. This can be achieved through milling or interrupted turning of the top part of the motor.

A machined motor head. This can be achieved through milling or interrupted turning of the top part of the motor.

Accessing Pinion of Globe Motor

2008-07-08T21:04:43Z

Matt Turpin:

The Globe motor we have in stock can be modified to be high speed and low torque with a few adjustments.

It is easy to do until the disassembled photo below. Simply unscrew the three long screws and pull off the top of the gearbox, along with the output shaft of the gearbox. Now you can see two shafts holding the stacks of gears actually implementing the reduction ratio. Using a pair of pliers, pull off the spacers near the tops of these shafts (these are press-fitted onto the shafts). Now the gears slide off the shafts. (Actually, when I tried it, one shaft came out with the spacer, while the other shaft remained in place and only the spacer came off.) The photo below shows the new state of the gearbox. '''Be careful not to manhandle the encoder when you apply large forces pulling off the spacers!''' You could damage the encoder.

[[image:globe-gearbox-annotated.jpg|300px]]
[[image:globe-nogearhead.jpg|300px]]

The rest of the gearbox is held in place by two long screws that run the full length from the back of the motor. These screws cannot be removed without removing the encoder. Therefore, if you want to better expose the motor's output shaft without entirely disassembling the motor, you can use a band saw to cut off the nearby posts (or to cut off the entire gearhead from the lip up) and to destroy and remove the pinion gear on the motor output shaft.

The more involved but safer method to access the pinion or output shaft is to disassemble to motor. To do this, use a small screwdriver to rotate the internal mechanism in the encoder. See the picture below.

[[image:globe-scredriver-inserted.jpg|300px]]
[[image:globe-hex-wrench-inserted.jpg|300px]]

Rotate this as far as it will go until the one dot lines up with the one dot on the outside of the encoder. This will line up a slot of the side of the encoder which a 0.035" hex wrench can be inserted into. While applying a bit of pressure to the wrench, turn the pinion until the hex wrench fits into a set screw. Unscrew this set screw a couple of turns and then pull gently on the encoder. This will get to the following image:

[[image:globe-encoder-removed.jpg|300px]]

Now unscrew the two exposed screws and then you will have access to the two bolts holding the motor together. Unscrew these and the top portion of the motor can now be removed. The best way to expose the pinion is to mill the top section of the motor to be much lower. See the following photos for results. Assemble the motor in reverse order, ensuring the set screw is tightened sufficiently.

[[image:globe-dissassembled.jpg|300px]]
[[image:globe-machined-motor-head.jpg|300px]]
[[image:globe-exposed-pinion.jpg|300px]]

Accessing Pinion of Globe Motor

2008-07-08T21:04:09Z

Matt Turpin:

The Globe motor we have in stock can be modified to be high speed and low torque with a few adjustments.

It is easy to do until the disassembled photo below. Simply unscrew the three long screws and pull off the top of the gearbox, along with the output shaft of the gearbox. Now you can see two shafts holding the stacks of gears actually implementing the reduction ratio. Using a pair of pliers, pull off the spacers near the tops of these shafts (these are press-fitted onto the shafts). Now the gears slide off the shafts. (Actually, when I tried it, one shaft came out with the spacer, while the other shaft remained in place and only the spacer came off.) The photo below shows the new state of the gearbox. '''Be careful not to manhandle the encoder when you apply large forces pulling off the spacers!''' You could damage the encoder.

[[image:globe-gearbox-annotated.jpg|300px]]
[[image:globe-nogearhead.jpg|300px]]

The rest of the gearbox is held in place by two long screws that run the full length from the back of the motor. These screws cannot be removed without removing the encoder. Therefore, if you want to better expose the motor's output shaft without entirely disassembling the motor, you can use a band saw to cut off the nearby posts (or to cut off the entire gearhead from the lip up) and to destroy and remove the pinion gear on the motor output shaft.

The more involved but safer method to access the pinion or output shaft is to disassemble to motor. To do this, use a small screwdriver to rotate the internal mechanism in the encoder. See the picture below.

[[image:globe-scredriver-inserted.jpg|300px]]
[[image:globe-hex-wrench-inserted.jpg|300px]]

Rotate this as far as it will go until the one dot lines up with the one dot on the outside of the encoder. This will line up a slot of the side of the encoder which a 0.035" hex wrench can be inserted into. While applying a bit of pressure to the wrench, turn the pinion until the hex wrench fits into a set screw. Unscrew this set screw a couple of turns and then pull gently on the encoder. This will get to the following image:

[[image:globe-encoder-removed.jpg|300px]]

Now unscrew the two exposed screws and then you will have access to the two bolts holding the motor together. Unscrew these and the top portion of the motor can now be removed. The best way to expose the pinion is to mill the top section of the motor to be much lower. See the following photos for results. Assemble the motor in reverse order, ensuring the set screw is tightened sufficiently.

[[image:globe-dissassembled.jpg|300px]]
[[image:globe-machined-encoder-head.jpg|300px]]
[[image:globe-exposed-pinion.jpg|300px]]

File:Globe-exposed-pinion.jpg

2008-07-08T21:03:03Z

Matt Turpin: Example of a final exposed pinion.

Example of a final exposed pinion.

File:Globe-dissassembled.jpg

2008-07-08T21:00:31Z

Matt Turpin: Disassembled Globe motor.

Disassembled Globe motor.

File:Globe-encoder-removed.jpg

2008-07-08T20:59:48Z

Matt Turpin: Image of the Globe motor with the encoder removed.

Image of the Globe motor with the encoder removed.

File:Globe-scredriver-inserted.jpg

2008-07-08T20:57:31Z

Matt Turpin: Insert a small screwdriver into the slot as shown and rotate until the dots line up.

Insert a small screwdriver into the slot as shown and rotate until the dots line up.

File:Globe-hex-wrench-inserted.jpg

2008-07-08T20:51:48Z

Matt Turpin: Insert the 0.035 inch hex wrench into the newly exposed slot and turn the pinion until the wrench is inserted into a set screw holding on the encoder wheel.

Insert the 0.035 inch hex wrench into the newly exposed slot and turn the pinion until the wrench is inserted into a set screw holding on the encoder wheel.

Accessing Pinion of Globe Motor

2008-07-08T20:49:02Z

Matt Turpin:

Actuators Available in the Mechatronics Lab

2008-07-08T20:48:23Z

Matt Turpin: /* Globe motor with 187.68:1 gearhead and 500 line encoder */

[[image:all-actuators-captions-small.jpg|right]]

We have acquired a number of actuators that are appropriately sized for
many mechatronics projects. These are the "standard" lab actuators.
You are welcome to borrow them for your project and return them when
you are finished. In addition to the actuators mentioned below, we
have a number of other actuators that we have acquired over the years
that you are welcome to borrow.

For your particular project, it may be best to spec out and buy a
particular type and size of actuator. If your specifications are not
too critical, however, the actuators below will allow you to get
started right away.

__TOC__

 

==DC Motors (with gearheads and encoders)==

There are many types of DC motors, but our favorites are brushed
permanent magnet DC motors for their power, price, ubiquity, and
simplicity. Simply put a voltage across the two motor terminals, and
the motor spins. (You can learn about the
theory of how a brushed DC
motor works and suggested methods
for driving a DC motor elsewhere on this wiki.)

One problem is that most DC motors tend to rotate at very high speeds,
typically several thousand RPM or more. This is too fast for most
mechatronics applications. Also, they tend to have too little torque.
Both of these problems can be solved by the use of gears on the output
shaft of the motor. If the motor has an N:1 gearhead on its output
shaft (where N>1, typically), then the output shaft of the gearhead
reduces the speed of the motor by a factor of N and icreases the
torque of the motor by a factor of N. (You can learn more
about how gears work including other issues
they introduce, such as gearhead efficiency and backlash.)

Another issue is how to determine how far the motor has rotated. You need
''feedback'' from the motor. There are many ways to do this; see
here for information on using
encoders, potentiometers, and tachometers. The most common way to get angle
feedback is through the use of encoders. An encoder is typically attached
to a motor shaft and produces pulses that encode the shaft rotation angle.
These pulses can be read in by the encoder inputs of the Mechatronics Lab
PC/104 stacks.

So, perhaps the most versatile kind of actuator is a DC motor with a gearhead and an
encoder. Below are some that we keep in the lab. Sometimes DC motors
with gearheads and encoders can be purchased through surplus outlets at
great prices, for prices less than any of the single components (motor,
gearhead, encoder) could be purchased individually. That's how many
copies of the actuators below were purchased. If you see a great
deal on a nice-sized motor plus gearhead plus encoder, of which many
copies can be purchased, let us know!

===6W Maxon motor with 6:1 gearhead and 100 line encoder===

[[image:maxon-small2.jpg|right]]

'''Summary:'''
* 24 V, 41.5 ohms resistance, max current 0.58 Amps
* max torque: 0.15 Nm (approx)
* max speed: 600 RPM (approx)
* encoder: 600 counts/rev at output shaft, 2400 counts/rev in 4x decoding mode

 

The motor is rated at 24 volts, giving a no-load (maximum)
speed of 3990 RPM (about 418 radians/sec) and a (maximum) stall torque of 31.9 mNm (milli
Newton meters). The terminal resistance (the resistance through the
motor windings) is 41.5 ohms. This means if you put 24 V across it,
the maximum current that it will draw is 24/41.5 = 0.58 Amps. This
maximum current occurs when the motor is stalled and generating its
maximum torque. Motor torque is proportional to the motor current by
the constant of proportionality called the ''torque constant'',
which is different for every motor.

The motor is called a 6 Watt motor because that is the maximum
electrical power (current times voltage) that can be put into the
motor on a continuous basis. Beyond this power level, the amount of
power dissipated by the resistance of the motor windings will cause
the windings to heat up unacceptably. (It is fine to overpower the
motor intermittently, allowing the coils to cool so that the average
power does not exceed the rated power.) At this operating point,
the motor draws 244 mA, giving 24 V x 0.244 A = 5.86 W electrical input
power. At this operating point, the speed of the motor is approximately
1689 RPM, or 177 radians/sec, and the torque of the motor is 13.5 mNm,
giving 177 rad/sec x 0.0135 Nm = 2.39 W of mechanical output power,
giving a power-conversion efficiency of about 41% at this operating point.
The maximum efficiency of the motor is 70%, which occurs at a higher
speed and lower torque. The maximum mechanical power you can get out
of the motor is (1/2 max torque) x (1/2 max speed) = 3.33 W. This is
beyond the continuous operation recommendation, but it is fine to
run it for short periods at this operating point.

Often you will want to run the motor at lower voltages, for instance
at 12 V, instead of the rated 24 V. In this case just multiply the
max current, speed, and torques by the factor 12/24 = 1/2. In particular,
the maximum output power will be only (1/2) x (1/2) = 1/4 the maximum at 24 V.

This actuator comes with a 6:1 spur gearhead, which increases the
torque available at the gearhead's output shaft by a factor of 6 and
decreases the speed by a factor of 6. (In this ideal case, the
power at the gearhead's output shaft is equal to the power at the input.
In practice, gearheads have an efficiency also; the maximum
efficiency of the gearhead here is 81%. This reduces the torque
available.)

In summary, then, if your application requires no more than about 6 x
31.9 mNm = 0.19 Nm maximum torque, 3990 RPM / 6 = 665 RPM max speed,
and 3.3 W max mechanical power, this may be the motor for you.
Reduce those values by a factor of 1/2, 1/2, and 1/4, respectively, if
you are operating the motor with 12 V max instead of 24 V max.

This actuator also comes with 100 line single-ended incremental optical encoder,
with outputs A+ and B+. There is no index channel. The encoder is
attached to the motor. Each of the A+ and B+ channels makes 100 pulses
per revolution of the motor, or 6 x 100 = 600 pulses per revolution of
the output shaft of the gearhead. This means the encoder provides
360 deg / 600 pulses = 0.6 deg/pulse resolution when the pulses are
decoded with the 1x scheme, or 0.15 deg/pulse resolution with the 4x
decoding scheme.

Information about the Maxon motor is given in this [[Media:maxon-2140-specs.pdf|data sheet]] which includes
other motors in this family (ours is the 24V version)
and this [[Media:maxon-our-specific-motor.pdf|data sheet]] which gives only
the information on this motor. (Note the speed-torque curve is a bit misleading,
as it seems to imply the maximum speed of the motor is 6100 RPM, when it should
be 3990 RPM.) Information on the 6:1 gearhead can be found
[[Media:maxon-gearhead.pdf|here]]. The encoder pin-out is indicated below:

 

[[image:encoder-maxon.jpg|right]]

 

The encoder comes with a 4-connector ribbon cable, corresponding to GND, Channel A, Vcc (usually +5V), and Channel B, as
shown on the left. Here the ribbon cable is broken out into a 10-pin connector (which we have in the lab). The connector
above is made to work with the PC/104 stacks, and the pin-out is shown. Always make sure you have the right connections
for your encoder so you don't damage it!

 

===Pittman GM8224 motor with 19.5:1 gearhead and 500 line encoder===

[[image:pittman-small.jpg|right]]

If you need more power than the motor above, this gearmotor may be a good choice.
As an added bonus, it provides much higher encoder resolution.

'''Summary:'''
* 24 V, 4.33 ohms resistance, max current 5.54 Amps
* max torque: 2 Nm (approx)
* max speed: 500 RPM (approx)
* encoder: 9750 counts/rev at output shaft, 39,000 counts/rev in 4x decoding mode

 

This motor is also rated at 24 V, with a terminal resistance of 4.33 ohms,
giving a stall (maximum) current of 5.54 Amps. The stall torque of the motor
itself is 0.1186 Nm
and the no-load (maximum) speed is 10,158 RPM (1064 radians/sec). The
recommended maximum continuous torque is 0.0185 Nm which occurs at
8573 RPM (898 radians/sec). Taken together, the maximum motor mechanical power
is (1/2 Tmax) x (1/2 nmax) = 31.5 W and the maximum recommended continuous
mechanical power is 16.6 W. The maximum electrical input power occurs when
the motor is stalled (or starting) and is 24 V x 5.54 A = 133 W. If you
operate the motor at a smaller voltage V2, then multiply the currents, speeds,
and torques above by a factor V2/24 and the power by a factor of (V2/24)^2.

This motor has a 19.5:1 gearhead with a power conversion efficiency of 73%.
Ignoring the efficiency for the moment, the 19.5:1 gearbox means that this
actuator may be appropriate if our application calls for no more than a
maximum speed of 10,158 RPM / 19.5 = 521 RPM and a maximum torque of
0.1186 Nm x 19.5 = 2.3 Nm. In other words, the output shaft speed is similar
to the Maxon gearmotor above, but with about 10 times the torque.

This motor comes with a 500 line encoder attached to the motor shaft. The
encoder has output channels A+ and B+ (no index pulse). This means that
the encoder provides 500 x 19.5 = 9750 pulses per revolution of the output shaft.
In the 4x decoding mode, this gives 39,000 counts per revolution, or a resolution
of 360/39,000 = 0.00923 degrees.

We also have a limited number of Pittman GM8712 motors with a 19.5:1 gearhead
and 512 line encoder. These motors are also rated at 24V but have a higher
terminal resistance of 12.1 ohms, giving a maximum current of 24/12.1 = 1.99 Amps.
They have a maximum speed of 7847 RPM and maximum torque of 0.052 Nm before the
gearhead, or (ignoring gearhead efficiency) 402 RPM and 1.01 Nm after the
gearhead. This motor is less powerful and draws less current, which may
be appropriate for some applications.
The encoder provides 9984 pulses per revolution of the output shaft
of the gearhead, or 360/(4 x 9984) = 0.009 degrees resolution in 4x decoding mode.

See the [[Media:pittmangearmotor.pdf|data sheet]] for more detailed
information on these Pittman 8224 and 8712 gearmotors. The 8712 is not treated
explicitly, but is believed to be similar to the 8722.

The quadrature encoder has four wires: black (GND), red (+5V), and blue and yellow as
channels A and B.

===Faulhaber 1524E006S motor with 141:1 gearhead and HES164A magnetic quadrature encoder===

[[image:faulhaber.png|right]]

'''Summary:'''
* motor rated at 6V, 12 ohms resistance (motor: 1524E006S123, where 123 is a special order)
* 141:1 gearhead (gearhead: 15/5S141:1K832)
* max speed at 6V: approximately 80 RPM at gearhead output
* quadrature encoder with 1 line per motor revolution, or 141 x 4 = 564 counts/rev at output shaft in 4x decoding mode (encoder: HES164A)
 

This little motor is the right size, speed, and torque for small wheeled mobile robots.
Ours were bought surplus from [http://www.bgmicro.com bgmicro.com]. This
[http://www.robotroom.com/FaulhaberGearmotor.html page] by
David Cook has a lot of great information on this motor + gearhead + encoder combination.
More info can be found in this [[Media:faulhaber-datasheet.pdf|data sheet]] from Faulhaber,
though our exact model encoder and motor are not listed. The gearhead has a right-angle
drive at the output.

 

[[image:faulhaber-pinout.jpg|right]]

The pins on the connector are (see figure at right):

1. Motor + 
2. +5V (or similar) to power the encoder 
3. Encoder channel A 
4. Encoder channel B 
5. GND for the encoder 
6. Motor -

Encoder channels A and B can sink (connect to ground) up to probably 25mA like most Hall sensors. There is only a a weak pull-up resistor inside, perhaps 10K, so they can only source (connect to +5) about 2mA. If you find the logic high signal from the encoder channel is not close enough to +5, which can happen even due to loading by an LED, you may want to add an external pull-up resistor from each encoder channel to +5. 470ohms is a good choice.

 

[[image:faulhaber-wheel.jpg|right]]

These [http://www.solarbotics.com/products/gmpw/ wheels] can be used with the motor (with the
right-angle drive) if you drill out the center of the wheel with a 9/32" bit (approximately). Then you
should get a nice tight press-fit. We have some of these wheels in the lab. This press-fit is not
suitable for high-torque applications, though; the shaft may begin to slip.

 

===Globe motor with 187.68:1 gearhead and 500 line encoder===

[[image:globe-motor.jpg|right|400px]]

'''Summary:'''
* motor rated at 12V, 21 ohms resistance (0.57 A stall current)
* 187.68:1 gearhead for high torque and low speed
* max speed at 12V: approximately 17 RPM at gearhead output (no load speed, motor alone: approx 3000 RPM)
* torque constant (motor alone): approximately 34 mNm/A (or 281 V/RPM)
* stall torque: motor alone: 0.019 Nm; with gearhead 2.4 Nm (based on torque multiplier of 125, less than the 187 gear ratio due to efficiency losses)
* quadrature encoder with 500 lines per motor revolution, or 500 x 4 x 187.68 = 375,360 counts/rev at output shaft in 4x decoding mode (encoder: HEDS-5505 A04)
 

This small motor combines with a high resolution encoder and a high gear ratio gearbox to give a high torque, low speed actuator with high resolution position sensing (and velocity sensing by finite differencing). The stall torque for this gearmotor (at 12 V) is approximately the same as that for the Pittman GM8224 gearmotor (at 24 V), but the max speed for the PIttman gearmotor is 20 times higher. The pin-out for the encoder is shown below. You can attach to the encoder using a Samtec IDSS-05-D-12.00 cable (shown in the middle below; order directly from [http://www.samtec.com Samtec], about $3.50 each) or you can make your own cable using stranded wires (22 AWG or ribbon cable) crimped or soldered in female Molex terminal pins (Molex series KK 2759, part number WM1114CT-ND on digikey) in a Molex 5 position connector housing (Molex series KK 2695, part number WM1578-ND on digikey), shown at right below. (See [[Making a Molex Connector]] for more details.) The [[Media:HEDS5500-encoder.pdf|datasheet]] for the encoder recommends putting a 3.2k pull-up resistor on Channels A and B (i.e., 3.2k resistors from these lines to +5V). The encoder works without these, but the datasheet indicates that you get better rise times on the encoder signals at high speeds when the pull-up resistors are added.

[[image:globe-encoder-annotated.jpg|300px]]
[[image:globe-encoder-cable.jpg|200px]]
[[image:globe-encoder-cable-molex.jpg|200px]]

An inside peek at the gearbox is shown below. If you want a higher-speed (up to 3000 RPM at 12V) lower-torque actuator, you can try removing the gearbox. This task takes a bit of work and depending on what output you want, may require a bit of machining. See [[Accessing_Pinion_of_Globe_Motor|here]].

The Globe motor we have in stock can be modified to be high speed and low torque with a few adjustments.

It is easy to do until the disassembled photo below. Simply unscrew the three long screws and pull off the top of the gearbox, along with the output shaft of the gearbox. Now you can see two shafts holding the stacks of gears actually implementing the reduction ratio. Using a pair of pliers, pull off the spacers near the tops of these shafts (these are press-fitted onto the shafts). Now the gears slide off the shafts. (Actually, when I tried it, one shaft came out with the spacer, while the other shaft remained in place and only the spacer came off.) The photo below shows the new state of the gearbox. '''Be careful not to manhandle the encoder when you apply large forces pulling off the spacers!''' You could damage the encoder.

[[image:globe-gearbox-annotated.jpg|300px]]
[[image:globe-nogearhead.jpg|300px]]

The rest of the gearbox is held in place by two long screws that run the full length from the back of the motor. These screws cannot be removed without removing the encoder. Therefore, if you want to better expose the motor's output shaft without entirely disassembling the motor, you can use a band saw to cut off the nearby posts (or to cut off the entire gearhead from the lip up) and to destroy and remove the pinion gear on the motor output shaft.

The more involved but safer method to access the pinion or output shaft is to disassemble to motor. To do this, use a small screwdriver to rotate the internal mechanism in the encoder. See the picture below.

[[image:globe-scredriver-inserted.jpg|300px]]
[[image:globe-hex-wrench-inserted.jpg|300px]]

Rotate this as far as it will go until the one dot lines up with the one dot on the outside of the encoder. This will line up a slot of the side of the encoder which a 0.035" hex wrench can be inserted into. While applying a bit of pressure to the wrench, turn the pinion until the hex wrench fits into a set screw. Unscrew this set screw a couple of turns and then pull gently on the encoder. This will get to the following image:

[[image:globe-encoder-removed.jpg|300px]]

Now unscrew the two exposed screws and then you will have access to the two bolts holding the motor together. Unscrew these and the top portion of the motor can now be removed. The best way to expose the pinion is to mill the top section of the motor to be much lower. See the following photos for results. Assemble the motor in reverse order, ensuring the set screw is tightened sufficiently.

[[image:globe-dissassembled.jpg|300px]]
[[image:globe-exposed-pinion.jpg|300px]]

The two motor power leads are wound through a ferrite toroid to suppress EMI "noise."

Here you can find a [[Media:globe-cad.pdf|cad file]] describing this actuator, a [[Media:HEDS5500-encoder.pdf|datasheet]] for the encoder, and a [[Media:idss-connector.pdf|datasheet]] for the Samtec IDSS-05-D-12.00 connector.

 

===GM3 and GM9 Gearmotors===

[[image:GM3.png|right]]

'''Summary:''' (GM3 pictured at right)
* rated at 6V, approx 10 ohms resistance
* 224:1 gearhead (GM3) or 143:1 gearhead (GM9)
* max speed at 6V approximately 43 RPM (GM3) or 84 RPM (GM9)
* stall torque at 6V approximately 73 oz-in (GM3) or 52 oz-in (GM9)
* no encoder installed, but can be modified to add one; see [[Adding_a_magnetic_encoder_to_a_GM3_Gearmotor|here]]
* size: 70 x 22.5 x 37 mm
 

These highly-geared motors can be bought new at [http://www.solarbotics.com solarbotics.com] or [http://www.hobbyengineering.com hobbyengineering.com]. These motors work with these [http://www.solarbotics.com/products/gmpw/ wheels], which we have in
the lab. The motors do not come with encoders, but you can [[Adding_a_magnetic_encoder_to_a_GM3_Gearmotor|add one yourself]],
similar to the magnetic encoder on the Faulhaber motor above.

 

==Stepper Motors==

Stepper motors move in discrete steps. The controller energizes electromagnet
coils, and the motor's rotor rotates to the nearest equilibrium point. By
proper sequencing of which coils are energized, the motor rotates as desired
(and, if the rotation is fast enough, may simply pass through the equilibrium
points without stopping).

One nice thing about stepper motors is that they do not require
feedback; we know how far the motor has rotated, because we commanded
the motion. This becomes a problem if we try to rotate the motor too
fast, or if the load is larger than expected --- the motor may not
actually do what we commanded. Stepper motors are a
good choice for relatively low-torque applications where the loads
are consistent, so we can be assured our commanded motions are followed.

===Jameco 163395 8.4V bipolar stepper motor===

[[image:small-stepper.jpg|right]]

Although this motor is rated at 8.4V, it is possible
to run it at lower or slightly higher voltages.

* 1.8 deg/step (0.9 deg/half step)
* 8.4V, 2 phases, 30 ohms resistance, 280 mA current
* holding torque: 0.081 Nm (coils energized)
* detent torque: 0.0037 Nm (coils off)
* size: 1.64" motor diameter, 1.2" motor height
* shaft: 0.29" x 0.155" diameter
* mass: 0.24 kg

More information can be found on this
[[Media:jameco-stepper-163395.pdf|data sheet]].
There are four leads, two for each independent coil.

 

===Jameco 162026CX 12V unipolar stepper motor===

[[image:stepper-small.jpg|right]]

If you need more holding torque, this stepper may be a
good choice.

* 1.8 deg/step (0.9 deg/half step)
* 12V, 4 phases, 20 ohms resistance, 600 mA current
* holding torque: 0.588 Nm (coils energized)
* detent torque: 0.071 Nm (coils off)
* size: 2.2" motor diameter, 2.0" motor height
* shaft: 1" x 0.25" diameter
* mass: 0.65 kg

More information can be found on this
[[Media:jameco-stepper-162026.pdf|data sheet]] (ours is the
57BYG084). There are six leads, three for each independent
coil.

 

==RC Servo Motors==

RC servos are convenient for positioning applications that require
significant torque, not much speed, and only moderate positioning
precision. They take three connections, power (+5V, typically),
ground, and a pulsing signal that tells the motor the desired angle (typically a
pulse of 0.5 - 3 ms every 20 ms or so, where the duration of the pulse
indicates the desired angle of the motor).
Inside the motor is a potentiometer that senses the actual angle of
the motor output shaft and a feedback controller that tries to make
the motor angle match that specified by the pulsed signal. There is
also a large gear ratio such that the motor provides high torque at
low speed. Most RC servos have limited angle range, like 180 degrees,
due to the angle-sensing potentiometer.

===Futaba S3004 standard ball bearing RC servo motor===

[[image:RC-servo-small.jpg|right]]

* motor rotation: 180 degrees
* speed: 60 degrees in 0.23 sec at 4.8V, 0.19 sec at 6V
* torque: 0.31 Nm at 4.8V, 0.4 Nm at 6V
* size: 1.4" height, 0.8" width
* mass: 37.2 g

These were purchased from Tower Hobbies, part number LM1954.
Higher torque versions are also available.

 

==Solenoids==

Solenoids are simple on-off actuators consisting of a plunger moving in an
electromagnetic field. If you power the electromagnet, the plunger is
"pushed" or "pulled" a particular stroke length, and if you unpower the
coil, the plunger returns to its original position, usually by a return
spring or gravity. These are simple to control and useful for applications
where the actuator only has to take one of two positions.

We stock two solenoids (in addition to many random ones) which are basically
the same, except one is a "pull type" solenoid and the other is a "push type."

===Jameco 262262 (pull) and 262271 (push) 12V open frame solenoid===

[[image:solenoids-small.jpg|right]]

* 12 V, 36 ohm resistance, 333 mA
* holding force: 0.5 N
* stroke: 6 mm
* size: 1.5" length x 1.0" x 0.8" diameter
* shaft diameter: 0.310"
* mass: 96 g

You can find a data sheet [[Media:jameco-solenoid-262262.pdf|here]].
You can attach a lever (or other mechanical transformer) to the plunger to
get more stroke and less force, or more force and less stroke. If no lever
will meet your specs,
then you will need another solenoid.

==AC Motors==

[[image:ac-servo-small.jpg|right]]

Some projects need more power than any of the actuators above can
provide. In that case, you may be able to use a Yaskawa AC motor.
These are technically in the Laboratory for Intelligent Mechanical
Systems, but they are available for Mechatronics use. These should
not be a first choice, as (1) they can be dangerous due to their high
power, and (2) they limit the mobility of your project as they must be
plugged into the wall to get 110V AC. You can find information
on these motors and their amplifiers
[http://www.mech.northwestern.edu/courses/433/Writeups/YaskawaMotors/YakawaACservomotors.htm here].

IR Tracker

2008-03-20T17:44:22Z

Matt Turpin: /* Problems Encountered */

[[image:IR_Tracker_Header.jpg|400px|right]]

==Team Members==

[[Image:IR_Tracker_Team.jpg|right|Left to right: Matt, Mark and Alice|thumb|300px]]

* Mark Straccia (Mechanical Engineering, Class of 2009)
* Matt Turpin (Mechanical Engineering, Class of 2009)
* Alice Zhao (Electrical Engineering, Class of 2008)

 

==Overview==

The goal of this project was to create a device that would follow a moving infrared light. The IR Tracker does this by continuously detecting the position of an infrared emitter in two axises, and then tracking the emitter with a laser.

The IR Tracker follows two major steps: (1) Identify the position of the IR emitter (2) Rotate the device to align itself with the IR emitter.

# The IR Tracker finds the location of the maximum infrared intensity in both the x-axis and y-axis. Two encoders continuously record the position of the IR emitter based on intensity levels detected by two IT detectors.
# Given the information about the location of the IR emitter, the device rotates itself in two dimensions to adjusts its plane to be normal to the IR emitter. At this point, the laser should point to the IR emitter.

We will discuss the mechanical design, electrical design, PIC code, resulting project and our team reflections.

==Mechanical Design==

===Primary Components===

The primary components used in this device are:

* 2 Pitman Motors
* 2 RC Servos
* 1 Turntable (6031K17, McMaster-Carr, $2.20, readily available)
* 1 Cylindrical Bearing
* 1 Laser
* Mirror
* Plexiglas

[[image:Mechanical_Design.jpg|center|Mechanical Design|700px]]

 

[[image:Detecting_Component.jpg|right|Detecting Component|thumb|300px]]

===Detecting Component===
On the main plane of the device, two encoders are placed perpendicular to each other (able to track on two axises). Mirrors are placed on the output shafts of the two encoders at 45 degree angles. Two infrared detectors are placed in line with the encoders. While the encoders are constantly spinning, the mirrors detect light from the IR emitter and bounce the light to the IR detectors.

 

[[image:Rotating_Component.jpg|right|Rotating Component|thumb|300px]]

===Rotating Component===
Below the main plane of the device, two servos are used to rotate the entire device to align the main plane to be normal to the emitter. The main plane is attached to a block of Plexiglas that surrounds a cylindrical bearing. This bearing allows the main plane to rotate along the y-axis. This block of Plexiglas is mounted on a turntable which allows the main plane to rotate along the x-axis.

 

==Electrical Design==

===Primary Components===

The primary components used in this circuit are:

* 1 PIC (18F4520)
* 2 IR Detector / Emitter Pairs
* 2 Hall Sensors & Small Magnets
* 1 H-Bridge (L298)
* 1 Inverting Schmidt Trigger (74HC14)

[[image:Circuit_Diagram.jpg|left|IR Tracker Schematic|thumb|500px]]
[[image:Circuit_Top_View.jpg|right|IR Tracker Top View|thumb|500px]]

 

[[image:IR_Detector_Emitter.jpg|left|IR Detector|thumb|200px]]

===IR Detector / Emitter Pairs===
The IR Detector detects the intensity of IR light coming from the IR Emitter. Over each revolution of the encoder's output shaft, the location of the maximum IR intensity is recorded. This information is given to the PIC to determine the servo's next position.

 

[[image:Hall_Sensors.jpg|left|Hall Sensors|thumb|200px]]

===Hall Sensors===
The Hall Sensors are used as a position marker for the encoders. They are located just below the output shafts of the encoders. A small magnet is placed on the side of the output shafts. As both encoder shafts spin, the Hall Sensor detects the location of the magnet. The purpose of the Hall Sensors is to use this information to sync the rotations of the two encoder shafts.

 


PIC 


The PIC is the central controller of the IR Tracker.


 MOSFETs 


The MOSFETs are used as intermediate components between the PIC and the servo motors. It allows the Pittman motors to run in one direction.


 Inverting Schmidt Trigger 


The Schmidt Trigger acts as an intermediate between both the PIC to the encoders on the motors and the PIC to the Hall Sensors. It helps filter out noisy signals and invert signals to be readable for the PIC.

==Code==

[[media:IR_Tracker_Code.c|See full code here]]

===Outline of Code===

Here is a general outline of what the IR Tracker does:

# Spin encoder shafts
# Record current position of the servo
# Determine location of the maximum IR intensity detected
# Convert encoder position to servo position
# Rotate the main plane to the new servo position
# Sync rotations of the two encoder shafts
# Repeat steps 2-6

===main()===

This is the main function of our code:

<pre>
void main()
{
runsetup();

while (TRUE)
{
encodersave();
positioncount();
ircheck();
equalize();
}
}
</pre>

The five functions it encompasses are described in detail below.

===runsetup()===

The interrupts for both servos and Hall sensors are set, and motors begin to spin at full velocity. This function is only called once at the beginning of the main function.

<pre>
void runsetup()
{
setup_timer_0(RTCC_EXT_L_TO_H | RTCC_DIV_1); //External input from quadrature encoder 0
setup_timer_1(T1_EXTERNAL | T1_DIV_BY_1); //External input from quadrature encoder 1
setup_timer_2(T2_DIV_BY_4, 255, 5); //Servo incrememnting timer at 1 kHz
setup_timer_3(T3_INTERNAL | T3_DIV_BY_4); //Servo reseting timer

enable_interrupts(INT_TIMER2); //Enable ISR2 for servo
enable_interrupts(INT_TIMER3); //Enable ISR3 for servo
enable_interrupts(INT_EXT); //Enable Interrupt for Hall sensor X
enable_interrupts(INT_EXT1); //Enable Interrupt for Hall sensor Y
enable_interrupts(global);

setup_ccp1(ccp_pwm); //Setup PWM1
setup_ccp2(ccp_pwm); //Setup PWM2

set_timer0(0); //Clear starting point of counters
set_timer1(0);

set_PWM1_duty(0); //Motors off for startup
set_PWM2_duty(0);

for(ii=0;ii<3;ii++) //Start up flashing lights
{
output_d(0x55);
delay_ms(100);
output_d(0);
delay_ms(100);
}

set_PWM1_duty(1023); //Motors start at full velocity
set_PWM2_duty(1023);
}
</pre>

===encodersave()===

This records the current servo positions in the both the x and y direction.

<pre>
void encodersave() //Counters will return the number of pulses to the inputs.
{
PositionCountX = get_timer0(); //Relative position of the X encoder
delay_us(10);

PositionCountY = get_timer1(); //Relative position of the Y encoder
delay_us(10);
}
</pre>

===positioncount()===

This uses LEDs to represent where in the rotation the mirrors are, with one LED for each axis. The LEDs are on for half of the rotation and off for the other half.

<pre>
void positioncount() //Gives visual information about where in the rotation the mirrors are
{
if (PositionCountX >4875)
{
output_high(pin_D3);
}
else if(PositionCountX>0)
{
output_low(pin_D3);
}
if (PositionCountY > 4875)
{
output_high(pin_D4);
}
else if(PositionCountY>0)
{
output_low(pin_D4);
}
}
</pre>

===ircheck()===

This finds the location of maximum infrared light in both the x-axis and y-axis. This information is originally collected as an encoder position count value, is converted into an angle in degrees and is then converted again into servo position count value, so that the servo can move to the appropriate location.

<pre>
void ircheck() //Check to see where in the rotation
{
if(PositionCountX<4875) //First half of rotation, facing up
{
if(input(PIN_C6)==0) //If IR detector is detecting encoded signal
{
output_high(PIN_D5); //Gives visual representation
MomentX+=PositionCountX; //Increase moment count by position
MomentCountX+=1; //Increase count of moments
}
else
{
output_low(PIN_D5); //Clear B5 if mirror is facing down
}
}
else if((PositionCountX>=4875)&&(MomentCountX>5)) //Runs when this function is called and IR detector
{
AverageAngleX = (MomentX/MomentCountX); //Average the moment to give the center of IR in terms of motor encoder counts

if (((AverageAngleX)>650)&&((AverageAngleX)<4800))
{
AnglePositionX = 3647-23*AverageAngleX/34; //Convert motor encoder counts to servo values

if (ServoCurrent[0] + AnglePositionX < 1950) //Less than 90 degress
{
ServoTargetX = 400;
}
else if (ServoCurrent[0] + AnglePositionX> 4250) //Greater than 450 degrees
{
ServoTargetX = 2700;
}
else //between 90 and 450 degrees
{
ServoTargetX = AnglePositionX + ServoCurrent[0] - 1550;
}
}
MomentX = 0; //reset moment variables
MomentCountX = 0;
}

if(PositionCountY<4875)
{
if(input(PIN_C5)==0)
{
output_high(PIN_D6);
MomentY+=PositionCountY;
MomentCountY+=1;
}
else
{
output_low(PIN_D6);
}
}
else if((PositionCountY>=4875)&&(MomentCountY>5))
{
AverageAngleY = (MomentY/MomentCountY);

if (((AverageAngleY)>650)&&((AverageAngleY)<4800))
{
AnglePositionY = 3647-23*AverageAngleY/34;

// find target location in terms of servo counts
if (ServoCurrent[1] + AnglePositionY < 1950) //less than 90 degress
{
ServoTargetY = 400;
}
else if (ServoCurrent[1] + AnglePositionY> 4250) // greater 450 deg
{
ServoTargetY = 2700;
}
else
{
ServoTargetY = AnglePositionY + ServoCurrent[1] - 1550;
}
}
MomentY = 0;
MomentCountY = 0;
}
}
</pre>

===equalize()===

This syncs the speed and direction of the rotation of the two encoder motors.

<pre>
void equalize() //puts motors in phase with each other
{
if(PositionCountX>PositionCountY)
{
set_PWM1_duty(850);
set_PWM2_duty(1023);
}
else if (PositionCountX<PositionCountY)
{
set_PWM2_duty(850);
set_PWM1_duty(1023);
}
}
</pre>

===servotrack()===

While this function isn't in the main function, it is called in one of the interrupts. Its purpose is to slowly move the servos from their current location to its destination.

<pre>
void servotrack() //Slowly adjusts the pulsing of the servo to place the plan in the appropriate location
{
if(((SlowServoX>15)&&(abs(ServoTargetX-ServoCurrent[0])>5))||((SlowServoX>8)&&(abs(ServoTargetX-ServoCurrent[0])>125))
||((SlowServoX>3)&&(abs(ServoTargetX-ServoCurrent[0])>450))||SlowServoX>100) //Can be used to slow down motion of Servos
{
if (ServoCurrent[0] < ServoTargetX - ServoMove)
{
ServoNextX = ServoCurrent[0] + ServoMove;
ServoCurrent[0] = ServoNextX;
}
else if (ServoCurrent[0] > ServoTargetX + ServoMove)
{
ServoNextX = ServoCurrent[0] - ServoMove;
ServoCurrent[0] = ServoNextX;
}
else
{
ServoCurrent[0] = ServoTargetX;
}
SlowServoX=0;
}
if(((SlowServoY>15)&&(abs(ServoTargetY-ServoCurrent[1])>5))||((SlowServoY>8)&&(abs(ServoTargetY-ServoCurrent[1])>125))
||((SlowServoY>3)&&(abs(ServoTargetY-ServoCurrent[1])>450))||SlowServoY>100)

{
if (ServoCurrent[1] < ServoTargetY - ServoMove)
{
ServoNextY = ServoCurrent[1] + ServoMove;
ServoCurrent[1] = ServoNextY;
}
else if (ServoCurrent[1] > ServoTargetY + ServoMove)
{
ServoNextY = ServoCurrent[1] - ServoMove;
ServoCurrent[1] = ServoNextY;
}
else
{
ServoCurrent[1] = ServoTargetY;
}
SlowServoY=0;
}

SlowServoX++;
SlowServoY++;
}
</pre>

==Results==

===Final Design===

[[image:Final_Design.jpg|600px|center]]

===Video===

"See Spot Run": Click [http://depot.northwestern.edu/mht363/public_html/IR%20Track/Mar%2019%20IR%20tracker.mp4 here] to see a movie of our final project.

==Reflections==

Overall, our team is very satisfied with our end result.

===Objectives Met===
* Ability to locate the position of an IR emitter on two axises.
* Ability to rotate to align its plane to be normal to an IR emitter.
* Ability to continuously track an IR signal.

===Problems Encountered===
* (Mechanical) Initially, the device had very shaky movements. We added additional screws to make the device more stable.
* (Electrical) We added Schmidt Triggers to clean up the noisy signals from the servo motors to the PICs.
* (Code) Originally coded to track direction of change of the IR emitter and supposed to move accordingly. We encountered a lot of noise. We changed the code to find the exact position of the IR emitter instead.
* (Electrical) The L298N H-bridge ended up heating up the entire circuit. In our final design, we chose to use MOSFETS in their place.

===Future Work===
* More powerful servos and a more accurately calculated counterweight would help smooth the movement of the device.
* A more sensitive IR detector could track lower intensities of IR light in a room, instead of specifically an IR emitter.
* With more precise measurements of the relationship between the encoder and servo values, the IR Tracker could more accurately determine the position of an IR signal.

IR Tracker

2008-03-20T17:43:06Z

Matt Turpin: /* Hall Sensors */

[[image:IR_Tracker_Header.jpg|400px|right]]

==Team Members==

[[Image:IR_Tracker_Team.jpg|right|Left to right: Matt, Mark and Alice|thumb|300px]]

* Mark Straccia (Mechanical Engineering, Class of 2009)
* Matt Turpin (Mechanical Engineering, Class of 2009)
* Alice Zhao (Electrical Engineering, Class of 2008)

 

==Overview==

The goal of this project was to create a device that would follow a moving infrared light. The IR Tracker does this by continuously detecting the position of an infrared emitter in two axises, and then tracking the emitter with a laser.

The IR Tracker follows two major steps: (1) Identify the position of the IR emitter (2) Rotate the device to align itself with the IR emitter.

# The IR Tracker finds the location of the maximum infrared intensity in both the x-axis and y-axis. Two encoders continuously record the position of the IR emitter based on intensity levels detected by two IT detectors.
# Given the information about the location of the IR emitter, the device rotates itself in two dimensions to adjusts its plane to be normal to the IR emitter. At this point, the laser should point to the IR emitter.

We will discuss the mechanical design, electrical design, PIC code, resulting project and our team reflections.

==Mechanical Design==

===Primary Components===

The primary components used in this device are:

* 2 Pitman Motors
* 2 RC Servos
* 1 Turntable (6031K17, McMaster-Carr, $2.20, readily available)
* 1 Cylindrical Bearing
* 1 Laser
* Mirror
* Plexiglas

[[image:Mechanical_Design.jpg|center|Mechanical Design|700px]]

 

[[image:Detecting_Component.jpg|right|Detecting Component|thumb|300px]]

===Detecting Component===
On the main plane of the device, two encoders are placed perpendicular to each other (able to track on two axises). Mirrors are placed on the output shafts of the two encoders at 45 degree angles. Two infrared detectors are placed in line with the encoders. While the encoders are constantly spinning, the mirrors detect light from the IR emitter and bounce the light to the IR detectors.

 

[[image:Rotating_Component.jpg|right|Rotating Component|thumb|300px]]

===Rotating Component===
Below the main plane of the device, two servos are used to rotate the entire device to align the main plane to be normal to the emitter. The main plane is attached to a block of Plexiglas that surrounds a cylindrical bearing. This bearing allows the main plane to rotate along the y-axis. This block of Plexiglas is mounted on a turntable which allows the main plane to rotate along the x-axis.

 

==Electrical Design==

===Primary Components===

The primary components used in this circuit are:

* 1 PIC (18F4520)
* 2 IR Detector / Emitter Pairs
* 2 Hall Sensors & Small Magnets
* 1 H-Bridge (L298)
* 1 Inverting Schmidt Trigger (74HC14)

[[image:Circuit_Diagram.jpg|left|IR Tracker Schematic|thumb|500px]]
[[image:Circuit_Top_View.jpg|right|IR Tracker Top View|thumb|500px]]

 

[[image:IR_Detector_Emitter.jpg|left|IR Detector|thumb|200px]]

===IR Detector / Emitter Pairs===
The IR Detector detects the intensity of IR light coming from the IR Emitter. Over each revolution of the encoder's output shaft, the location of the maximum IR intensity is recorded. This information is given to the PIC to determine the servo's next position.

 

[[image:Hall_Sensors.jpg|left|Hall Sensors|thumb|200px]]

===Hall Sensors===
The Hall Sensors are used as a position marker for the encoders. They are located just below the output shafts of the encoders. A small magnet is placed on the side of the output shafts. As both encoder shafts spin, the Hall Sensor detects the location of the magnet. The purpose of the Hall Sensors is to use this information to sync the rotations of the two encoder shafts.

 


PIC 


The PIC is the central controller of the IR Tracker.


 MOSFETs 


The MOSFETs are used as intermediate components between the PIC and the servo motors. It allows the Pittman motors to run in one direction.


 Inverting Schmidt Trigger 


The Schmidt Trigger acts as an intermediate between both the PIC to the encoders on the motors and the PIC to the Hall Sensors. It helps filter out noisy signals and invert signals to be readable for the PIC.

==Code==

[[media:IR_Tracker_Code.c|See full code here]]

===Outline of Code===

Here is a general outline of what the IR Tracker does:

# Spin encoder shafts
# Record current position of the servo
# Determine location of the maximum IR intensity detected
# Convert encoder position to servo position
# Rotate the main plane to the new servo position
# Sync rotations of the two encoder shafts
# Repeat steps 2-6

===main()===

This is the main function of our code:

<pre>
void main()
{
runsetup();

while (TRUE)
{
encodersave();
positioncount();
ircheck();
equalize();
}
}
</pre>

The five functions it encompasses are described in detail below.

===runsetup()===

The interrupts for both servos and Hall sensors are set, and motors begin to spin at full velocity. This function is only called once at the beginning of the main function.

<pre>
void runsetup()
{
setup_timer_0(RTCC_EXT_L_TO_H | RTCC_DIV_1); //External input from quadrature encoder 0
setup_timer_1(T1_EXTERNAL | T1_DIV_BY_1); //External input from quadrature encoder 1
setup_timer_2(T2_DIV_BY_4, 255, 5); //Servo incrememnting timer at 1 kHz
setup_timer_3(T3_INTERNAL | T3_DIV_BY_4); //Servo reseting timer

enable_interrupts(INT_TIMER2); //Enable ISR2 for servo
enable_interrupts(INT_TIMER3); //Enable ISR3 for servo
enable_interrupts(INT_EXT); //Enable Interrupt for Hall sensor X
enable_interrupts(INT_EXT1); //Enable Interrupt for Hall sensor Y
enable_interrupts(global);

setup_ccp1(ccp_pwm); //Setup PWM1
setup_ccp2(ccp_pwm); //Setup PWM2

set_timer0(0); //Clear starting point of counters
set_timer1(0);

set_PWM1_duty(0); //Motors off for startup
set_PWM2_duty(0);

for(ii=0;ii<3;ii++) //Start up flashing lights
{
output_d(0x55);
delay_ms(100);
output_d(0);
delay_ms(100);
}

set_PWM1_duty(1023); //Motors start at full velocity
set_PWM2_duty(1023);
}
</pre>

===encodersave()===

This records the current servo positions in the both the x and y direction.

<pre>
void encodersave() //Counters will return the number of pulses to the inputs.
{
PositionCountX = get_timer0(); //Relative position of the X encoder
delay_us(10);

PositionCountY = get_timer1(); //Relative position of the Y encoder
delay_us(10);
}
</pre>

===positioncount()===

This uses LEDs to represent where in the rotation the mirrors are, with one LED for each axis. The LEDs are on for half of the rotation and off for the other half.

<pre>
void positioncount() //Gives visual information about where in the rotation the mirrors are
{
if (PositionCountX >4875)
{
output_high(pin_D3);
}
else if(PositionCountX>0)
{
output_low(pin_D3);
}
if (PositionCountY > 4875)
{
output_high(pin_D4);
}
else if(PositionCountY>0)
{
output_low(pin_D4);
}
}
</pre>

===ircheck()===

This finds the location of maximum infrared light in both the x-axis and y-axis. This information is originally collected as an encoder position count value, is converted into an angle in degrees and is then converted again into servo position count value, so that the servo can move to the appropriate location.

<pre>
void ircheck() //Check to see where in the rotation
{
if(PositionCountX<4875) //First half of rotation, facing up
{
if(input(PIN_C6)==0) //If IR detector is detecting encoded signal
{
output_high(PIN_D5); //Gives visual representation
MomentX+=PositionCountX; //Increase moment count by position
MomentCountX+=1; //Increase count of moments
}
else
{
output_low(PIN_D5); //Clear B5 if mirror is facing down
}
}
else if((PositionCountX>=4875)&&(MomentCountX>5)) //Runs when this function is called and IR detector
{
AverageAngleX = (MomentX/MomentCountX); //Average the moment to give the center of IR in terms of motor encoder counts

if (((AverageAngleX)>650)&&((AverageAngleX)<4800))
{
AnglePositionX = 3647-23*AverageAngleX/34; //Convert motor encoder counts to servo values

if (ServoCurrent[0] + AnglePositionX < 1950) //Less than 90 degress
{
ServoTargetX = 400;
}
else if (ServoCurrent[0] + AnglePositionX> 4250) //Greater than 450 degrees
{
ServoTargetX = 2700;
}
else //between 90 and 450 degrees
{
ServoTargetX = AnglePositionX + ServoCurrent[0] - 1550;
}
}
MomentX = 0; //reset moment variables
MomentCountX = 0;
}

if(PositionCountY<4875)
{
if(input(PIN_C5)==0)
{
output_high(PIN_D6);
MomentY+=PositionCountY;
MomentCountY+=1;
}
else
{
output_low(PIN_D6);
}
}
else if((PositionCountY>=4875)&&(MomentCountY>5))
{
AverageAngleY = (MomentY/MomentCountY);

if (((AverageAngleY)>650)&&((AverageAngleY)<4800))
{
AnglePositionY = 3647-23*AverageAngleY/34;

// find target location in terms of servo counts
if (ServoCurrent[1] + AnglePositionY < 1950) //less than 90 degress
{
ServoTargetY = 400;
}
else if (ServoCurrent[1] + AnglePositionY> 4250) // greater 450 deg
{
ServoTargetY = 2700;
}
else
{
ServoTargetY = AnglePositionY + ServoCurrent[1] - 1550;
}
}
MomentY = 0;
MomentCountY = 0;
}
}
</pre>

===equalize()===

This syncs the speed and direction of the rotation of the two encoder motors.

<pre>
void equalize() //puts motors in phase with each other
{
if(PositionCountX>PositionCountY)
{
set_PWM1_duty(850);
set_PWM2_duty(1023);
}
else if (PositionCountX<PositionCountY)
{
set_PWM2_duty(850);
set_PWM1_duty(1023);
}
}
</pre>

===servotrack()===

While this function isn't in the main function, it is called in one of the interrupts. Its purpose is to slowly move the servos from their current location to its destination.

<pre>
void servotrack() //Slowly adjusts the pulsing of the servo to place the plan in the appropriate location
{
if(((SlowServoX>15)&&(abs(ServoTargetX-ServoCurrent[0])>5))||((SlowServoX>8)&&(abs(ServoTargetX-ServoCurrent[0])>125))
||((SlowServoX>3)&&(abs(ServoTargetX-ServoCurrent[0])>450))||SlowServoX>100) //Can be used to slow down motion of Servos
{
if (ServoCurrent[0] < ServoTargetX - ServoMove)
{
ServoNextX = ServoCurrent[0] + ServoMove;
ServoCurrent[0] = ServoNextX;
}
else if (ServoCurrent[0] > ServoTargetX + ServoMove)
{
ServoNextX = ServoCurrent[0] - ServoMove;
ServoCurrent[0] = ServoNextX;
}
else
{
ServoCurrent[0] = ServoTargetX;
}
SlowServoX=0;
}
if(((SlowServoY>15)&&(abs(ServoTargetY-ServoCurrent[1])>5))||((SlowServoY>8)&&(abs(ServoTargetY-ServoCurrent[1])>125))
||((SlowServoY>3)&&(abs(ServoTargetY-ServoCurrent[1])>450))||SlowServoY>100)

{
if (ServoCurrent[1] < ServoTargetY - ServoMove)
{
ServoNextY = ServoCurrent[1] + ServoMove;
ServoCurrent[1] = ServoNextY;
}
else if (ServoCurrent[1] > ServoTargetY + ServoMove)
{
ServoNextY = ServoCurrent[1] - ServoMove;
ServoCurrent[1] = ServoNextY;
}
else
{
ServoCurrent[1] = ServoTargetY;
}
SlowServoY=0;
}

SlowServoX++;
SlowServoY++;
}
</pre>

==Results==

===Final Design===

[[image:Final_Design.jpg|600px|center]]

===Video===

"See Spot Run": Click [http://depot.northwestern.edu/mht363/public_html/IR%20Track/Mar%2019%20IR%20tracker.mp4 here] to see a movie of our final project.

==Reflections==

Overall, our team is very satisfied with our end result.

===Objectives Met===
* Ability to locate the position of an IR emitter on two axises.
* Ability to rotate to align its plane to be normal to an IR emitter.
* Ability to continuously track an IR signal.

===Problems Encountered===
* (Mechanical) Initially, the device had very shaky movements. We added additional screws to make the device more stable.
* (Electrical) We added Schmidt Triggers to clean up the noisy signals from the servo motors to the PICs.
* (Code) Originally coded to track direction of change of the IR emitter and supposed to move accordingly. We encountered a lot of noise. We changed the code to find the exact position of the IR emitter instead.
* (Electrical) The Schmidt Triggers ended up heating up the entire circuit. In our final design, we chose to use MOSFETS in their place.

===Future Work===
* More powerful servos and a more accurately calculated counterweight would help smooth the movement of the device.
* A more sensitive IR detector could track lower intensities of IR light in a room, instead of specifically an IR emitter.
* With more precise measurements of the relationship between the encoder and servo values, the IR Tracker could more accurately determine the position of an IR signal.

File:I2CMotorControllerCode.zip

2008-03-17T03:02:26Z

Matt Turpin: The PIC C and MATLAB code for the I2C motor controller

The PIC C and MATLAB code for the I2C motor controller

I2C Motor Controller

2008-03-17T02:59:08Z

Matt Turpin:

This design is intended as a cost effective, readily available motor controller solution capable of handling multiple controllers from one master device in a logical, powerful and easy to use interface.

This solution is best suited to drive DC brush motors at encoder rates up to and exceeding 2 MHz. Motor positions are measured with hardware quadrature encoding to achieve this high rate. A built in PID controller with adjustable gains is used to control each motor to be flexible enough for any choice of motor.

See the datasheet [[Media:I2CMotorController.PDF|'''here''']] for more information about using this I2C motor controller.

Download zip file of code [[Media:I2CMotorControllerCode.zip|'''here''']]

File:I2CMotorController.PDF

2008-03-17T02:57:27Z

Matt Turpin: A simple easy to construct I2C motor controller for the PIC 18F4520.

A simple easy to construct I2C motor controller for the PIC 18F4520.

I2C Motor Controller

2008-03-17T02:51:50Z

Matt Turpin:

This design is intended as a cost effective, readily available motor controller solution capable of handling multiple controllers from one master device in a logical, powerful and easy to use interface.

This solution is best suited to drive DC brush motors at encoder rates up to and exceeding 2 MHz. Motor positions are measured with hardware quadrature encoding to achieve this high rate. A built in PID controller with adjustable gains is used to control each motor to be flexible enough for any choice of motor.

See the datasheet [[Media:I2CMotorController.PDF|'''here''']] for more information about using this I2C motor controller.

Download I2CMotorControllerCode.zip of code [[Media:I2CMotorControllerCode.zip|'''here''']]

Main Page

2008-03-17T02:46:15Z

Matt Turpin:

The Northwestern University mechatronics design wiki provides reference material on the theory and applications of electronics, sensors, actuators, etc., for use in mechatronics-related research and projects. Practical applications often refer to equipment and supplies available in the [http://mechatronics.mech.northwestern.edu/ Northwestern Mechatronics Design Lab].

Important: Please be sure to read the [http://mechatronics.mech.northwestern.edu/mech-rules.pdf Rules for Using the Mechatronics Design Lab].

__TOC__

<h3>Design Competition 2008</h3>

Wiki pages on sensors, actuators, programming, and microcontrollers: use pages below
 
* [http://www.mech.northwestern.edu/courses/433/Writeups/QuickStart/ Parts in the DC2008 quick start pack]
* [http://peshkin.mech.northwestern.edu/pic/info/piccintro_2008-01-24.pdf PIC C intro slides, as presented 2008/01/24 (pdf)]
* [http://peshkin.mech.northwestern.edu/pic/info/picinterfacing_2008-01-28.pdf PIC interfacing slides, as presented 2008/01/28 (pdf)]
 

<h3>Sensors and actuators for DC</h3>
* [[Using Solderless Breadboard|Solderless Breadboard & wiring that works]]
* [[Using LEDs & IREDs]]
* [[Using a laser]]
* [[Sensing optical tape|Infrared reflectivity]]
** Using phototransistors
** Sensing optical tape
* [[Comparators | Comparators : the analog digital interface]]
* [[Driving a DC Motor using PWM]]
* [http://www.robotroom.com/FaulhaberGearmotor.html Faulhaber MiniMotor SA gearmotor with encoder], as well as [[Actuators_Available_in_the_Mechatronics_Lab#Faulhaber_1524E006S_motor_with_141:1_gearhead_and_HES164A_magnetic_quadrature_encoder|the local wiki page]]
* [[Adding a magnetic encoder to a GM3 Gearmotor]]
** Using magnetic switches (Hall Effect)
* [[Driving using a single MOSFET | Driving a DC motor using a single MOSFET]]
* [[High-current devices|Driving high-current devices: several options]]
* [[Driving a Stepper Motor]]
* [[Driving an RC Servo]]
* [[Accelerometers]]
* [[Strain gauges]]
* [[Using the Basic Stamp Microcontroller|Basic Stamp Microcontroller]] Not recommended for DC2008
* [http://www.mech.northwestern.edu/courses/433/Writeups/Battery_NiMH/ NiMH rechargable batteries and chargers]

<h3> [http://peshkin.mech.northwestern.edu/datasheets Prof. Peshkin's favorite datasheets]</h3>
 

<h3>PIC 18F4520 prototyping board </h3>
*[[4520 Board intro|Prototyping board intro]]
*[[4520 Board construction|Assembling the 18F4520 prototyping board, circuit, parts]]
*[[4520 Board use|Using the 18F4520 prototyping board]]
 

<h3>Programming with CCS C </h3>
*[[C language|The C language]]
*[[CCS C|CCS C, specifically for the 18F4520]]
*[[CCS IDE|Using the CCS development environment]]
*[[Debugging C on a PIC]]
*[[More debugging tips]]
*[http://www.ccsinfo.com/forum/ CCS user forum]
 

<h3>Interfacing and skeleton code for the PIC 18F4520</h3> 
These topics have wiki pages and sample code available 
[http://peshkin.mech.northwestern.edu/pic/code Link to all sample code here.]
 
* [[Digital inputs & outputs]] (filename: DigitalIO)
* [[Analog Input]] (filename: AnalogInput)
** reading a trimpot
** reading a phototransistor
** amplified phototransistor, and IRED strobing
** using an instrumentation amp (example: for a strain gauge)
* [[Analog Output|Analog Output, and the I2C bus]] (filename: AnalogOutput)
*[[Pulse width modulation|Pulse width modulation (PWM) for driving motors or other high current devices]] (filename: MotorPWM)
** using H-bridges
* [[Interrupts]]
* [[Quadrature decoding in software]] (filename: QuadratureSoft)
* [[Quadrature decoding in hardware, or just counters]] (filename: QuadratureHard)
* [[Running RC servos]] (filename: RCservoSoft & RCservoHard)
* [[Watchdog timer]] (filename: Watchdog)
* [[PIC RS232|RS-232 serial communication between a PC and a PIC]] (filename: RS232)
* [[C Example: Serial LCD|Text output to a serial LCD display]]
* [[C Example: Parallel Interfacing with LCDs|Text output to a parallel LCD display]]
* [[Servo skeleton with fast & slow interrupts]]
* [[XBee radio communication between PICs]]
* [[I2C communication between PICs]]
* [[Serial communication with Matlab]]
* [[SPI communication between PICs]] (Note: this function has not been successfully tested)
* [[Microphones]]
* [[Ambient light color sensing]]
* [[Controlling a seven segment display]]
* [[Storing constant data in program memory]]
* [[PIC computation time benchmarks]]
* [[Stepper motor control with the PIC]]
* [[Global Positioning System]]
* [[IR communication between PICs]] (Note: this function has not been successfully tested) 
* [[Interfacing to External EEPROM]]
* [[I2C Motor Controller]]

 
These topics have sample code available, but no wiki pages yet 
[http://peshkin.mech.northwestern.edu/pic/code Link to all sample code here.]

* Counter0 - Counting pulses with Timer0]
* Counter1 - Counting pulses with Timer1]
* Interrupt0 - Periodic servo cycles using interrupt routines, 10mS & slower; Timer 0]
* Interrupt2 - Periodic servo cycles using interrupt routines; 10mS & faster; Timer 2]
* InterruptExternal - Interrupts generated by an external pulse]

 
These topics need more development 
[http://peshkin.mech.northwestern.edu/pic/code Link to all sample code here.] 
* AnalogOutputParallel - Analog output using 8 digital lines]
* PIC-to-PIC communication
* Zigbee radio communication
* Modulated IR communication
* Strobing LEDs or IREDs for better range and immunity to background light
* I2C communication
* CAN bus
* Capturing data to Matlab
* Running stepper motors
 

<h3>PIC Microcontrollers</h3>
* [[PIC Microcontrollers with CCS Compiler]], for DC, 333, etc, using the CCS ICD-U40 device [this section has been replaced by the material above]
* [[PIC Microcontrollers with C18 Compiler]], for e-puck, or using the Microchip ICD device or
 

<h3>e-puck Mobile Robot</h3>
* [[e-puck Mobile Robot]]
 

<h3>[[Printing Circuit Boards]]</h3>

<h3> Basic Electronics </h3>
* [http://hades.mech.northwestern.edu/wiki/index.php/Category:Electronics Electronics]
 

<h3>Analog and Digital chips</h3>
* [[Comparators | Comparators: the analog to digital interface]]
* [http://en.wikipedia.org/wiki/Operational_amplifier_applications Opamps : building blocks of analog computation]
* [http://www.mech.northwestern.edu/courses/433/Writeups/InstAmp/instamp.htm Instrumentation amps, and NU circuit board for them]

 

<h3>[[:Category:Sensors|Sensors]]</h3>

* [[Potentiometers|Angle, Linear Position: Potentiometers]]
* [[Optointerrupter|Beam Breaker: Optointerrupter]]
* [[Optoreflector|Proximity: Optoreflector]]
* [[Sensing optical tape|Infrared reflectivity : Sensing optical tape]]
* [[Reed Switch|Proximity: Reed Switch]]
* [[Hall Effect Sensor|Proximity, Angle: Hall Effect Sensor]]
* [[Rotary Encoder|Angle: Rotary Encoder]]
* Angular Velocity: Tachometer
* [[Photodiodes and Phototransistors|Light: Photodiodes and Phototransistors]]
* [[Photocell|Ambient Light: Photocell]]
* [[Thermistor|Temperature: Thermistor]]
* Temperature: Thermotransistor IC
* Audio: [[Microphones]]
* [[Accelerometers|Tilt, Acceleration: Accelerometers]]
* [[Strain Gauge|Force: Strain Gauge]]
* Current: Current Sense Resistor
* [[Limit Switch|Contact: Microswitch (Limit Switch)]]
* [[Ambient light color sensing]]
* [[Global Positioning System]]

 

<h3>[[:Category:Actuators|Actuators]]</h3>
[[image:All-actuators-captions-small.jpg|thumb|300px|[[Actuators Available in the Mechatronics Lab|Available Actuators]]|right]]

* [[Brushed DC Motor Theory|Brushed DC Motors]]
** [[Choosing a Motor and Gearing Combination|Choosing a Motor and Gearing Combination]]
** [[Linear Amplifier Motor Driver|Driving Using a Linear Amplifier]]
** [[Driving using a single MOSFET|Driving using a single MOSFET]]
** [[Pulse Width Modulation|Driving Using Pulse Width Modulation]]
** [[PIC PWM Motor Driver]]
** [[Gear Motor]]
*** [http://www.mech.northwestern.edu/courses/433/Writeups/AddEncoderHobbyEngGearMotor Adding a rotation encoder to a gearmotor]
* [[Brushless DC Motors]]
** [[Driving Brushless DC Motors]]
* [[Stepper Motor Theory|Stepper Motors]]
** [[Stepper Motor Circuits|Driving Stepper Motors]]
** [[Unipolar Stepper Motor Driver Circuit]]
** [[Bipolar Stepper Motor Driver Circuit]]
* [[RC Servo Theory|RC Servos]]
** [[555 Servo Circuit|Driving Your Servo Using a 555 Timer]]
* [[Solenoid Theory|Solenoids]]
** Practice: Driving Your Solenoid
* AC Motors
** [[Using the Yaskawa Motors]]
* [[Actuators Available in the Mechatronics Lab]]
 

<h3>Mechanical Design</h3>
*Mechanics of Materials
**Beam Mechanics
**[[Mohr's Circle]]
*Failure Theories
**Static Loading
**Variable Loading and Fatigue
*Fastening
**Nuts and Bolts
**Keys and Keyways
**Press-fits
**Set Screws
*Support
**Housings
**Shafts
**[[Bearings]]
*Transmission
**Rigid: [[Gears]]
**Flexible: Belts, Chains
**Motion Connection/Separation: Clutches, Brakes, Couplings
*Linkages
**Serial Chains
**Parallel and Closed-Loop Chains
*Other: springs/dampers, cams, etc.

 

<h3>The PC/104 Stack</h3>
[[Image:Img0174.jpg|thumb|300px|[[PC104 Overview|The PC104 Stack]]|right]]
* [[PC104 Overview|Overview]]
* [[The PC/104 Lab Kit]]
* Hardware:
** [[Advantech CPU Card]]
** [[Sensoray 526 Data Aquisition Card]]

** [http://www.mech.northwestern.edu/courses/433/Writeups/PC104BoB/stack.htm#power[Power Components]]
** [http://www.mech.northwestern.edu/courses/433/Writeups/PC104BoB/stack.htm#electrical[I/O Electronics: Analog I/O, Digital I/O, Encoder Connections]]
* Advanced: Creating a Working Stack from Parts
** [http://www.mech.northwestern.edu/courses/433/Writeups/PC104BoB/stack.htm [Building the Breakout Board]]
** [http://www.mech.northwestern.edu/courses/433/Writeups/PC104BoB/stack.htm#ribboncables[Breakout Board Ribbon Cables]]
** [http://www.mech.northwestern.edu/courses/433/Writeups/PC104BoB/stack.htm#mechanical[Assembling the PC104 Stack]]
** '''[[Creating an xPC Flash Boot Disk]]''' <- when new version of MATLAB
* Custom Boards
** Dual PWM Motor Controller
** Dual Linear Amplifier Motor Controller
 

<h3>xPC Target Real-Time Operating System</h3>

* [[xPC Overview|Overview of Real-Time Programming with Simulink and xPC Target]]
* [[Configuring xPC Target PC|Configuring xPC Host/Target PC]]
* [[Creating a Simple xPC Program|'''Quickstart''':Creating a simple xPC Program]]
* [[Common xPC Blocks|Commonly Used Blocks]]
* [[Using the Host Scope]]
*Advanced
** Model Properties
** [[XPC M-file Communication|M-file communication]]
** Using outside of the lab
** [[media:standalone.pdf|Standalone Mode]]
** Stateflow
* Code Examples
** [[Controlling a DC Motor with an Encoder]]
** Something With State Machine
** [[Using RS-232 and Printing to LCD]]
**[[UDP Communications between Target and Host PC]]
** M-functions and S-functions
** [[xPC Code From Student Projects]]
 

<h3>QNX Real-Time Operating System</h3>
*[[media:qnxtemplate.zip|QNX Control Program with Interrupts]]

 

<h3>Lab Supplies and Data Sheets</h3>

* [http://spreadsheets.google.com/pub?key=pa_bNAhFF-OvvxpSje1KDYg&output=html&gid=0&single=true Generally stocked lab inventory ]

 

<h3>[[Vendors]]</h3>

 

<h3>Other Software</h3>
*[[List of Useful Software for Download]]
*Circuit Schematics and PCB Layout
*LaTex Document Preparation
** [http://meta.wikimedia.org/wiki/Help:Formula Mathematical Formulae]
** Document Formatting
** [[LaTeX Software Setup|Software Setup]]
** IEEE Styles

 

<h3>[[Other Lab Equipment]]</h3>
* Prototyping Tools
** [[Tektronix TDS220 Oscilloscope]]
** [[Tektronix CFG253 Function Generator]]
** [[media:Mastech_power_supply_manual.pdf|Mastech Power Supply]]
** Fluke III Multimeter
** Benchtop Multimeter
** Powered Breadboard
** Soldering Iron
* [http://ediacaran.mech.northwestern.edu/neuromech/index.php/Lab_Equipment High Performance Neuromechatronics Benches]
* The Sensoray 626 DAQ Card

 

<h3>Course Material</h3>
* [[ME 224 Experimental Engineering]]
* [http://lims.mech.northwestern.edu/~lynch/courses/ME333/2008/index.html ME 333 Introduction to Mechatronics]
** [[Lab 5]]
** [[Suggested final projects]]
** [[ME 333 final projects]]

* [http://www.mech.northwestern.edu/courses/433/ ME 433 Advanced Mechatronics]

 

<h3>Miscellaneous</h3>
* [[Swarm Robot Project]]
** [[Swarm Robot Project Links]]

I2C communication between PICs

2008-02-18T06:38:14Z

Matt Turpin: /* Overview */

== Original Assignment ==

Microcontrollers commonly talk to each other using protocols such as RS-232, SPI (for "serial peripheral interface"), I2C (or I^2C, "I squared C," for inter-integrated circuit), CAN bus, or other. This project is to demonstrate bidirectional I2C communication between two PICs. A demonstration might have the value of an analog input (potentiometer) at one PIC displayed as a "light bar" on the LEDs of the other PIC board, and simultaneously vice-versa.

== Overview ==

[http://www.nxp.com/acrobat_download/literature/9398/39340011.pdf I2C] is pronounced "I squared C" and stands for Inter-Integrated Circuit. This protocol was designed by Phillips Semiconductors around 1992 to allow easy communication between components on the same circuit board and can achieve transfer rates of up to 400 kbit/sec. Is is a 2 line (plus common ground) communication method for one master device to control up to 112 slave devices. While it is possible to have multiple masters on the same I2c bus, this page will only deal with a one master configuration.

The two lines are named SCL and SDA where SCL is the CLock line and SDA is the DAta line. The PIC 4520 is designed to use pin 18 as SCL and pin 23 as SDA for hardware I2C. Note that pin 18 is one of the only pins not accessible on the prototyping board. An additional wire can be added as shown in the example image. It is possible to use lines accessible from the prototyping board to communicate via software I2C, but this has data rates of less than one fourth those of hardware I2C and will therefore be omitted. I2C requires the lines to be high unless the master or the slave is pulling the line down, so you will need to use pull up resistors on both the clock and data lines.

An communication diagram is shown:

[[image:I2C_Data_Transfer.jpg|center]]

* S - As the master pulls down the data line, the falling edge of the data line signifies the start condition.
* P - As the master allows the data line to rise, the rising edge of the data line signifies the stop condition.
* B - Individual bits being transferred.

The data line can only change while the clock line is low. The data line is only read when the clock line is high and therefore 1 bit can be transferred per cycle of the clock line.

The master is initially sends a start bit followed by the 7-bit address of the slave it wishes to communicate with. The next bit represents whether it wishes to write(0) to or read(1) from the slave.

The slave then responds with an acknowledge bit. The transmission continues according to whether the master is attempting to read to or write from the device.

The master then ends the transmission with a stop bit. Another option is to send another start bit to continue the transfer in a combined message.

== Circuit ==

Below is a simple circuit diagram showing the master PIC with 2 close button switches. Note that pin 18 (RC3) is not brought out to the circuit board, but a wire can be soldered next to the PIC itself. Both SDA and SCL need pull up resistors as either the master or the slave can hold the line low to stop communication.
[[image:I2C Circuit Diagram.jpg|center|600px]]

Here is an example image of how to wire this.
[[image:I2C Wiring Image.jpg|center|600px]]

== Code ==
Code for master to slave transfer of one byte with switch de-bouncing can be found here:

[[Media:I2C_Master.c|'''Master Code''']]

[[Media:I2C_Slave.c|'''Slave Code''']]

Master

For the Master PIC, we first need to define the output pins and force hardware I2C communication.

#use I2C(FAST, SCL=PIN_C3, SDA=PIN_C4, FORCE_HW) //using hardware I2C, built into the PIC, make sure to include this line in any master I2C program

To communicate with a device, we use the following lines of code where 0x14 is the device name. The first line is the issuing of the start command and this forces all slave devices on the bus to wait for their address. The next write command is the address of the slave. The following byte is the data being sent to the slave. All communication must terminate with a stop command or the line will remain open and no future communication is possible until the command is given.

i2c_start(); //begin transmission
i2c_write(0x14); //select address of device to communicate with
i2c_write(data); //send actual data
i2c_stop(); //terminate communication

Slave

For the Slave PIC, we first need to define the output pins, define the name of the device and force hardware I2C communication. This device was randomly assigned name 0x14, but could have been just about any even hex number with a few exceptions noted below code.

#use i2c(SLAVE, FAST, SCL=PIN_C3, SDA=PIN_C4, address=0x14, FORCE_HW) //make sure to include this line in any Slave I2C program

The SSP interrupt is used for I2C communication. When the master begins to transmit data, the PIC goes into this interrupt.

#INT_SSP //Interrupt for I2C activity
void sspinterupt()
{

The definition of state is to determine whether or not the master is requesting or sending data.

state = i2c_isr_state(); //Reading the type of transmission

State is less than 0x80 for all read operations.

if(state < 0x80) //Master is sending data
{
data = i2c_read(); //An array will be needed to store data if more than one byte is transferred
}

State will be equal to 0x80 for write commands.

if(state == 0x80) //Master is requesting data
{
i2c_write(data);
}
output_d(data); //Output data to port D to visualize
}

Somewhere in the main section of the program, probably right away, the SSP interrupt will need to be enabled.

enable_interrupts(INT_SSP);
enable_interrupts(GLOBAL);

Address exceptions:

0000 000 1 START byte - for slow micros without I2C h/w
0000 001 X CBUS address - a different bus protocol
0000 010 X Reserved for different bus format
0000 011 X Reserved for future purposes
0000 1XX X Hs-mode master code
1111 1XX X Reserved for future purposes
1111 0XX X 10-bit slave addressing

== Two Way Communication ==

An alternate circuit diagram is shown below with an analogue input on the slave and three switches.

[[image:I2C_Alternate_Circuit_Diagram|center|600px]]

Changes are made to the code to allow more than one bit of data as well as data transferred from the slave to the master.

[[Media:I2C_Alternate_Master.c|'''Alternate Master''']]

[[Media:I2C_Alternate_Slave.c|'''Alternate Slave''']]

Master

An alternate address of 0xa0 is used to demonstrate any address can be used.

To read from the slave, the first byte sent is the address of the slave. The second byte is the location of the data on the slave being requested. The communication is terminated before being restarted.

i2c_start (); //begin communication
i2c_write (0xa0); //send slave address
i2c_write (0x02); //request slave internal memory address for analogue data
i2c_stop(); //stop write cycle to shift to read cycle
i2c_start (); //send repeated start command to begin read cycle

Immediately after restarting, the address plus one read bit added is sent. The data requested previously is read and the communication is terminated.

i2c_write (0xa1); //add 1 to the address to send a read bit
result = i2c_read(0); //read analogue information from the slave
i2c_stop (); //terminate communication
output_d(result); //display analogue information from the slave

Slave

In this example a larger information buffer is used, an array of 0x03 bytes, but this can be as large as needed.

int address, buffer[0x03];

In the interrupt, most of the same code is used as before.

#INT_SSP
void ssp_interupt ()
{
state = i2c_isr_state();
if(state < 0x80) //master is sending data
{

The first command bit is empty, so nothing is done.

if(state == 0)
{
}

The first data byte returns state 1 and is the address to be written to.

if(state == 1) //first received byte is address
{
address = i2c_read();
}

The second data byte is the information being received from the master and is stored in the address sent in the first data byte.

if(state == 2) //second received byte is data
{
buffer[address] = i2c_read();
}
}

If the master is requesting data, the slave sends data from the requested address.

if(state == 0x80) //master is requesting data
{
i2c_write (buffer[address]); //send requested data
}
}

==More Information==

Phillips Brief on I2c: http://www.nxp.com/acrobat_download/literature/9398/39340011.pdf

An I2C Primer: http://www.i2c-bus.org/I2C-Primer.520.0.html

I2C communication between PICs

2008-02-18T06:15:48Z

Matt Turpin:

== Original Assignment ==

Microcontrollers commonly talk to each other using protocols such as RS-232, SPI (for "serial peripheral interface"), I2C (or I^2C, "I squared C," for inter-integrated circuit), CAN bus, or other. This project is to demonstrate bidirectional I2C communication between two PICs. A demonstration might have the value of an analog input (potentiometer) at one PIC displayed as a "light bar" on the LEDs of the other PIC board, and simultaneously vice-versa.

== Overview ==

[http://www.nxp.com/acrobat_download/literature/9398/39340011.pdf I2C] is pronounced "I squared C" and stands for Inter-Integrated Circuit. This protocol was designed by Phillips Semiconductors around 1992 to allow easy communication between components on the same circuit board and can achieve transfer rates of up to 400 kbit/sec. Is is a 2 line (plus common ground) communication method for one master device to control up to 112 slave devices. While it is possible to have multiple masters on the same I2c bus, this page will only deal with a one master configuration.

The two lines are named SCL and SDA where SCL is the CLock line and SDA is the DAta line. The PIC 4520 is designed to use pin 18 as SCL and pin 23 as SDA for hardware I2C. Note that pin 18 is one of the only pins not accessible on the prototyping board. An additional wire can be added as shown in the example image. I2C requires the lines to be high unless the master or the slave is pulling the line down, so you will need to use pull up resistors on both the clock and data lines.

An communication diagram is shown:

[[image:I2C_Data_Transfer.jpg|center]]

* S - As the master pulls down the data line, the falling edge of the data line signifies the start condition.
* P - As the master allows the data line to rise, the rising edge of the data line signifies the stop condition.
* B - Individual bits being transferred.

The data line can only change while the clock line is low. The data line is only read when the clock line is high and therefore 1 bit can be transferred per cycle of the clock line.

The master is initially sends a start bit followed by the 7-bit address of the slave it wishes to communicate with. The next bit represents whether it wishes to write(0) to or read(1) from the slave.

The slave then responds with an acknowledge bit. The transmission continues according to whether the master is attempting to read to or write from the device.

The master then ends the transmission with a stop bit. Another option is to send another start bit to continue the transfer in a combined message.

== Circuit ==

Below is a simple circuit diagram showing the master PIC with 2 close button switches. Note that pin 18 (RC3) is not brought out to the circuit board, but a wire can be soldered next to the PIC itself. Both SDA and SCL need pull up resistors as either the master or the slave can hold the line low to stop communication.
[[image:I2C Circuit Diagram.jpg|center|600px]]

Here is an example image of how to wire this.
[[image:I2C Wiring Image.jpg|center|600px]]

== Code ==
Code for master to slave transfer of one byte with switch de-bouncing can be found here:

[[Media:I2C_Master.c|'''Master Code''']]

[[Media:I2C_Slave.c|'''Slave Code''']]

Master

For the Master PIC, we first need to define the output pins and force hardware I2C communication.

#use I2C(FAST, SCL=PIN_C3, SDA=PIN_C4, FORCE_HW) //using hardware I2C, built into the PIC, make sure to include this line in any master I2C program

To communicate with a device, we use the following lines of code where 0x14 is the device name. The first line is the issuing of the start command and this forces all slave devices on the bus to wait for their address. The next write command is the address of the slave. The following byte is the data being sent to the slave. All communication must terminate with a stop command or the line will remain open and no future communication is possible until the command is given.

i2c_start(); //begin transmission
i2c_write(0x14); //select address of device to communicate with
i2c_write(data); //send actual data
i2c_stop(); //terminate communication

Slave

For the Slave PIC, we first need to define the output pins, define the name of the device and force hardware I2C communication. This device was randomly assigned name 0x14, but could have been just about any even hex number with a few exceptions noted below code.

#use i2c(SLAVE, FAST, SCL=PIN_C3, SDA=PIN_C4, address=0x14, FORCE_HW) //make sure to include this line in any Slave I2C program

The SSP interrupt is used for I2C communication. When the master begins to transmit data, the PIC goes into this interrupt.

#INT_SSP //Interrupt for I2C activity
void sspinterupt()
{

The definition of state is to determine whether or not the master is requesting or sending data.

state = i2c_isr_state(); //Reading the type of transmission

State is less than 0x80 for all read operations.

if(state < 0x80) //Master is sending data
{
data = i2c_read(); //An array will be needed to store data if more than one byte is transferred
}

State will be equal to 0x80 for write commands.

if(state == 0x80) //Master is requesting data
{
i2c_write(data);
}
output_d(data); //Output data to port D to visualize
}

Somewhere in the main section of the program, probably right away, the SSP interrupt will need to be enabled.

enable_interrupts(INT_SSP);
enable_interrupts(GLOBAL);

Address exceptions:

0000 000 1 START byte - for slow micros without I2C h/w
0000 001 X CBUS address - a different bus protocol
0000 010 X Reserved for different bus format
0000 011 X Reserved for future purposes
0000 1XX X Hs-mode master code
1111 1XX X Reserved for future purposes
1111 0XX X 10-bit slave addressing

== Two Way Communication ==

An alternate circuit diagram is shown below with an analogue input on the slave and three switches.

[[image:I2C_Alternate_Circuit_Diagram|center|600px]]

Changes are made to the code to allow more than one bit of data as well as data transferred from the slave to the master.

[[Media:I2C_Alternate_Master.c|'''Alternate Master''']]

[[Media:I2C_Alternate_Slave.c|'''Alternate Slave''']]

Master

An alternate address of 0xa0 is used to demonstrate any address can be used.

To read from the slave, the first byte sent is the address of the slave. The second byte is the location of the data on the slave being requested. The communication is terminated before being restarted.

i2c_start (); //begin communication
i2c_write (0xa0); //send slave address
i2c_write (0x02); //request slave internal memory address for analogue data
i2c_stop(); //stop write cycle to shift to read cycle
i2c_start (); //send repeated start command to begin read cycle

Immediately after restarting, the address plus one read bit added is sent. The data requested previously is read and the communication is terminated.

i2c_write (0xa1); //add 1 to the address to send a read bit
result = i2c_read(0); //read analogue information from the slave
i2c_stop (); //terminate communication
output_d(result); //display analogue information from the slave

Slave

In this example a larger information buffer is used, an array of 0x03 bytes, but this can be as large as needed.

int address, buffer[0x03];

In the interrupt, most of the same code is used as before.

#INT_SSP
void ssp_interupt ()
{
state = i2c_isr_state();
if(state < 0x80) //master is sending data
{

The first command bit is empty, so nothing is done.

if(state == 0)
{
}

The first data byte returns state 1 and is the address to be written to.

if(state == 1) //first received byte is address
{
address = i2c_read();
}

The second data byte is the information being received from the master and is stored in the address sent in the first data byte.

if(state == 2) //second received byte is data
{
buffer[address] = i2c_read();
}
}

If the master is requesting data, the slave sends data from the requested address.

if(state == 0x80) //master is requesting data
{
i2c_write (buffer[address]); //send requested data
}
}

==More Information==

Phillips Brief on I2c: http://www.nxp.com/acrobat_download/literature/9398/39340011.pdf

An I2C Primer: http://www.i2c-bus.org/I2C-Primer.520.0.html

I2C communication between PICs

2008-02-18T06:05:21Z

Matt Turpin: /* Two Way Communication */

== Original Assignment ==

Microcontrollers commonly talk to each other using protocols such as RS-232, SPI (for "serial peripheral interface"), I2C (or I^2C, "I squared C," for inter-integrated circuit), CAN bus, or other. This project is to demonstrate bidirectional I2C communication between two PICs. A demonstration might have the value of an analog input (potentiometer) at one PIC displayed as a "light bar" on the LEDs of the other PIC board, and simultaneously vice-versa.

== Overview ==

I2C is pronounced "I squared C" and stands for Inter-Integrated Circuit. Is is a 2 line (plus common ground) communication method for one master device to control up to 112 slave devices. While it is possible to have multiple masters on the same I2c bus, this page will only deal with a one master configuration.

The two lines are named SCL and SDA where SCL is the CLock line and SDA is the DAta line. The PIC 4520 is designed to use pin 18 as SCL and pin 23 as SDA for hardware I2C. Note that pin 18 is one of the only pins not accessible on the prototyping board. An additional wire can be added as shown in the example image. I2C requires the lines to be high unless the master or the slave is pulling the line down, so you will need to use pull up resistors on both the clock and data lines.

An communication diagram is shown:

[[image:I2C_Data_Transfer.jpg|center]]

* S - As the master pulls down the data line, the falling edge of the data line signifies the start condition.
* P - As the master allows the data line to rise, the rising edge of the data line signifies the stop condition.
* B - Individual bits being transferred.

The data line can only change while the clock line is low. The data line is only read when the clock line is high and therefore 1 bit can be transferred per cycle of the clock line.

The master is initially sends a start bit followed by the 7-bit address of the slave it wishes to communicate with. The next bit represents whether it wishes to write(0) to or read(1) from the slave.

The slave then responds with an acknowledge bit. The transmission continues according to whether the master is attempting to read to or write from the device.

The master then ends the transmission with a stop bit. Another option is to send another start bit to continue the transfer in a combined message.

== Circuit ==

Below is a simple circuit diagram showing the master PIC with 2 close button switches. Note that pin 18 (RC3) is not brought out to the circuit board, but a wire can be soldered next to the PIC itself. Both SDA and SCL need pull up resistors as either the master or the slave can hold the line low to stop communication.
[[image:I2C Circuit Diagram.jpg|center|600px]]

Here is an example image of how to wire this.
[[image:I2C Wiring Image.jpg|center|600px]]

== Code ==
Code for master to slave transfer of one byte with switch de-bouncing can be found here:

[[Media:I2C_Master.c|'''Master Code''']]

[[Media:I2C_Slave.c|'''Slave Code''']]

Master

For the Master PIC, we first need to define the output pins and force hardware I2C communication.

#use I2C(FAST, SCL=PIN_C3, SDA=PIN_C4, FORCE_HW) //using hardware I2C, built into the PIC, make sure to include this line in any master I2C program

To communicate with a device, we use the following lines of code where 0x14 is the device name. The first line is the issuing of the start command and this forces all slave devices on the bus to wait for their address. The next write command is the address of the slave. The following byte is the data being sent to the slave. All communication must terminate with a stop command or the line will remain open and no future communication is possible until the command is given.

i2c_start(); //begin transmission
i2c_write(0x14); //select address of device to communicate with
i2c_write(data); //send actual data
i2c_stop(); //terminate communication

Slave

For the Slave PIC, we first need to define the output pins, define the name of the device and force hardware I2C communication. This device was randomly assigned name 0x14, but could have been just about any even hex number with a few exceptions noted below code.

#use i2c(SLAVE, FAST, SCL=PIN_C3, SDA=PIN_C4, address=0x14, FORCE_HW) //make sure to include this line in any Slave I2C program

The SSP interrupt is used for I2C communication. When the master begins to transmit data, the PIC goes into this interrupt.

#INT_SSP //Interrupt for I2C activity
void sspinterupt()
{

The definition of state is to determine whether or not the master is requesting or sending data.

state = i2c_isr_state(); //Reading the type of transmission

State is less than 0x80 for all read operations.

if(state < 0x80) //Master is sending data
{
data = i2c_read(); //An array will be needed to store data if more than one byte is transferred
}

State will be equal to 0x80 for write commands.

if(state == 0x80) //Master is requesting data
{
i2c_write(data);
}
output_d(data); //Output data to port D to visualize
}

Somewhere in the main section of the program, probably right away, the SSP interrupt will need to be enabled.

enable_interrupts(INT_SSP);
enable_interrupts(GLOBAL);

Address exceptions:

0000 000 1 START byte - for slow micros without I2C h/w
0000 001 X CBUS address - a different bus protocol
0000 010 X Reserved for different bus format
0000 011 X Reserved for future purposes
0000 1XX X Hs-mode master code
1111 1XX X Reserved for future purposes
1111 0XX X 10-bit slave addressing

== Two Way Communication ==

An alternate circuit diagram is shown below with an analogue input on the slave and three switches.

[[image:I2C_Alternate_Circuit_Diagram|center|600px]]

Changes are made to the code to allow more than one bit of data as well as data transferred from the slave to the master.

[[Media:I2C_Alternate_Master.c|'''Alternate Master''']]

[[Media:I2C_Alternate_Slave.c|'''Alternate Slave''']]

Master

An alternate address of 0xa0 is used to demonstrate any address can be used.

To read from the slave, the first byte sent is the address of the slave. The second byte is the location of the data on the slave being requested. The communication is terminated before being restarted.

i2c_start (); //begin communication
i2c_write (0xa0); //send slave address
i2c_write (0x02); //request slave internal memory address for analogue data
i2c_stop(); //stop write cycle to shift to read cycle
i2c_start (); //send repeated start command to begin read cycle

Immediately after restarting, the address plus one read bit added is sent. The data requested previously is read and the communication is terminated.

i2c_write (0xa1); //add 1 to the address to send a read bit
result = i2c_read(0); //read analogue information from the slave
i2c_stop (); //terminate communication
output_d(result); //display analogue information from the slave

Slave

In this example a larger information buffer is used, an array of 0x03 bytes, but this can be as large as needed.

int address, buffer[0x03];

In the interrupt, most of the same code is used as before.

#INT_SSP
void ssp_interupt ()
{
state = i2c_isr_state();
if(state < 0x80) //master is sending data
{

The first command bit is empty, so nothing is done.

if(state == 0)
{
}

The first data byte returns state 1 and is the address to be written to.

if(state == 1) //first received byte is address
{
address = i2c_read();
}

The second data byte is the information being received from the master and is stored in the address sent in the first data byte.

if(state == 2) //second received byte is data
{
buffer[address] = i2c_read();
}
}

If the master is requesting data, the slave sends data from the requested address.

if(state == 0x80) //master is requesting data
{
i2c_write (buffer[address]); //send requested data
}
}

I2C communication between PICs

2008-02-18T05:50:42Z

Matt Turpin: /* Code */

== Original Assignment ==

Microcontrollers commonly talk to each other using protocols such as RS-232, SPI (for "serial peripheral interface"), I2C (or I^2C, "I squared C," for inter-integrated circuit), CAN bus, or other. This project is to demonstrate bidirectional I2C communication between two PICs. A demonstration might have the value of an analog input (potentiometer) at one PIC displayed as a "light bar" on the LEDs of the other PIC board, and simultaneously vice-versa.

== Overview ==

I2C is pronounced "I squared C" and stands for Inter-Integrated Circuit. Is is a 2 line (plus common ground) communication method for one master device to control up to 112 slave devices. While it is possible to have multiple masters on the same I2c bus, this page will only deal with a one master configuration.

The two lines are named SCL and SDA where SCL is the CLock line and SDA is the DAta line. The PIC 4520 is designed to use pin 18 as SCL and pin 23 as SDA for hardware I2C. Note that pin 18 is one of the only pins not accessible on the prototyping board. An additional wire can be added as shown in the example image. I2C requires the lines to be high unless the master or the slave is pulling the line down, so you will need to use pull up resistors on both the clock and data lines.

An communication diagram is shown:

[[image:I2C_Data_Transfer.jpg|center]]

* S - As the master pulls down the data line, the falling edge of the data line signifies the start condition.
* P - As the master allows the data line to rise, the rising edge of the data line signifies the stop condition.
* B - Individual bits being transferred.

The data line can only change while the clock line is low. The data line is only read when the clock line is high and therefore 1 bit can be transferred per cycle of the clock line.

The master is initially sends a start bit followed by the 7-bit address of the slave it wishes to communicate with. The next bit represents whether it wishes to write(0) to or read(1) from the slave.

The slave then responds with an acknowledge bit. The transmission continues according to whether the master is attempting to read to or write from the device.

The master then ends the transmission with a stop bit. Another option is to send another start bit to continue the transfer in a combined message.

== Circuit ==

Below is a simple circuit diagram showing the master PIC with 2 close button switches. Note that pin 18 (RC3) is not brought out to the circuit board, but a wire can be soldered next to the PIC itself. Both SDA and SCL need pull up resistors as either the master or the slave can hold the line low to stop communication.
[[image:I2C Circuit Diagram.jpg|center|600px]]

Here is an example image of how to wire this.
[[image:I2C Wiring Image.jpg|center|600px]]

== Code ==
Code for master to slave transfer of one byte with switch de-bouncing can be found here:

[[Media:I2C_Master.c|'''Master Code''']]

[[Media:I2C_Slave.c|'''Slave Code''']]

Master

For the Master PIC, we first need to define the output pins and force hardware I2C communication.

#use I2C(FAST, SCL=PIN_C3, SDA=PIN_C4, FORCE_HW) //using hardware I2C, built into the PIC, make sure to include this line in any master I2C program

To communicate with a device, we use the following lines of code where 0x14 is the device name. The first line is the issuing of the start command and this forces all slave devices on the bus to wait for their address. The next write command is the address of the slave. The following byte is the data being sent to the slave. All communication must terminate with a stop command or the line will remain open and no future communication is possible until the command is given.

i2c_start(); //begin transmission
i2c_write(0x14); //select address of device to communicate with
i2c_write(data); //send actual data
i2c_stop(); //terminate communication

Slave

For the Slave PIC, we first need to define the output pins, define the name of the device and force hardware I2C communication. This device was randomly assigned name 0x14, but could have been just about any even hex number with a few exceptions noted below code.

#use i2c(SLAVE, FAST, SCL=PIN_C3, SDA=PIN_C4, address=0x14, FORCE_HW) //make sure to include this line in any Slave I2C program

The SSP interrupt is used for I2C communication. When the master begins to transmit data, the PIC goes into this interrupt.

#INT_SSP //Interrupt for I2C activity
void sspinterupt()
{

The definition of state is to determine whether or not the master is requesting or sending data.

state = i2c_isr_state(); //Reading the type of transmission

State is less than 0x80 for all read operations.

if(state < 0x80) //Master is sending data
{
data = i2c_read(); //An array will be needed to store data if more than one byte is transferred
}

State will be equal to 0x80 for write commands.

if(state == 0x80) //Master is requesting data
{
i2c_write(data);
}
output_d(data); //Output data to port D to visualize
}

Somewhere in the main section of the program, probably right away, the SSP interrupt will need to be enabled.

enable_interrupts(INT_SSP);
enable_interrupts(GLOBAL);

Address exceptions:

0000 000 1 START byte - for slow micros without I2C h/w
0000 001 X CBUS address - a different bus protocol
0000 010 X Reserved for different bus format
0000 011 X Reserved for future purposes
0000 1XX X Hs-mode master code
1111 1XX X Reserved for future purposes
1111 0XX X 10-bit slave addressing

== Two Way Communication ==

An alternate circuit diagram is shown below.

[[image:I2C_Alternate_Circuit_Diagram|center|600px]]

Changes are made to the code to allow more than one bit of data as well as data transferred from the slave to the master.

[[Media:I2C_Alternate_Master.c|'''Alternate Master''']]

[[Media:I2C_Alternate_Slave.c|'''Alternate Slave''']]

Master

An alternate address of 0xa0 is used to demonstrate any address can be used.

To read from the slave, the first byte sent is the address of the slave. The second byte is the location of the data on the slave being requested. The communication is terminated before being restarted.

i2c_start (); //begin communication
i2c_write (0xa0); //send slave address
i2c_write (0x02); //request slave internal memory address for analogue data
i2c_stop(); //stop write cycle to shift to read cycle
i2c_start (); //send repeated start command to begin read cycle

Immediately after restarting, the address plus one read bit added is sent. The data requested previously is read and the communication is terminated.

i2c_write (0xa1); //add 1 to the address to send a read bit
result = i2c_read(0); //read analogue information from the slave
i2c_stop (); //terminate communication
output_d(result); //display analogue information from the slave

Slave

In this example a larger information buffer is used, an array of 0x03 bytes, but this can be as large as needed.

int address, buffer[0x03];

In the interrupt, most of the same code is used as before.

#INT_SSP
void ssp_interupt ()
{
state = i2c_isr_state();
if(state < 0x80) //master is sending data
{

the first command bit is empty, so nothing is done.

if(state == 0)
{
}

The first data byte returns state 1 and is the address to be written to.

if(state == 1) //first received byte is address
{
address = i2c_read();
}

The second data byte is the information being received from the master and is stored in the address sent in the first data byte.

if(state == 2) //second received byte is data
{
buffer[address] = i2c_read();
}
}

If the master is requesting data, the slave sends data from the requested address.

if(state == 0x80) //master is requesting data
{
i2c_write (buffer[address]); //send requested data
}
}

I2C communication between PICs

2008-02-18T03:12:53Z

Matt Turpin: /* Overview */

== Original Assignment ==

Microcontrollers commonly talk to each other using protocols such as RS-232, SPI (for "serial peripheral interface"), I2C (or I^2C, "I squared C," for inter-integrated circuit), CAN bus, or other. This project is to demonstrate bidirectional I2C communication between two PICs. A demonstration might have the value of an analog input (potentiometer) at one PIC displayed as a "light bar" on the LEDs of the other PIC board, and simultaneously vice-versa.

== Overview ==

I2C is pronounced "I squared C" and stands for Inter-Integrated Circuit. Is is a 2 line (plus common ground) communication method for one master device to control up to 112 slave devices. While it is possible to have multiple masters on the same I2c bus, this page will only deal with a one master configuration.

The two lines are named SCL and SDA where SCL is the CLock line and SDA is the DAta line. The PIC 4520 is designed to use pin 18 as SCL and pin 23 as SDA for hardware I2C. Note that pin 18 is one of the only pins not accessible on the prototyping board. An additional wire can be added as shown in the example image. I2C requires the lines to be high unless the master or the slave is pulling the line down, so you will need to use pull up resistors on both the clock and data lines.

An communication diagram is shown:

[[image:I2C_Data_Transfer.jpg|center]]

* S - As the master pulls down the data line, the falling edge of the data line signifies the start condition.
* P - As the master allows the data line to rise, the rising edge of the data line signifies the stop condition.
* B - Individual bits being transferred.

The data line can only change while the clock line is low. The data line is only read when the clock line is high and therefore 1 bit can be transferred per cycle of the clock line.

The master is initially sends a start bit followed by the 7-bit address of the slave it wishes to communicate with. The next bit represents whether it wishes to write(0) to or read(1) from the slave.

The slave then responds with an acknowledge bit. The transmission continues according to whether the master is attempting to read to or write from the device.

The master then ends the transmission with a stop bit. Another option is to send another start bit to continue the transfer in a combined message.

== Circuit ==

Below is a simple circuit diagram showing the master PIC with 2 close button switches. Note that pin 18 (RC3) is not brought out to the circuit board, but a wire can be soldered next to the PIC itself. Both SDA and SCL need pull up resistors as either the master or the slave can hold the line low to stop communication.
[[image:I2C Circuit Diagram.jpg|center|600px]]

Here is an example image of how to wire this.
[[image:I2C Wiring Image.jpg|center|600px]]

== Code ==
Code for master to slave transfer of one byte with switch de-bouncing can be found here:

[[Media:I2C_Master.c|'''Master Code''']]

[[Media:I2C_Slave.c|'''Slave Code''']]

Master

For the Master PIC, we first need to define the output pins and force hardware I2C communication.

#use I2C(FAST, SCL=PIN_C3, SDA=PIN_C4, FORCE_HW) //using hardware I2C, built into the PIC, make sure to include this line in any master I2C program

To communicate with a device, we use the following lines of code where 0x14 is the device name.

i2c_start(); //begin transmission
i2c_write(0x14); //select address of device to communicate with
i2c_write(data); //send actual data
i2c_stop(); //terminate communication

Slave

For the Slave PIC, we first need to define the output pins, define the name of the device and force hardware I2C communication. This device was randomly assigned name 0x14, but could have been just about any even hex number with a few exceptions noted below code.

#use i2c(SLAVE, FAST, SCL=PIN_C3, SDA=PIN_C4, address=0x14, FORCE_HW) //make sure to include this line in any Slave I2C program

The SSP interrupt is used for I2C communication. When the master begins to transmit data, the PIC goes into this interrupt.

#INT_SSP //Interrupt for I2C activity
void sspinterupt()
{
state = i2c_isr_state(); //Reading the type of transmission

if(state < 0x80) //Master is sending data
{
data = i2c_read(); //An array will be needed to store data if more than one byte is transferred
}
if(state == 0x80) //Master is requesting data
{
i2c_write(data);
}
output_d(data); //Output data to port D to visualize
}

Somewhere in the main section of the program, probably right away, the SSP interrupt will need to be enabled.

enable_interrupts(INT_SSP);
enable_interrupts(GLOBAL);

Address exceptions:

0000 000 1 START byte - for slow micros without I2C h/w
0000 001 X CBUS address - a different bus protocol
0000 010 X Reserved for different bus format
0000 011 X Reserved for future purposes
0000 1XX X Hs-mode master code
1111 1XX X Reserved for future purposes
1111 0XX X 10-bit slave addressing

== Two Way Communication ==

An alternate circuit diagram is shown below.

[[image:I2C_Alternate_Circuit_Diagram|center|600px]]

Changes are made to the code to allow more than one bit of data as well as data transferred from the slave to the master.

[[Media:I2C_Alternate_Master.c|'''Alternate Master''']]

[[Media:I2C_Alternate_Slave.c|'''Alternate Slave''']]

Master

An alternate address of 0xa0 is used to demonstrate any address can be used.

To read from the slave, the first byte sent is the address of the slave. The second byte is the location of the data on the slave being requested. The communication is terminated before being restarted.

i2c_start (); //begin communication
i2c_write (0xa0); //send slave address
i2c_write (0x02); //request slave internal memory address for analogue data
i2c_stop(); //stop write cycle to shift to read cycle
i2c_start (); //send repeated start command to begin read cycle

Immediately after restarting, the address plus one read bit added is sent. The data requested previously is read and the communication is terminated.

i2c_write (0xa1); //add 1 to the address to send a read bit
result = i2c_read(0); //read analogue information from the slave
i2c_stop (); //terminate communication
output_d(result); //display analogue information from the slave

Slave

In this example a larger information buffer is used, an array of 0x03 bytes, but this can be as large as needed.

int address, buffer[0x03];

In the interrupt, most of the same code is used as before.

#INT_SSP
void ssp_interupt ()
{
state = i2c_isr_state();
if(state < 0x80) //master is sending data
{

the first command bit is empty, so nothing is done.

if(state == 0)
{
}

The first data byte returns state 1 and is the address to be written to.

if(state == 1) //first received byte is address
{
address = i2c_read();
}

The second data byte is the information being received from the master and is stored in the address sent in the first data byte.

if(state == 2) //second received byte is data
{
buffer[address] = i2c_read();
}
}

If the master is requesting data, the slave sends data from the requested address.

if(state == 0x80) //master is requesting data
{
i2c_write (buffer[address]); //send requested data
}
}

I2C communication between PICs

2008-02-18T03:02:16Z

Matt Turpin: /* Overview */

== Original Assignment ==

Microcontrollers commonly talk to each other using protocols such as RS-232, SPI (for "serial peripheral interface"), I2C (or I^2C, "I squared C," for inter-integrated circuit), CAN bus, or other. This project is to demonstrate bidirectional I2C communication between two PICs. A demonstration might have the value of an analog input (potentiometer) at one PIC displayed as a "light bar" on the LEDs of the other PIC board, and simultaneously vice-versa.

== Overview ==

I2C is pronounced "I squared C" and stands for Inter-Integrated Circuit. Is is a 2 line (plus common ground) communication method for one master device to control up to 112 slave devices. While it is possible to have multiple masters on the same I2c bus, this page will only deal with a one master configuration.

The two lines are named SCL and SDA where SCL is the CLock line and SDA is the DAta line. The PIC 4520 is designed to use pin 18 as SCL and pin 23 as SDA for hardware I2C. Note that pin 18 is one of the only pins not accessible on the prototyping board. An additional wire can be added as shown below.

An example communication diagram is shown below

[[image:I2C_Data_Transfer.jpg|center]]

* S - As the master pulls down the data line, the falling edge of the data line signifies the start condition.
* P - As the master allows the data line to rise, the rising edge of the data line signifies the stop condition.

The data line can only change while the clock line is low. The data line is only read when the clock line is high and therefore 1 bit can be transferred per cycle of the clock line.

The master is initially sends a start bit followed by the 7-bit address of the slave it wishes to communicate with. The next bit represents whether it wishes to write(0) to or read(1) from the slave.

The slave then responds with an acknowledge bit. The transmission continues according to whether the master is attempting to read to or write from the device.

The master then ends the transmission with a stop bit. Another option is to send another start bit to continue the transfer in a combined message.

== Circuit ==

Below is a simple circuit diagram showing the master PIC with 2 close button switches. Note that pin 18 (RC3) is not brought out to the circuit board, but a wire can be soldered next to the PIC itself. Both SDA and SCL need pull up resistors as either the master or the slave can hold the line low to stop communication.
[[image:I2C Circuit Diagram.jpg|center|600px]]

Here is an example image of how to wire this.
[[image:I2C Wiring Image.jpg|center|600px]]

== Code ==
Code for master to slave transfer of one byte with switch de-bouncing can be found here:

[[Media:I2C_Master.c|'''Master Code''']]

[[Media:I2C_Slave.c|'''Slave Code''']]

Master

For the Master PIC, we first need to define the output pins and force hardware I2C communication.

#use I2C(FAST, SCL=PIN_C3, SDA=PIN_C4, FORCE_HW) //using hardware I2C, built into the PIC, make sure to include this line in any master I2C program

To communicate with a device, we use the following lines of code where 0x14 is the device name.

i2c_start(); //begin transmission
i2c_write(0x14); //select address of device to communicate with
i2c_write(data); //send actual data
i2c_stop(); //terminate communication

Slave

For the Slave PIC, we first need to define the output pins, define the name of the device and force hardware I2C communication. This device was randomly assigned name 0x14, but could have been just about any even hex number with a few exceptions noted below code.

#use i2c(SLAVE, FAST, SCL=PIN_C3, SDA=PIN_C4, address=0x14, FORCE_HW) //make sure to include this line in any Slave I2C program

The SSP interrupt is used for I2C communication. When the master begins to transmit data, the PIC goes into this interrupt.

#INT_SSP //Interrupt for I2C activity
void sspinterupt()
{
state = i2c_isr_state(); //Reading the type of transmission

if(state < 0x80) //Master is sending data
{
data = i2c_read(); //An array will be needed to store data if more than one byte is transferred
}
if(state == 0x80) //Master is requesting data
{
i2c_write(data);
}
output_d(data); //Output data to port D to visualize
}

Somewhere in the main section of the program, probably right away, the SSP interrupt will need to be enabled.

enable_interrupts(INT_SSP);
enable_interrupts(GLOBAL);

Address exceptions:

0000 000 1 START byte - for slow micros without I2C h/w
0000 001 X CBUS address - a different bus protocol
0000 010 X Reserved for different bus format
0000 011 X Reserved for future purposes
0000 1XX X Hs-mode master code
1111 1XX X Reserved for future purposes
1111 0XX X 10-bit slave addressing

== Two Way Communication ==

An alternate circuit diagram is shown below.

[[image:I2C_Alternate_Circuit_Diagram|center|600px]]

Changes are made to the code to allow more than one bit of data as well as data transferred from the slave to the master.

[[Media:I2C_Alternate_Master.c|'''Alternate Master''']]

[[Media:I2C_Alternate_Slave.c|'''Alternate Slave''']]

Master

An alternate address of 0xa0 is used to demonstrate any address can be used.

To read from the slave, the first byte sent is the address of the slave. The second byte is the location of the data on the slave being requested. The communication is terminated before being restarted.

i2c_start (); //begin communication
i2c_write (0xa0); //send slave address
i2c_write (0x02); //request slave internal memory address for analogue data
i2c_stop(); //stop write cycle to shift to read cycle
i2c_start (); //send repeated start command to begin read cycle

Immediately after restarting, the address plus one read bit added is sent. The data requested previously is read and the communication is terminated.

i2c_write (0xa1); //add 1 to the address to send a read bit
result = i2c_read(0); //read analogue information from the slave
i2c_stop (); //terminate communication
output_d(result); //display analogue information from the slave

Slave

In this example a larger information buffer is used, an array of 0x03 bytes, but this can be as large as needed.

int address, buffer[0x03];

In the interrupt, most of the same code is used as before.

#INT_SSP
void ssp_interupt ()
{
state = i2c_isr_state();
if(state < 0x80) //master is sending data
{

the first command bit is empty, so nothing is done.

if(state == 0)
{
}

The first data byte returns state 1 and is the address to be written to.

if(state == 1) //first received byte is address
{
address = i2c_read();
}

The second data byte is the information being received from the master and is stored in the address sent in the first data byte.

if(state == 2) //second received byte is data
{
buffer[address] = i2c_read();
}
}

If the master is requesting data, the slave sends data from the requested address.

if(state == 0x80) //master is requesting data
{
i2c_write (buffer[address]); //send requested data
}
}

I2C communication between PICs

2008-02-18T03:01:51Z

Matt Turpin: /* Overview */

== Original Assignment ==

Microcontrollers commonly talk to each other using protocols such as RS-232, SPI (for "serial peripheral interface"), I2C (or I^2C, "I squared C," for inter-integrated circuit), CAN bus, or other. This project is to demonstrate bidirectional I2C communication between two PICs. A demonstration might have the value of an analog input (potentiometer) at one PIC displayed as a "light bar" on the LEDs of the other PIC board, and simultaneously vice-versa.

== Overview ==

I2C is pronounced "I squared C" and stands for Inter-Integrated Circuit. Is is a 2 line (plus common ground) communication method for one master device to control up to 112 slave devices. While it is possible to have multiple masters on the same I2c bus, this page will only deal with a one master configuration.

The two lines are named SCL and SDA where SCL is the CLock line and SDA is the DAta line. The PIC 4520 is designed to use pin 18 as SCL and pin 23 as SDA for hardware I2C. Note that pin 18 is one of the only pins not accessible on the prototyping board. An additional wire can be added as shown below.

An example communication diagram is shown below

[[image:I2C_Data_Transfer.jpg|center]]

S - As the master pulls down the data line, the falling edge of the data line signifies the start condition.
P - As the master allows the data line to rise, the rising edge of the data line signifies the stop condition.

The data line can only change while the clock line is low. The data line is only read when the clock line is high and therefore 1 bit can be transferred per cycle of the clock line.

The master is initially sends a start bit followed by the 7-bit address of the slave it wishes to communicate with. The next bit represents whether it wishes to write(0) to or read(1) from the slave.

The slave then responds with an acknowledge bit. The transmission continues according to whether the master is attempting to read to or write from the device.

The master then ends the transmission with a stop bit. Another option is to send another start bit to continue the transfer in a combined message.

== Circuit ==

Below is a simple circuit diagram showing the master PIC with 2 close button switches. Note that pin 18 (RC3) is not brought out to the circuit board, but a wire can be soldered next to the PIC itself. Both SDA and SCL need pull up resistors as either the master or the slave can hold the line low to stop communication.
[[image:I2C Circuit Diagram.jpg|center|600px]]

Here is an example image of how to wire this.
[[image:I2C Wiring Image.jpg|center|600px]]

== Code ==
Code for master to slave transfer of one byte with switch de-bouncing can be found here:

[[Media:I2C_Master.c|'''Master Code''']]

[[Media:I2C_Slave.c|'''Slave Code''']]

Master

For the Master PIC, we first need to define the output pins and force hardware I2C communication.

#use I2C(FAST, SCL=PIN_C3, SDA=PIN_C4, FORCE_HW) //using hardware I2C, built into the PIC, make sure to include this line in any master I2C program

To communicate with a device, we use the following lines of code where 0x14 is the device name.

i2c_start(); //begin transmission
i2c_write(0x14); //select address of device to communicate with
i2c_write(data); //send actual data
i2c_stop(); //terminate communication

Slave

For the Slave PIC, we first need to define the output pins, define the name of the device and force hardware I2C communication. This device was randomly assigned name 0x14, but could have been just about any even hex number with a few exceptions noted below code.

#use i2c(SLAVE, FAST, SCL=PIN_C3, SDA=PIN_C4, address=0x14, FORCE_HW) //make sure to include this line in any Slave I2C program

The SSP interrupt is used for I2C communication. When the master begins to transmit data, the PIC goes into this interrupt.

#INT_SSP //Interrupt for I2C activity
void sspinterupt()
{
state = i2c_isr_state(); //Reading the type of transmission

if(state < 0x80) //Master is sending data
{
data = i2c_read(); //An array will be needed to store data if more than one byte is transferred
}
if(state == 0x80) //Master is requesting data
{
i2c_write(data);
}
output_d(data); //Output data to port D to visualize
}

Somewhere in the main section of the program, probably right away, the SSP interrupt will need to be enabled.

enable_interrupts(INT_SSP);
enable_interrupts(GLOBAL);

Address exceptions:

0000 000 1 START byte - for slow micros without I2C h/w
0000 001 X CBUS address - a different bus protocol
0000 010 X Reserved for different bus format
0000 011 X Reserved for future purposes
0000 1XX X Hs-mode master code
1111 1XX X Reserved for future purposes
1111 0XX X 10-bit slave addressing

== Two Way Communication ==

An alternate circuit diagram is shown below.

[[image:I2C_Alternate_Circuit_Diagram|center|600px]]

Changes are made to the code to allow more than one bit of data as well as data transferred from the slave to the master.

[[Media:I2C_Alternate_Master.c|'''Alternate Master''']]

[[Media:I2C_Alternate_Slave.c|'''Alternate Slave''']]

Master

An alternate address of 0xa0 is used to demonstrate any address can be used.

To read from the slave, the first byte sent is the address of the slave. The second byte is the location of the data on the slave being requested. The communication is terminated before being restarted.

i2c_start (); //begin communication
i2c_write (0xa0); //send slave address
i2c_write (0x02); //request slave internal memory address for analogue data
i2c_stop(); //stop write cycle to shift to read cycle
i2c_start (); //send repeated start command to begin read cycle

Immediately after restarting, the address plus one read bit added is sent. The data requested previously is read and the communication is terminated.

i2c_write (0xa1); //add 1 to the address to send a read bit
result = i2c_read(0); //read analogue information from the slave
i2c_stop (); //terminate communication
output_d(result); //display analogue information from the slave

Slave

In this example a larger information buffer is used, an array of 0x03 bytes, but this can be as large as needed.

int address, buffer[0x03];

In the interrupt, most of the same code is used as before.

#INT_SSP
void ssp_interupt ()
{
state = i2c_isr_state();
if(state < 0x80) //master is sending data
{

the first command bit is empty, so nothing is done.

if(state == 0)
{
}

The first data byte returns state 1 and is the address to be written to.

if(state == 1) //first received byte is address
{
address = i2c_read();
}

The second data byte is the information being received from the master and is stored in the address sent in the first data byte.

if(state == 2) //second received byte is data
{
buffer[address] = i2c_read();
}
}

If the master is requesting data, the slave sends data from the requested address.

if(state == 0x80) //master is requesting data
{
i2c_write (buffer[address]); //send requested data
}
}

I2C communication between PICs

2008-02-18T02:59:22Z

Matt Turpin: /* Overview */

== Original Assignment ==

Microcontrollers commonly talk to each other using protocols such as RS-232, SPI (for "serial peripheral interface"), I2C (or I^2C, "I squared C," for inter-integrated circuit), CAN bus, or other. This project is to demonstrate bidirectional I2C communication between two PICs. A demonstration might have the value of an analog input (potentiometer) at one PIC displayed as a "light bar" on the LEDs of the other PIC board, and simultaneously vice-versa.

== Overview ==

I2C is pronounced "I squared C" and stands for Inter-Integrated Circuit. Is is a 2 line (plus common ground) communication method for one master device to control up to 112 slave devices. While it is possible to have multiple masters on the same I2c bus, this page will only deal with a one master configuration.

The two lines are named SCL and SDA where SCL is the CLock line and SDA is the DAta line. The PIC 4520 is designed to use pin 18 as SCL and pin 23 as SDA for hardware I2C. Note that pin 18 is one of the only pins not accessible on the prototyping board. An additional wire can be added as shown below.

An example communication diagram is shown below

[[image:I2C_Data_Transfer.jpg|center]]

S - Start condition; P - Stop condition; B - One bit transferred

The data line can only change while the clock line is low. The data line is only read when the clock line is high and therefore 1 bit can be transferred per cycle of the clock line.

The master is initially sends a start bit followed by the 7-bit address of the slave it wishes to communicate with. The next bit represents whether it wishes to write(0) to or read(1) from the slave.

The slave then responds with an acknowledge bit. The transmission continues according to whether the master is attempting to read to or write from the device.

The master then ends the transmission with a stop bit. Another option is to send another start bit to continue the transfer in a combined message.

== Circuit ==

Below is a simple circuit diagram showing the master PIC with 2 close button switches. Note that pin 18 (RC3) is not brought out to the circuit board, but a wire can be soldered next to the PIC itself. Both SDA and SCL need pull up resistors as either the master or the slave can hold the line low to stop communication.
[[image:I2C Circuit Diagram.jpg|center|600px]]

Here is an example image of how to wire this.
[[image:I2C Wiring Image.jpg|center|600px]]

== Code ==
Code for master to slave transfer of one byte with switch de-bouncing can be found here:

[[Media:I2C_Master.c|'''Master Code''']]

[[Media:I2C_Slave.c|'''Slave Code''']]

Master

For the Master PIC, we first need to define the output pins and force hardware I2C communication.

#use I2C(FAST, SCL=PIN_C3, SDA=PIN_C4, FORCE_HW) //using hardware I2C, built into the PIC, make sure to include this line in any master I2C program

To communicate with a device, we use the following lines of code where 0x14 is the device name.

i2c_start(); //begin transmission
i2c_write(0x14); //select address of device to communicate with
i2c_write(data); //send actual data
i2c_stop(); //terminate communication

Slave

For the Slave PIC, we first need to define the output pins, define the name of the device and force hardware I2C communication. This device was randomly assigned name 0x14, but could have been just about any even hex number with a few exceptions noted below code.

#use i2c(SLAVE, FAST, SCL=PIN_C3, SDA=PIN_C4, address=0x14, FORCE_HW) //make sure to include this line in any Slave I2C program

The SSP interrupt is used for I2C communication. When the master begins to transmit data, the PIC goes into this interrupt.

#INT_SSP //Interrupt for I2C activity
void sspinterupt()
{
state = i2c_isr_state(); //Reading the type of transmission

if(state < 0x80) //Master is sending data
{
data = i2c_read(); //An array will be needed to store data if more than one byte is transferred
}
if(state == 0x80) //Master is requesting data
{
i2c_write(data);
}
output_d(data); //Output data to port D to visualize
}

Somewhere in the main section of the program, probably right away, the SSP interrupt will need to be enabled.

enable_interrupts(INT_SSP);
enable_interrupts(GLOBAL);

Address exceptions:

0000 000 1 START byte - for slow micros without I2C h/w
0000 001 X CBUS address - a different bus protocol
0000 010 X Reserved for different bus format
0000 011 X Reserved for future purposes
0000 1XX X Hs-mode master code
1111 1XX X Reserved for future purposes
1111 0XX X 10-bit slave addressing

== Two Way Communication ==

An alternate circuit diagram is shown below.

[[image:I2C_Alternate_Circuit_Diagram|center|600px]]

Changes are made to the code to allow more than one bit of data as well as data transferred from the slave to the master.

[[Media:I2C_Alternate_Master.c|'''Alternate Master''']]

[[Media:I2C_Alternate_Slave.c|'''Alternate Slave''']]

Master

An alternate address of 0xa0 is used to demonstrate any address can be used.

To read from the slave, the first byte sent is the address of the slave. The second byte is the location of the data on the slave being requested. The communication is terminated before being restarted.

i2c_start (); //begin communication
i2c_write (0xa0); //send slave address
i2c_write (0x02); //request slave internal memory address for analogue data
i2c_stop(); //stop write cycle to shift to read cycle
i2c_start (); //send repeated start command to begin read cycle

Immediately after restarting, the address plus one read bit added is sent. The data requested previously is read and the communication is terminated.

i2c_write (0xa1); //add 1 to the address to send a read bit
result = i2c_read(0); //read analogue information from the slave
i2c_stop (); //terminate communication
output_d(result); //display analogue information from the slave

Slave

In this example a larger information buffer is used, an array of 0x03 bytes, but this can be as large as needed.

int address, buffer[0x03];

In the interrupt, most of the same code is used as before.

#INT_SSP
void ssp_interupt ()
{
state = i2c_isr_state();
if(state < 0x80) //master is sending data
{

the first command bit is empty, so nothing is done.

if(state == 0)
{
}

The first data byte returns state 1 and is the address to be written to.

if(state == 1) //first received byte is address
{
address = i2c_read();
}

The second data byte is the information being received from the master and is stored in the address sent in the first data byte.

if(state == 2) //second received byte is data
{
buffer[address] = i2c_read();
}
}

If the master is requesting data, the slave sends data from the requested address.

if(state == 0x80) //master is requesting data
{
i2c_write (buffer[address]); //send requested data
}
}

File:I2C Data Transfer.jpg

2008-02-18T02:58:44Z

Matt Turpin:

A sequence diagram of data transfer on the I²C bus S - Start condition; P - Stop condition; B - One bit transferred; data changes allowed when clock low (blue)

Thanks to Marcin Floryan from http://en.wikipedia.org/wiki/Image:I2C_data_transfer.svg for releasing this image into the public domain.

I2C communication between PICs

2008-02-11T17:38:00Z

Matt Turpin: /* Circuit */

== Original Assignment ==

Microcontrollers commonly talk to each other using protocols such as RS-232, SPI (for "serial peripheral interface"), I2C (or I^2C, "I squared C," for inter-integrated circuit), CAN bus, or other. This project is to demonstrate bidirectional I2C communication between two PICs. A demonstration might have the value of an analog input (potentiometer) at one PIC displayed as a "light bar" on the LEDs of the other PIC board, and simultaneously vice-versa.

== Overview ==

I2C is pronounced "I squared C" and stands for Inter-Integrated Circuit. Is is a 2 line (plus common ground) communication method for one master device to control up to 112 slave devices. While it is possible to have multiple masters on the same I2c bus, this page will only deal with a one master configuration.

The two lines are named SCL and SDA where SCL is the CLock line and SDA is the DAta line. The PIC 4520 is designed to use pin 18 as SCL and pin 23 as SDA for hardware I2C. Note that pin 18 is one of the only pins not accessible on the prototyping board. An additional wire can be added as shown below.

An example communication diagram is shown below

[[image:I2C_Data_Transfer.jpg|center]]

S - Start condition; P - Stop condition; B - One bit transferred; data changes allowed when clock low (blue)

The master is initially sends a start bit followed by the 7-bit address of the slave it wishes to communicate with. The next bit represents whether it wishes to write(0) to or read(1) from the slave.

The slave then responds with an acknowledge bit. The transmission continues according to whether the master is attempting to read to or write from the device.

The master then ends the transmission with a stop bit. Another option is to send another start bit to continue the transfer in a combined message.

== Circuit ==

Below is a simple circuit diagram showing the master PIC with 2 close button switches. Note that pin 18 (RC3) is not brought out to the circuit board, but a wire can be soldered next to the PIC itself. Both SDA and SCL need pull up resistors as either the master or the slave can hold the line low to stop communication.
[[image:I2C Circuit Diagram.jpg|center|600px]]

Here is an example image of how to wire this.
[[image:I2C Wiring Image.jpg|center|600px]]

== Code ==
Code for master to slave transfer of one byte with switch de-bouncing can be found here:

[[Media:I2C_Master.c|'''Master Code''']]

[[Media:I2C_Slave.c|'''Slave Code''']]

Master

For the Master PIC, we first need to define the output pins and force hardware I2C communication.

#use I2C(FAST, SCL=PIN_C3, SDA=PIN_C4, FORCE_HW) //using hardware I2C, built into the PIC, make sure to include this line in any master I2C program

To communicate with a device, we use the following lines of code where 0x14 is the device name.

i2c_start(); //begin transmission
i2c_write(0x14); //select address of device to communicate with
i2c_write(data); //send actual data
i2c_stop(); //terminate communication

Slave

For the Slave PIC, we first need to define the output pins, define the name of the device and force hardware I2C communication. This device was randomly assigned name 0x14, but could have been just about any even hex number with a few exceptions noted below code.

#use i2c(SLAVE, FAST, SCL=PIN_C3, SDA=PIN_C4, address=0x14, FORCE_HW) //make sure to include this line in any Slave I2C program

The SSP interrupt is used for I2C communication. When the master begins to transmit data, the PIC goes into this interrupt.

#INT_SSP //Interrupt for I2C activity
void sspinterupt()
{
state = i2c_isr_state(); //Reading the type of transmission

if(state < 0x80) //Master is sending data
{
data = i2c_read(); //An array will be needed to store data if more than one byte is transferred
}
if(state == 0x80) //Master is requesting data
{
i2c_write(data);
}
output_d(data); //Output data to port D to visualize
}

Somewhere in the main section of the program, probably right away, the SSP interrupt will need to be enabled.

enable_interrupts(INT_SSP);
enable_interrupts(GLOBAL);

Address exceptions:

0000 000 1 START byte - for slow micros without I2C h/w
0000 001 X CBUS address - a different bus protocol
0000 010 X Reserved for different bus format
0000 011 X Reserved for future purposes
0000 1XX X Hs-mode master code
1111 1XX X Reserved for future purposes
1111 0XX X 10-bit slave addressing

== Two Way Communication ==

An alternate circuit diagram is shown below.

[[image:I2C_Alternate_Circuit_Diagram|center|600px]]

Changes are made to the code to allow more than one bit of data as well as data transferred from the slave to the master.

[[Media:I2C_Alternate_Master.c|'''Alternate Master''']]

[[Media:I2C_Alternate_Slave.c|'''Alternate Slave''']]

Master

An alternate address of 0xa0 is used to demonstrate any address can be used.

To read from the slave, the first byte sent is the address of the slave. The second byte is the location of the data on the slave being requested. The communication is terminated before being restarted.

i2c_start (); //begin communication
i2c_write (0xa0); //send slave address
i2c_write (0x02); //request slave internal memory address for analogue data
i2c_stop(); //stop write cycle to shift to read cycle
i2c_start (); //send repeated start command to begin read cycle

Immediately after restarting, the address plus one read bit added is sent. The data requested previously is read and the communication is terminated.

i2c_write (0xa1); //add 1 to the address to send a read bit
result = i2c_read(0); //read analogue information from the slave
i2c_stop (); //terminate communication
output_d(result); //display analogue information from the slave

Slave

In this example a larger information buffer is used, an array of 0x03 bytes, but this can be as large as needed.

int address, buffer[0x03];

In the interrupt, most of the same code is used as before.

#INT_SSP
void ssp_interupt ()
{
state = i2c_isr_state();
if(state < 0x80) //master is sending data
{

the first command bit is empty, so nothing is done.

if(state == 0)
{
}

The first data byte returns state 1 and is the address to be written to.

if(state == 1) //first received byte is address
{
address = i2c_read();
}

The second data byte is the information being received from the master and is stored in the address sent in the first data byte.

if(state == 2) //second received byte is data
{
buffer[address] = i2c_read();
}
}

If the master is requesting data, the slave sends data from the requested address.

if(state == 0x80) //master is requesting data
{
i2c_write (buffer[address]); //send requested data
}
}

Global Positioning System

2008-02-07T04:11:10Z

Matt Turpin: /* Overview */

==Objective==

The goal of this assignment is to provide the code and circuitry necessary to retrieve data from a Parallax GPS Receiver Module.

==Overview==

The [http://info.hobbyengineering.com/specs/PX-GPSManualV1.1.pdf Parallax GPS (Global Positioning System) Receiver Module] is a fully integrated, low-cost unit with an on-board patch antenna. It provides standard, raw NMEA0183 (National Marine Electronics Association) strings or specific data from up to 12 satellites via its serial command interface. It can provide the current time, date, latitude, longitude, altitude, speed, travel direction, and other data.

The Parallax GPS module was designed to be used with a Basic Stamp and to use two directional information transmission. In order to use this chip with a PIC, we will need to read in long serial strings containing all data and then parse the strings for important data to export. The PIC can use RS232 to read in the serial data and store a large array of all characters, which can then be parsed by searching for comma seperated values.

The NEMA strings this particular GPS outputs are GPGGA,GPGSA,GPGSV, and GPRMC in that order. For additional information about what data can be retrieved from these strings, go [http://home.mira.net/~gnb/gps/nmea.html here].

Here is an example string:
[[image:GPS_Raw_Data_Stream|center]]

The goal of the project was to set up a one-way connection between the PIC and the GPS Receiver Module, in which the PIC interprets the raw data collected by the GPS Receiver Module and displays it in a user-friendly format on a parallel LCD (Liquid Crystal Display). Specifically for this project, there are three sets of information that can be displayed: Position (Latitude / Longitude); Time & Number of Satellites Detectable; Velocity / Direction of Movement.

We will first discuss the circuitry of PIC-GPS connection, followed by the method used to allow the PIC to gather data from the GPS Module, and finally how to display specific information on the parallel LCD.

==Circuit==

The four primary components used in this circuit are:

* Controller (PIC)
* Parallax GPS Receiver Module
* Liquid Crystal Display
* Three buttons

[[image:Parallax_GPS_Wiring_Digram.jpg|400px|center]]
Image 1 shows the connection between the PIC and GPS Receiver Module.

Note that the pin labeled "Raw" needs to be grounded with a 1K resistor. The serial line also needs to be pulled high with a 1K resistor.

[[image:Parallel_LCD_Wiring_Digram.jpg|400px|center]]
Image 2 shows the connection between the PIC and LCD.

[[image:GPS_Circuit.jpg|400px|center]]
Image 3 is an example of how to wire all these elements together on one breadboard

==Code==

[[media:ParallaxGPS.c|See full code here]]

Include headers and set serial rate to 4800 baud

#include <18F4520.h>
#fuses HS,NOWDT,PUT,NOLVP
#use delay(clock=20000000)
#use rs232(baud=4800, rcv=PIN_C1) //can use any pin to read from GPS, but define it here
#include "flex_lcd.c" //included to allow easy writing to a parallel LCD display

Variable declarations and start of main loop

char letter[300];
int go = 0,wait = 0,commacount = 0,dataoutput = 1,j = 0;
int16 i;
int16 comma[90];

void main()
{
lcd_init();
while(TRUE)
{

One of the most important aspects of this code is waiting for signal to return to high. Without this section, the rs232 command could end up in the middle of the output of the GPS and render all information unusable. This loop waits for the signal to remain high for over 2 bytes to ensure it is at the stop position before beginning to read.

for (wait=0;wait<20;) //for loop used to wait until signal has reset. 20*50us=1ms>two bytes of ones at 4800 baud
{
if (input(PIN_C1)==1)
{
wait++;
}
else if (input(pin_c1)==0)
{
wait = 0;
}
delay_us(50);
}

After getting into the data loop, all data is recorded into a 300 character matrix letter

for(i=0;i<300;i++) //record 300 characters into letter matrix
{
letter[i]= getc();
}

The data is then parsed into sets of commas.

for(i=0;i<300;i++) //parse matrix for commas (ascii=44 for a comma)
{
if (letter[i] == 44)
{
comma[commacount] = i;
commacount++;
}
}

Counting variables are reset to zero at the end of the while loop

go = 0; //reset testing variables back to zero
commacount=0;

To finish the program, data must be converted into a usable format and output to the LCD screen. See full code above for an example of how to do this.

==References==

Parallax Info: http://info.hobbyengineering.com/specs/PX-GPSManualV1.1.pdf

Circuit Info: http://hades.mech.northwestern.edu/wiki/index.php/C_Example:_Parallel_Interfacing_with_LCDs

File:GPS Raw Data Stream

2008-02-07T04:02:05Z

Matt Turpin: Here is an example of the serial output of a Parallax GPS module.

Here is an example of the serial output of a Parallax GPS module.

Global Positioning System

2008-02-07T04:01:08Z

Matt Turpin: /* Overview */

==Objective==

The goal of this assignment is to provide the code and circuitry necessary to retrieve data from a Parallax GPS Receiver Module.

==Overview==

The [http://info.hobbyengineering.com/specs/PX-GPSManualV1.1.pdf Parallax GPS (Global Positioning System) Receiver Module] is a fully integrated, low-cost unit with an on-board patch antenna. It provides standard, raw NMEA0183 (National Marine Electronics Association) strings or specific data from up to 12 satellites via its serial command interface. It can provide the current time, date, latitude, longitude, altitude, speed, travel direction, and other data.

The NEMA strings this particular GPS outputs are GPGGA,GPGSA,GPGSV, and GPRMC in that order. For additional information about what data can be retrieved from these strings, go [http://home.mira.net/~gnb/gps/nmea.html here].

Here is an example string:
[[image:GPS_Raw_Data_Stream|center]]

The goal of the project was to set up a one-way connection between the PIC and the GPS Receiver Module, in which the PIC interprets the raw data collected by the GPS Receiver Module and displays it in a user-friendly format on a parallel LCD (Liquid Crystal Display). Specifically for this project, there are three sets of information that can be displayed: Position (Latitude / Longitude); Time & Number of Satellites Detectable; Velocity / Direction of Movement.

We will first discuss the circuitry of PIC-GPS connection, followed by the method used to allow the PIC to gather data from the GPS Module, and finally how to display specific information on the parallel LCD.

==Circuit==

The four primary components used in this circuit are:

* Controller (PIC)
* Parallax GPS Receiver Module
* Liquid Crystal Display
* Three buttons

[[image:Parallax_GPS_Wiring_Digram.jpg|400px|center]]
Image 1 shows the connection between the PIC and GPS Receiver Module.

Note that the pin labeled "Raw" needs to be grounded with a 1K resistor. The serial line also needs to be pulled high with a 1K resistor.

[[image:Parallel_LCD_Wiring_Digram.jpg|400px|center]]
Image 2 shows the connection between the PIC and LCD.

[[image:GPS_Circuit.jpg|400px|center]]
Image 3 is an example of how to wire all these elements together on one breadboard

==Code==

[[media:ParallaxGPS.c|See full code here]]

Include headers and set serial rate to 4800 baud

#include <18F4520.h>
#fuses HS,NOWDT,PUT,NOLVP
#use delay(clock=20000000)
#use rs232(baud=4800, rcv=PIN_C1) //can use any pin to read from GPS, but define it here
#include "flex_lcd.c" //included to allow easy writing to a parallel LCD display

Variable declarations and start of main loop

char letter[300];
int go = 0,wait = 0,commacount = 0,dataoutput = 1,j = 0;
int16 i;
int16 comma[90];

void main()
{
lcd_init();
while(TRUE)
{

One of the most important aspects of this code is waiting for signal to return to high. Without this section, the rs232 command could end up in the middle of the output of the GPS and render all information unusable. This loop waits for the signal to remain high for over 2 bytes to ensure it is at the stop position before beginning to read.

for (wait=0;wait<20;) //for loop used to wait until signal has reset. 20*50us=1ms>two bytes of ones at 4800 baud
{
if (input(PIN_C1)==1)
{
wait++;
}
else if (input(pin_c1)==0)
{
wait = 0;
}
delay_us(50);
}

After getting into the data loop, all data is recorded into a 300 character matrix letter

for(i=0;i<300;i++) //record 300 characters into letter matrix
{
letter[i]= getc();
}

The data is then parsed into sets of commas.

for(i=0;i<300;i++) //parse matrix for commas (ascii=44 for a comma)
{
if (letter[i] == 44)
{
comma[commacount] = i;
commacount++;
}
}

Counting variables are reset to zero at the end of the while loop

go = 0; //reset testing variables back to zero
commacount=0;

To finish the program, data must be converted into a usable format and output to the LCD screen. See full code above for an example of how to do this.

==References==

Parallax Info: http://info.hobbyengineering.com/specs/PX-GPSManualV1.1.pdf

Circuit Info: http://hades.mech.northwestern.edu/wiki/index.php/C_Example:_Parallel_Interfacing_with_LCDs

Global Positioning System

2008-02-07T03:55:29Z

Matt Turpin:

==Objective==

The goal of this assignment is to provide the code and circuitry necessary to retrieve data from a Parallax GPS Receiver Module.

==Overview==

The [http://info.hobbyengineering.com/specs/PX-GPSManualV1.1.pdf Parallax GPS (Global Positioning System) Receiver Module] is a fully integrated, low-cost unit with an on-board patch antenna. It provides standard, raw NMEA0183 (National Marine Electronics Association) strings or specific data from up to 12 satellites via its serial command interface. It can provide the current time, date, latitude, longitude, altitude, speed, travel direction, and other data.

The NEMA strings this particular GPS outputs are GPGGA,GPGSA,GPGSV, and GPRMC in that order. For additional information about what data can be retrieved from these strings, go [http://home.mira.net/~gnb/gps/nmea.html here].

The goal of the project was to set up a one-way connection between the PIC and the GPS Receiver Module, in which the PIC interprets the raw data collected by the GPS Receiver Module and displays it in a user-friendly format on a parallel LCD (Liquid Crystal Display). Specifically for this project, there are three sets of information that can be displayed: Position (Latitude / Longitude); Time & Number of Satellites Detectable; Velocity / Direction of Movement.

We will first discuss the circuitry of PIC-GPS connection, followed by the method used to allow the PIC to gather data from the GPS Module, and finally how to display specific information on the parallel LCD.

==Circuit==

The four primary components used in this circuit are:

* Controller (PIC)
* Parallax GPS Receiver Module
* Liquid Crystal Display
* Three buttons

[[image:Parallax_GPS_Wiring_Digram.jpg|400px|center]]
Image 1 shows the connection between the PIC and GPS Receiver Module.

Note that the pin labeled "Raw" needs to be grounded with a 1K resistor. The serial line also needs to be pulled high with a 1K resistor.

[[image:Parallel_LCD_Wiring_Digram.jpg|400px|center]]
Image 2 shows the connection between the PIC and LCD.

[[image:GPS_Circuit.jpg|400px|center]]
Image 3 is an example of how to wire all these elements together on one breadboard

==Code==

[[media:ParallaxGPS.c|See full code here]]

Include headers and set serial rate to 4800 baud

#include <18F4520.h>
#fuses HS,NOWDT,PUT,NOLVP
#use delay(clock=20000000)
#use rs232(baud=4800, rcv=PIN_C1) //can use any pin to read from GPS, but define it here
#include "flex_lcd.c" //included to allow easy writing to a parallel LCD display

Variable declarations and start of main loop

char letter[300];
int go = 0,wait = 0,commacount = 0,dataoutput = 1,j = 0;
int16 i;
int16 comma[90];

void main()
{
lcd_init();
while(TRUE)
{

One of the most important aspects of this code is waiting for signal to return to high. Without this section, the rs232 command could end up in the middle of the output of the GPS and render all information unusable. This loop waits for the signal to remain high for over 2 bytes to ensure it is at the stop position before beginning to read.

for (wait=0;wait<20;) //for loop used to wait until signal has reset. 20*50us=1ms>two bytes of ones at 4800 baud
{
if (input(PIN_C1)==1)
{
wait++;
}
else if (input(pin_c1)==0)
{
wait = 0;
}
delay_us(50);
}

After getting into the data loop, all data is recorded into a 300 character matrix letter

for(i=0;i<300;i++) //record 300 characters into letter matrix
{
letter[i]= getc();
}

The data is then parsed into sets of commas.

for(i=0;i<300;i++) //parse matrix for commas (ascii=44 for a comma)
{
if (letter[i] == 44)
{
comma[commacount] = i;
commacount++;
}
}

Counting variables are reset to zero at the end of the while loop

go = 0; //reset testing variables back to zero
commacount=0;

To finish the program, data must be converted into a usable format and output to the LCD screen. See full code above for an example of how to do this.

==References==

Parallax Info: http://info.hobbyengineering.com/specs/PX-GPSManualV1.1.pdf

Circuit Info: http://hades.mech.northwestern.edu/wiki/index.php/C_Example:_Parallel_Interfacing_with_LCDs

File:ParallaxGPS.c

2008-02-07T03:54:32Z

Matt Turpin: Full Parallax GPS code with parsing of 3 data selections.

Full Parallax GPS code with parsing of 3 data selections.

Global Positioning System

2008-02-07T03:52:07Z

Matt Turpin: /* Overview */

==Objective==

The goal of this assignment is to provide the code and circuitry necessary to retrieve data from a Parallax GPS Receiver Module.

==Overview==

The [http://info.hobbyengineering.com/specs/PX-GPSManualV1.1.pdf Parallax GPS (Global Positioning System) Receiver Module] is a fully integrated, low-cost unit with an on-board patch antenna. It provides standard, raw NMEA0183 (National Marine Electronics Association) strings or specific data from up to 12 satellites via its serial command interface. It can provide the current time, date, latitude, longitude, altitude, speed, travel direction, and other data.

The NEMA strings this particular GPS outputs are GPGGA,GPGSA,GPGSV, and GPRMC in that order. For additional information about what data can be retrieved from these strings, go [http://home.mira.net/~gnb/gps/nmea.html here].

The goal of the project was to set up a one-way connection between the PIC and the GPS Receiver Module, in which the PIC interprets the raw data collected by the GPS Receiver Module and displays it in a user-friendly format on a parallel LCD (Liquid Crystal Display). Specifically for this project, there are three sets of information that can be displayed: Position (Latitude / Longitude); Time & Number of Satellites Detectable; Velocity / Direction of Movement.

We will first discuss the circuitry of PIC-GPS connection, followed by the method used to allow the PIC to gather data from the GPS Module, and finally how to display specific information on the parallel LCD.

==Circuit==

The four primary components used in this circuit are:

* Controller (PIC)
* Parallax GPS Receiver Module
* Liquid Crystal Display
* Three buttons

[[image:Parallax_GPS_Wiring_Digram.jpg|400px|center]]
Image 1 shows the connection between the PIC and GPS Receiver Module.

Note that the pin labeled "Raw" needs to be grounded with a 1K resistor. The serial line also needs to be pulled high with a 1K resistor.

[[image:Parallel_LCD_Wiring_Digram.jpg|400px|center]]
Image 2 shows the connection between the PIC and LCD.

[[image:GPS_Circuit.jpg|400px|center]]
Image 3 is an example of how to wire all these elements together on one breadboard

==Code==

[[media:ParallaxGPS.c|See full code here]]

Include headers and set serial rate to 4800 baud

#include <18F4520.h>
#fuses HS,NOWDT,PUT,NOLVP
#use delay(clock=20000000)
#use rs232(baud=4800, rcv=PIN_C1) //can use any pin to read from GPS, but define it here
#include "flex_lcd.c" //included to allow easy writing to a parallel LCD display

Variable declarations and start of main loop

char letter[300];
int go = 0,wait = 0,commacount = 0,dataoutput = 1,j = 0;
int16 i;
int16 comma[90];

void main()
{
lcd_init();
while(TRUE)
{

One of the most important aspects of this code is waiting for signal to return to high. Without this section, the rs232 command could end up in the middle of the output of the GPS and render all information unusable. This loop waits for the signal to remain high for over 2 bytes to ensure it is at the stop position before beginning to read.

for (wait=0;wait<20;) //for loop used to wait until signal has reset. 20*50us=1ms>two bytes of ones at 4800 baud
{
if (input(PIN_C1)==1)
{
wait++;
}
else if (input(pin_c1)==0)
{
wait = 0;
}
delay_us(50);
}

After getting into the data loop, all data is recorded into a 300 character matrix letter

for(i=0;i<300;i++) //record 300 characters into letter matrix
{
letter[i]= getc();
}

The data is then parsed into sets of commas.

for(i=0;i<300;i++) //parse matrix for commas (ascii=44 for a comma)
{
if (letter[i] == 44)
{
comma[commacount] = i;
commacount++;
}
}

Counting variables are reset to zero at the end of the while loop

go = 0; //reset testing variables back to zero
commacount=0;

To finish the program, data must be converted into a usable format and output to the LCD screen. See full code above for an example of how to do this.

Global Positioning System

2008-02-07T03:48:19Z

Matt Turpin: /* Overview */

==Objective==

The goal of this assignment is to provide the code and circuitry necessary to retrieve data from a Parallax GPS Receiver Module.

==Overview==

The [http://info.hobbyengineering.com/specs/PX-GPSManualV1.1.pdf Parallax GPS (Global Positioning System) Receiver Module] is a fully integrated, low-cost unit with an on-board patch antenna. It provides standard, raw NMEA0183 (National Marine Electronics Association) strings or specific data from up to 12 satellites via its serial command interface. It can provide the current time, date, latitude, longitude, altitude, speed, travel direction, and other data.

The goal of the project was to set up a one-way connection between the PIC and the GPS Receiver Module, in which the PIC interprets the raw data collected by the GPS Receiver Module and displays it in a user-friendly format on a parallel LCD (Liquid Crystal Display). Specifically for this project, there are three sets of information that can be displayed: Position (Latitude / Longitude); Time & Number of Satellites Detectable; Velocity / Direction of Movement.

We will first discuss the circuitry of PIC-GPS connection, followed by the method used to allow the PIC to gather data from the GPS Module, and finally how to display specific information on the parallel LCD.

==Circuit==

The four primary components used in this circuit are:

* Controller (PIC)
* Parallax GPS Receiver Module
* Liquid Crystal Display
* Three buttons

[[image:Parallax_GPS_Wiring_Digram.jpg|400px|center]]
Image 1 shows the connection between the PIC and GPS Receiver Module.

Note that the pin labeled "Raw" needs to be grounded with a 1K resistor. The serial line also needs to be pulled high with a 1K resistor.

[[image:Parallel_LCD_Wiring_Digram.jpg|400px|center]]
Image 2 shows the connection between the PIC and LCD.

[[image:GPS_Circuit.jpg|400px|center]]
Image 3 is an example of how to wire all these elements together on one breadboard

==Code==

[[media:ParallaxGPS.c|See full code here]]

Include headers and set serial rate to 4800 baud

#include <18F4520.h>
#fuses HS,NOWDT,PUT,NOLVP
#use delay(clock=20000000)
#use rs232(baud=4800, rcv=PIN_C1) //can use any pin to read from GPS, but define it here
#include "flex_lcd.c" //included to allow easy writing to a parallel LCD display

Variable declarations and start of main loop

char letter[300];
int go = 0,wait = 0,commacount = 0,dataoutput = 1,j = 0;
int16 i;
int16 comma[90];

void main()
{
lcd_init();
while(TRUE)
{

One of the most important aspects of this code is waiting for signal to return to high. Without this section, the rs232 command could end up in the middle of the output of the GPS and render all information unusable. This loop waits for the signal to remain high for over 2 bytes to ensure it is at the stop position before beginning to read.

for (wait=0;wait<20;) //for loop used to wait until signal has reset. 20*50us=1ms>two bytes of ones at 4800 baud
{
if (input(PIN_C1)==1)
{
wait++;
}
else if (input(pin_c1)==0)
{
wait = 0;
}
delay_us(50);
}

After getting into the data loop, all data is recorded into a 300 character matrix letter

for(i=0;i<300;i++) //record 300 characters into letter matrix
{
letter[i]= getc();
}

The data is then parsed into sets of commas.

for(i=0;i<300;i++) //parse matrix for commas (ascii=44 for a comma)
{
if (letter[i] == 44)
{
comma[commacount] = i;
commacount++;
}
}

Counting variables are reset to zero at the end of the while loop

go = 0; //reset testing variables back to zero
commacount=0;

To finish the program, data must be converted into a usable format and output to the LCD screen. See full code above for an example of how to do this.

Global Positioning System

2008-02-07T03:48:01Z

Matt Turpin:

==Objective==

The goal of this assignment is to provide the code and circuitry necessary to retrieve data from a Parallax GPS Receiver Module.

==Overview==

The [[http://info.hobbyengineering.com/specs/PX-GPSManualV1.1.pdf Parallax GPS (Global Positioning System) Receiver Module]] is a fully integrated, low-cost unit with an on-board patch antenna. It provides standard, raw NMEA0183 (National Marine Electronics Association) strings or specific data from up to 12 satellites via its serial command interface. It can provide the current time, date, latitude, longitude, altitude, speed, travel direction, and other data.

The goal of the project was to set up a one-way connection between the PIC and the GPS Receiver Module, in which the PIC interprets the raw data collected by the GPS Receiver Module and displays it in a user-friendly format on a parallel LCD (Liquid Crystal Display). Specifically for this project, there are three sets of information that can be displayed: Position (Latitude / Longitude); Time & Number of Satellites Detectable; Velocity / Direction of Movement.

We will first discuss the circuitry of PIC-GPS connection, followed by the method used to allow the PIC to gather data from the GPS Module, and finally how to display specific information on the parallel LCD.

==Circuit==

The four primary components used in this circuit are:

* Controller (PIC)
* Parallax GPS Receiver Module
* Liquid Crystal Display
* Three buttons

[[image:Parallax_GPS_Wiring_Digram.jpg|400px|center]]
Image 1 shows the connection between the PIC and GPS Receiver Module.

Note that the pin labeled "Raw" needs to be grounded with a 1K resistor. The serial line also needs to be pulled high with a 1K resistor.

[[image:Parallel_LCD_Wiring_Digram.jpg|400px|center]]
Image 2 shows the connection between the PIC and LCD.

[[image:GPS_Circuit.jpg|400px|center]]
Image 3 is an example of how to wire all these elements together on one breadboard

==Code==

[[media:ParallaxGPS.c|See full code here]]

Include headers and set serial rate to 4800 baud

#include <18F4520.h>
#fuses HS,NOWDT,PUT,NOLVP
#use delay(clock=20000000)
#use rs232(baud=4800, rcv=PIN_C1) //can use any pin to read from GPS, but define it here
#include "flex_lcd.c" //included to allow easy writing to a parallel LCD display

Variable declarations and start of main loop

char letter[300];
int go = 0,wait = 0,commacount = 0,dataoutput = 1,j = 0;
int16 i;
int16 comma[90];

void main()
{
lcd_init();
while(TRUE)
{

One of the most important aspects of this code is waiting for signal to return to high. Without this section, the rs232 command could end up in the middle of the output of the GPS and render all information unusable. This loop waits for the signal to remain high for over 2 bytes to ensure it is at the stop position before beginning to read.

for (wait=0;wait<20;) //for loop used to wait until signal has reset. 20*50us=1ms>two bytes of ones at 4800 baud
{
if (input(PIN_C1)==1)
{
wait++;
}
else if (input(pin_c1)==0)
{
wait = 0;
}
delay_us(50);
}

After getting into the data loop, all data is recorded into a 300 character matrix letter

for(i=0;i<300;i++) //record 300 characters into letter matrix
{
letter[i]= getc();
}

The data is then parsed into sets of commas.

for(i=0;i<300;i++) //parse matrix for commas (ascii=44 for a comma)
{
if (letter[i] == 44)
{
comma[commacount] = i;
commacount++;
}
}

Counting variables are reset to zero at the end of the while loop

go = 0; //reset testing variables back to zero
commacount=0;

To finish the program, data must be converted into a usable format and output to the LCD screen. See full code above for an example of how to do this.

Parallax GPS (Global Positioning System) Receiver Module

2008-02-07T03:46:56Z

Matt Turpin:

http://info.hobbyengineering.com/specs/PX-GPSManualV1.1.pdf

Global Positioning System

2008-02-07T03:46:43Z

Matt Turpin: /* Overview */

==Objective==

The goal of this assignment is to provide the code and circuitry necessary to retrieve data from a Parallax GPS Receiver Module.

==Overview==

The [[Parallax GPS (Global Positioning System) Receiver Module]] is a fully integrated, low-cost unit with an on-board patch antenna. It provides standard, raw NMEA0183 (National Marine Electronics Association) strings or specific data from up to 12 satellites via its serial command interface. It can provide the current time, date, latitude, longitude, altitude, speed, travel direction, and other data.

The goal of the project was to set up a one-way connection between the PIC and the GPS Receiver Module, in which the PIC interprets the raw data collected by the GPS Receiver Module and displays it in a user-friendly format on a parallel LCD (Liquid Crystal Display). Specifically for this project, there are three sets of information that can be displayed: Position (Latitude / Longitude); Time & Number of Satellites Detectable; Velocity / Direction of Movement.

We will first discuss the circuitry of PIC-GPS connection, followed by the method used to allow the PIC to gather data from the GPS Module, and finally how to display specific information on the parallel LCD.

==Circuit==

The four primary components used in this circuit are:

* Controller (PIC)
* Parallax GPS Receiver Module
* Liquid Crystal Display
* Three buttons

[[image:Parallax_GPS_Wiring_Digram.jpg|400px|center]]
Image 1 shows the connection between the PIC and GPS Receiver Module.

Note that the pin labeled "Raw" needs to be grounded with a 1K resistor. The serial line also needs to be pulled high with a 1K resistor.

[[image:Parallel_LCD_Wiring_Digram.jpg|400px|center]]
Image 2 shows the connection between the PIC and LCD.

[[image:GPS_Circuit.jpg|400px|center]]
Image 3 is an example of how to wire all these elements together on one breadboard

==Code==

[[media:ParallaxGPS.c|See full code here]]

Include headers and set serial rate to 4800 baud

#include <18F4520.h>
#fuses HS,NOWDT,PUT,NOLVP
#use delay(clock=20000000)
#use rs232(baud=4800, rcv=PIN_C1) //can use any pin to read from GPS, but define it here
#include "flex_lcd.c" //included to allow easy writing to a parallel LCD display

Variable declarations and start of main loop

char letter[300];
int go = 0,wait = 0,commacount = 0,dataoutput = 1,j = 0;
int16 i;
int16 comma[90];

void main()
{
lcd_init();
while(TRUE)
{

One of the most important aspects of this code is waiting for signal to return to high. Without this section, the rs232 command could end up in the middle of the output of the GPS and render all information unusable. This loop waits for the signal to remain high for over 2 bytes to ensure it is at the stop position before beginning to read.

for (wait=0;wait<20;) //for loop used to wait until signal has reset. 20*50us=1ms>two bytes of ones at 4800 baud
{
if (input(PIN_C1)==1)
{
wait++;
}
else if (input(pin_c1)==0)
{
wait = 0;
}
delay_us(50);
}

After getting into the data loop, all data is recorded into a 300 character matrix letter

for(i=0;i<300;i++) //record 300 characters into letter matrix
{
letter[i]= getc();
}

The data is then parsed into sets of commas.

for(i=0;i<300;i++) //parse matrix for commas (ascii=44 for a comma)
{
if (letter[i] == 44)
{
comma[commacount] = i;
commacount++;
}
}

Counting variables are reset to zero at the end of the while loop

go = 0; //reset testing variables back to zero
commacount=0;

To finish the program, data must be converted into a usable format and output to the LCD screen. See full code above for an example of how to do this.

File:GPS Circuit.jpg

2008-02-07T03:43:28Z

Matt Turpin: An example of how to wire a parallax GPS on one solderless breadboard.

An example of how to wire a parallax GPS on one solderless breadboard.

Global Positioning System

2008-02-07T03:41:49Z

Matt Turpin: /* Circuit */

==Objective==

The goal of this assignment is to provide the code and circuitry necessary to retrieve data from a Parallax GPS Receiver Module.

==Overview==

The Parallax GPS (Global Positioning System) Receiver Module is a fully integrated, low-cost unit with an on-board patch antenna. It provides standard, raw NMEA0183 (National Marine Electronics Association) strings or specific data from up to 12 satellites via its serial command interface. It can provide the current time, date, latitude, longitude, altitude, speed, travel direction, and other data.

The goal of the project was to set up a one-way connection between the PIC and the GPS Receiver Module, in which the PIC interprets the raw data collected by the GPS Receiver Module and displays it in a user-friendly format on a parallel LCD (Liquid Crystal Display). Specifically for this project, there are three sets of information that can be displayed: Position (Latitude / Longitude); Time & Number of Satellites Detectable; Velocity / Direction of Movement.

We will first discuss the circuitry of PIC-GPS connection, followed by the method used to allow the PIC to gather data from the GPS Module, and finally how to display specific information on the parallel LCD.

==Circuit==

The four primary components used in this circuit are:

* Controller (PIC)
* Parallax GPS Receiver Module
* Liquid Crystal Display
* Three buttons

[[image:Parallax_GPS_Wiring_Digram.jpg|400px|center]]
Image 1 shows the connection between the PIC and GPS Receiver Module.

Note that the pin labeled "Raw" needs to be grounded with a 1K resistor. The serial line also needs to be pulled high with a 1K resistor.

[[image:Parallel_LCD_Wiring_Digram.jpg|400px|center]]
Image 2 shows the connection between the PIC and LCD.

[[image:GPS_Circuit.jpg|400px|center]]
Image 3 is an example of how to wire all these elements together on one breadboard

==Code==

[[media:ParallaxGPS.c|See full code here]]

Include headers and set serial rate to 4800 baud

#include <18F4520.h>
#fuses HS,NOWDT,PUT,NOLVP
#use delay(clock=20000000)
#use rs232(baud=4800, rcv=PIN_C1) //can use any pin to read from GPS, but define it here
#include "flex_lcd.c" //included to allow easy writing to a parallel LCD display

Variable declarations and start of main loop

char letter[300];
int go = 0,wait = 0,commacount = 0,dataoutput = 1,j = 0;
int16 i;
int16 comma[90];

void main()
{
lcd_init();
while(TRUE)
{

One of the most important aspects of this code is waiting for signal to return to high. Without this section, the rs232 command could end up in the middle of the output of the GPS and render all information unusable. This loop waits for the signal to remain high for over 2 bytes to ensure it is at the stop position before beginning to read.

for (wait=0;wait<20;) //for loop used to wait until signal has reset. 20*50us=1ms>two bytes of ones at 4800 baud
{
if (input(PIN_C1)==1)
{
wait++;
}
else if (input(pin_c1)==0)
{
wait = 0;
}
delay_us(50);
}

After getting into the data loop, all data is recorded into a 300 character matrix letter

for(i=0;i<300;i++) //record 300 characters into letter matrix
{
letter[i]= getc();
}

The data is then parsed into sets of commas.

for(i=0;i<300;i++) //parse matrix for commas (ascii=44 for a comma)
{
if (letter[i] == 44)
{
comma[commacount] = i;
commacount++;
}
}

Counting variables are reset to zero at the end of the while loop

go = 0; //reset testing variables back to zero
commacount=0;

To finish the program, data must be converted into a usable format and output to the LCD screen. See full code above for an example of how to do this.

Global Positioning System

2008-02-07T03:40:03Z

Matt Turpin: /* Circuit */

==Objective==

The goal of this assignment is to provide the code and circuitry necessary to retrieve data from a Parallax GPS Receiver Module.

==Overview==

The Parallax GPS (Global Positioning System) Receiver Module is a fully integrated, low-cost unit with an on-board patch antenna. It provides standard, raw NMEA0183 (National Marine Electronics Association) strings or specific data from up to 12 satellites via its serial command interface. It can provide the current time, date, latitude, longitude, altitude, speed, travel direction, and other data.

The goal of the project was to set up a one-way connection between the PIC and the GPS Receiver Module, in which the PIC interprets the raw data collected by the GPS Receiver Module and displays it in a user-friendly format on a parallel LCD (Liquid Crystal Display). Specifically for this project, there are three sets of information that can be displayed: Position (Latitude / Longitude); Time & Number of Satellites Detectable; Velocity / Direction of Movement.

We will first discuss the circuitry of PIC-GPS connection, followed by the method used to allow the PIC to gather data from the GPS Module, and finally how to display specific information on the parallel LCD.

==Circuit==

The four primary components used in this circuit are:

* Controller (PIC)
* Parallax GPS Receiver Module
* Liquid Crystal Display
* Three buttons

[[image:Parallax_GPS_Wiring_Digram.jpg|400px|center]]
Image 1 shows the connection between the PIC and GPS Receiver Module.

Note that the pin labeled "Raw" needs to be grounded with a 1K resistor. The serial line also needs to be pulled high with a 1K resistor.

[[image:Parallel_LCD_Wiring_Digram.jpg|400px|center]]
Image 2 shows the connection between the PIC and LCD.

==Code==

[[media:ParallaxGPS.c|See full code here]]

Include headers and set serial rate to 4800 baud

#include <18F4520.h>
#fuses HS,NOWDT,PUT,NOLVP
#use delay(clock=20000000)
#use rs232(baud=4800, rcv=PIN_C1) //can use any pin to read from GPS, but define it here
#include "flex_lcd.c" //included to allow easy writing to a parallel LCD display

Variable declarations and start of main loop

char letter[300];
int go = 0,wait = 0,commacount = 0,dataoutput = 1,j = 0;
int16 i;
int16 comma[90];

void main()
{
lcd_init();
while(TRUE)
{

One of the most important aspects of this code is waiting for signal to return to high. Without this section, the rs232 command could end up in the middle of the output of the GPS and render all information unusable. This loop waits for the signal to remain high for over 2 bytes to ensure it is at the stop position before beginning to read.

for (wait=0;wait<20;) //for loop used to wait until signal has reset. 20*50us=1ms>two bytes of ones at 4800 baud
{
if (input(PIN_C1)==1)
{
wait++;
}
else if (input(pin_c1)==0)
{
wait = 0;
}
delay_us(50);
}

After getting into the data loop, all data is recorded into a 300 character matrix letter

for(i=0;i<300;i++) //record 300 characters into letter matrix
{
letter[i]= getc();
}

The data is then parsed into sets of commas.

for(i=0;i<300;i++) //parse matrix for commas (ascii=44 for a comma)
{
if (letter[i] == 44)
{
comma[commacount] = i;
commacount++;
}
}

Counting variables are reset to zero at the end of the while loop

go = 0; //reset testing variables back to zero
commacount=0;

To finish the program, data must be converted into a usable format and output to the LCD screen. See full code above for an example of how to do this.

Global Positioning System

2008-02-07T03:39:48Z

Matt Turpin: /* Circuit */

==Objective==

The goal of this assignment is to provide the code and circuitry necessary to retrieve data from a Parallax GPS Receiver Module.

==Overview==

The Parallax GPS (Global Positioning System) Receiver Module is a fully integrated, low-cost unit with an on-board patch antenna. It provides standard, raw NMEA0183 (National Marine Electronics Association) strings or specific data from up to 12 satellites via its serial command interface. It can provide the current time, date, latitude, longitude, altitude, speed, travel direction, and other data.

The goal of the project was to set up a one-way connection between the PIC and the GPS Receiver Module, in which the PIC interprets the raw data collected by the GPS Receiver Module and displays it in a user-friendly format on a parallel LCD (Liquid Crystal Display). Specifically for this project, there are three sets of information that can be displayed: Position (Latitude / Longitude); Time & Number of Satellites Detectable; Velocity / Direction of Movement.

We will first discuss the circuitry of PIC-GPS connection, followed by the method used to allow the PIC to gather data from the GPS Module, and finally how to display specific information on the parallel LCD.

==Circuit==

The four primary components used in this circuit are:

* Controller (PIC)
* Parallax GPS Receiver Module
* Liquid Crystal Display
* Three buttons

[[image:Parallax_GPS_Wiring_Digram.jpg|200px|center]]
Image 1 shows the connection between the PIC and GPS Receiver Module.

Note that the pin labeled "Raw" needs to be grounded with a 1K resistor. The serial line also needs to be pulled high with a 1K resistor.

[[image:Parallel_LCD_Wiring_Digram.jpg|300px|center]]
Image 2 shows the connection between the PIC and LCD.

==Code==

[[media:ParallaxGPS.c|See full code here]]

Include headers and set serial rate to 4800 baud

#include <18F4520.h>
#fuses HS,NOWDT,PUT,NOLVP
#use delay(clock=20000000)
#use rs232(baud=4800, rcv=PIN_C1) //can use any pin to read from GPS, but define it here
#include "flex_lcd.c" //included to allow easy writing to a parallel LCD display

Variable declarations and start of main loop

char letter[300];
int go = 0,wait = 0,commacount = 0,dataoutput = 1,j = 0;
int16 i;
int16 comma[90];

void main()
{
lcd_init();
while(TRUE)
{

One of the most important aspects of this code is waiting for signal to return to high. Without this section, the rs232 command could end up in the middle of the output of the GPS and render all information unusable. This loop waits for the signal to remain high for over 2 bytes to ensure it is at the stop position before beginning to read.

for (wait=0;wait<20;) //for loop used to wait until signal has reset. 20*50us=1ms>two bytes of ones at 4800 baud
{
if (input(PIN_C1)==1)
{
wait++;
}
else if (input(pin_c1)==0)
{
wait = 0;
}
delay_us(50);
}

After getting into the data loop, all data is recorded into a 300 character matrix letter

for(i=0;i<300;i++) //record 300 characters into letter matrix
{
letter[i]= getc();
}

The data is then parsed into sets of commas.

for(i=0;i<300;i++) //parse matrix for commas (ascii=44 for a comma)
{
if (letter[i] == 44)
{
comma[commacount] = i;
commacount++;
}
}

Counting variables are reset to zero at the end of the while loop

go = 0; //reset testing variables back to zero
commacount=0;

To finish the program, data must be converted into a usable format and output to the LCD screen. See full code above for an example of how to do this.

File:Parallel LCD Wiring Digram.jpg

2008-02-07T03:37:27Z

Matt Turpin: Taken from http://hades.mech.northwestern.edu/wiki/index.php/C_Example:_Parallel_Interfacing_with_LCDs See that page for code and additional information.

Taken from http://hades.mech.northwestern.edu/wiki/index.php/C_Example:_Parallel_Interfacing_with_LCDs
See that page for code and additional information.

Global Positioning System

2008-02-07T03:35:53Z

Matt Turpin: /* Circuit */

==Objective==

The goal of this assignment is to provide the code and circuitry necessary to retrieve data from a Parallax GPS Receiver Module.

==Overview==

The Parallax GPS (Global Positioning System) Receiver Module is a fully integrated, low-cost unit with an on-board patch antenna. It provides standard, raw NMEA0183 (National Marine Electronics Association) strings or specific data from up to 12 satellites via its serial command interface. It can provide the current time, date, latitude, longitude, altitude, speed, travel direction, and other data.

The goal of the project was to set up a one-way connection between the PIC and the GPS Receiver Module, in which the PIC interprets the raw data collected by the GPS Receiver Module and displays it in a user-friendly format on a parallel LCD (Liquid Crystal Display). Specifically for this project, there are three sets of information that can be displayed: Position (Latitude / Longitude); Time & Number of Satellites Detectable; Velocity / Direction of Movement.

We will first discuss the circuitry of PIC-GPS connection, followed by the method used to allow the PIC to gather data from the GPS Module, and finally how to display specific information on the parallel LCD.

==Circuit==

The four primary components used in this circuit are:

* Controller (PIC)
* Parallax GPS Receiver Module
* Liquid Crystal Display
* Three buttons

[[image:Parallax_GPS_Wiring_Digram.jpg|size=200px|center]]
Image 1 shows the connection between the PIC and GPS Receiver Module.

Note that the pin labeled "Raw" needs to be grounded with a 1K resistor. The serial line also needs to be pulled high with a 1K resistor.

[[image:Parallel_LCD_Wiring_Digram.jpg|size=300px|center]]
Image 2 shows the connection between the PIC and LCD.

==Code==

[[media:ParallaxGPS.c|See full code here]]

Include headers and set serial rate to 4800 baud

#include <18F4520.h>
#fuses HS,NOWDT,PUT,NOLVP
#use delay(clock=20000000)
#use rs232(baud=4800, rcv=PIN_C1) //can use any pin to read from GPS, but define it here
#include "flex_lcd.c" //included to allow easy writing to a parallel LCD display

Variable declarations and start of main loop

char letter[300];
int go = 0,wait = 0,commacount = 0,dataoutput = 1,j = 0;
int16 i;
int16 comma[90];

void main()
{
lcd_init();
while(TRUE)
{

One of the most important aspects of this code is waiting for signal to return to high. Without this section, the rs232 command could end up in the middle of the output of the GPS and render all information unusable. This loop waits for the signal to remain high for over 2 bytes to ensure it is at the stop position before beginning to read.

for (wait=0;wait<20;) //for loop used to wait until signal has reset. 20*50us=1ms>two bytes of ones at 4800 baud
{
if (input(PIN_C1)==1)
{
wait++;
}
else if (input(pin_c1)==0)
{
wait = 0;
}
delay_us(50);
}

After getting into the data loop, all data is recorded into a 300 character matrix letter

for(i=0;i<300;i++) //record 300 characters into letter matrix
{
letter[i]= getc();
}

The data is then parsed into sets of commas.

for(i=0;i<300;i++) //parse matrix for commas (ascii=44 for a comma)
{
if (letter[i] == 44)
{
comma[commacount] = i;
commacount++;
}
}

Counting variables are reset to zero at the end of the while loop

go = 0; //reset testing variables back to zero
commacount=0;

To finish the program, data must be converted into a usable format and output to the LCD screen. See full code above for an example of how to do this.

Global Positioning System

2008-02-07T03:33:36Z

Matt Turpin: /* Circuit */

==Objective==

The goal of this assignment is to provide the code and circuitry necessary to retrieve data from a Parallax GPS Receiver Module.

==Overview==

The Parallax GPS (Global Positioning System) Receiver Module is a fully integrated, low-cost unit with an on-board patch antenna. It provides standard, raw NMEA0183 (National Marine Electronics Association) strings or specific data from up to 12 satellites via its serial command interface. It can provide the current time, date, latitude, longitude, altitude, speed, travel direction, and other data.

The goal of the project was to set up a one-way connection between the PIC and the GPS Receiver Module, in which the PIC interprets the raw data collected by the GPS Receiver Module and displays it in a user-friendly format on a parallel LCD (Liquid Crystal Display). Specifically for this project, there are three sets of information that can be displayed: Position (Latitude / Longitude); Time & Number of Satellites Detectable; Velocity / Direction of Movement.

We will first discuss the circuitry of PIC-GPS connection, followed by the method used to allow the PIC to gather data from the GPS Module, and finally how to display specific information on the parallel LCD.

==Circuit==

The four primary components used in this circuit are:

* Controller (PIC)
* Parallax GPS Receiver Module
* Liquid Crystal Display
* Three buttons

[[image:Parallax_GPS_Wiring_Digram.jpg|size=200px|center]]
Image 1 shows the connection between the PIC and GPS Receiver Module.
Note that the pin labeled "Raw" needs to be grounded with a 1K resistor. The serial line also needs to be pulled high with a 1K resistor.

[[image:Parallel_LCD_Wiring_Digram.jpg|size=300px|center]]
Image 2 shows the connection between the PIC and LCD.

==Code==

[[media:ParallaxGPS.c|See full code here]]

Include headers and set serial rate to 4800 baud

#include <18F4520.h>
#fuses HS,NOWDT,PUT,NOLVP
#use delay(clock=20000000)
#use rs232(baud=4800, rcv=PIN_C1) //can use any pin to read from GPS, but define it here
#include "flex_lcd.c" //included to allow easy writing to a parallel LCD display

Variable declarations and start of main loop

char letter[300];
int go = 0,wait = 0,commacount = 0,dataoutput = 1,j = 0;
int16 i;
int16 comma[90];

void main()
{
lcd_init();
while(TRUE)
{

One of the most important aspects of this code is waiting for signal to return to high. Without this section, the rs232 command could end up in the middle of the output of the GPS and render all information unusable. This loop waits for the signal to remain high for over 2 bytes to ensure it is at the stop position before beginning to read.

for (wait=0;wait<20;) //for loop used to wait until signal has reset. 20*50us=1ms>two bytes of ones at 4800 baud
{
if (input(PIN_C1)==1)
{
wait++;
}
else if (input(pin_c1)==0)
{
wait = 0;
}
delay_us(50);
}

After getting into the data loop, all data is recorded into a 300 character matrix letter

for(i=0;i<300;i++) //record 300 characters into letter matrix
{
letter[i]= getc();
}

The data is then parsed into sets of commas.

for(i=0;i<300;i++) //parse matrix for commas (ascii=44 for a comma)
{
if (letter[i] == 44)
{
comma[commacount] = i;
commacount++;
}
}

Counting variables are reset to zero at the end of the while loop

go = 0; //reset testing variables back to zero
commacount=0;

To finish the program, data must be converted into a usable format and output to the LCD screen. See full code above for an example of how to do this.

File:Parallax GPS Wiring Digram.jpg

2008-02-07T03:22:26Z

Matt Turpin: 4 pin connections for the Parallax GPS chip. Note that the pin labeled "Raw" needs to pulled high with a 10k resistor.

4 pin connections for the Parallax GPS chip. Note that the pin labeled "Raw" needs to pulled high with a 10k resistor.

Global Positioning System

2008-02-07T03:20:27Z

Matt Turpin: /* Circuit */

==Objective==

The goal of this assignment is to provide the code and circuitry necessary to retrieve data from a Parallax GPS Receiver Module.

==Overview==

The Parallax GPS (Global Positioning System) Receiver Module is a fully integrated, low-cost unit with an on-board patch antenna. It provides standard, raw NMEA0183 (National Marine Electronics Association) strings or specific data from up to 12 satellites via its serial command interface. It can provide the current time, date, latitude, longitude, altitude, speed, travel direction, and other data.

The goal of the project was to set up a one-way connection between the PIC and the GPS Receiver Module, in which the PIC interprets the raw data collected by the GPS Receiver Module and displays it in a user-friendly format on a parallel LCD (Liquid Crystal Display). Specifically for this project, there are three sets of information that can be displayed: Position (Latitude / Longitude); Time & Number of Satellites Detectable; Velocity / Direction of Movement.

We will first discuss the circuitry of PIC-GPS connection, followed by the method used to allow the PIC to gather data from the GPS Module, and finally how to display specific information on the parallel LCD.

==Circuit==

The four primary components used in this circuit are:

* Controller (PIC)
* Parallax GPS Receiver Module
* Liquid Crystal Display
* Three buttons

[[image:Parallax_GPS_Wiring_Digram.jpg|size=300px|center]]
Image 1 shows the connection between the PIC and GPS Receiver Module.

[[image:Parallel_LCD_Wiring_Digram.jpg|size=300px|center]]
Image 2 shows the connection between the PIC and LCD.

==Code==

[[media:ParallaxGPS.c|See full code here]]

Include headers and set serial rate to 4800 baud

#include <18F4520.h>
#fuses HS,NOWDT,PUT,NOLVP
#use delay(clock=20000000)
#use rs232(baud=4800, rcv=PIN_C1) //can use any pin to read from GPS, but define it here
#include "flex_lcd.c" //included to allow easy writing to a parallel LCD display

Variable declarations and start of main loop

char letter[300];
int go = 0,wait = 0,commacount = 0,dataoutput = 1,j = 0;
int16 i;
int16 comma[90];

void main()
{
lcd_init();
while(TRUE)
{

One of the most important aspects of this code is waiting for signal to return to high. Without this section, the rs232 command could end up in the middle of the output of the GPS and render all information unusable. This loop waits for the signal to remain high for over 2 bytes to ensure it is at the stop position before beginning to read.

for (wait=0;wait<20;) //for loop used to wait until signal has reset. 20*50us=1ms>two bytes of ones at 4800 baud
{
if (input(PIN_C1)==1)
{
wait++;
}
else if (input(pin_c1)==0)
{
wait = 0;
}
delay_us(50);
}

After getting into the data loop, all data is recorded into a 300 character matrix letter

for(i=0;i<300;i++) //record 300 characters into letter matrix
{
letter[i]= getc();
}

The data is then parsed into sets of commas.

for(i=0;i<300;i++) //parse matrix for commas (ascii=44 for a comma)
{
if (letter[i] == 44)
{
comma[commacount] = i;
commacount++;
}
}

Counting variables are reset to zero at the end of the while loop

go = 0; //reset testing variables back to zero
commacount=0;

To finish the program, data must be converted into a usable format and output to the LCD screen. See full code above for an example of how to do this.

Global Positioning System

2008-02-07T03:19:58Z

Matt Turpin: /* Circuit */

==Objective==

The goal of this assignment is to provide the code and circuitry necessary to retrieve data from a Parallax GPS Receiver Module.

==Overview==

The Parallax GPS (Global Positioning System) Receiver Module is a fully integrated, low-cost unit with an on-board patch antenna. It provides standard, raw NMEA0183 (National Marine Electronics Association) strings or specific data from up to 12 satellites via its serial command interface. It can provide the current time, date, latitude, longitude, altitude, speed, travel direction, and other data.

The goal of the project was to set up a one-way connection between the PIC and the GPS Receiver Module, in which the PIC interprets the raw data collected by the GPS Receiver Module and displays it in a user-friendly format on a parallel LCD (Liquid Crystal Display). Specifically for this project, there are three sets of information that can be displayed: Position (Latitude / Longitude); Time & Number of Satellites Detectable; Velocity / Direction of Movement.

We will first discuss the circuitry of PIC-GPS connection, followed by the method used to allow the PIC to gather data from the GPS Module, and finally how to display specific information on the parallel LCD.

==Circuit==

The four primary components used in this circuit are:

* Controller (PIC)
* Parallax GPS Receiver Module
* Liquid Crystal Display
* Three buttons

[[image=Parallax_GPS_Wiring_Digram.jpg|size=300px|center]]
Image 1 shows the connection between the PIC and GPS Receiver Module.

[[image=Parallel_LCD_Wiring_Digram.jpg|size=300px|center]]
Image 2 shows the connection between the PIC and LCD.

==Code==

[[media:ParallaxGPS.c|See full code here]]

Include headers and set serial rate to 4800 baud

#include <18F4520.h>
#fuses HS,NOWDT,PUT,NOLVP
#use delay(clock=20000000)
#use rs232(baud=4800, rcv=PIN_C1) //can use any pin to read from GPS, but define it here
#include "flex_lcd.c" //included to allow easy writing to a parallel LCD display

Variable declarations and start of main loop

char letter[300];
int go = 0,wait = 0,commacount = 0,dataoutput = 1,j = 0;
int16 i;
int16 comma[90];

void main()
{
lcd_init();
while(TRUE)
{

One of the most important aspects of this code is waiting for signal to return to high. Without this section, the rs232 command could end up in the middle of the output of the GPS and render all information unusable. This loop waits for the signal to remain high for over 2 bytes to ensure it is at the stop position before beginning to read.

for (wait=0;wait<20;) //for loop used to wait until signal has reset. 20*50us=1ms>two bytes of ones at 4800 baud
{
if (input(PIN_C1)==1)
{
wait++;
}
else if (input(pin_c1)==0)
{
wait = 0;
}
delay_us(50);
}

After getting into the data loop, all data is recorded into a 300 character matrix letter

for(i=0;i<300;i++) //record 300 characters into letter matrix
{
letter[i]= getc();
}

The data is then parsed into sets of commas.

for(i=0;i<300;i++) //parse matrix for commas (ascii=44 for a comma)
{
if (letter[i] == 44)
{
comma[commacount] = i;
commacount++;
}
}

Counting variables are reset to zero at the end of the while loop

go = 0; //reset testing variables back to zero
commacount=0;

To finish the program, data must be converted into a usable format and output to the LCD screen. See full code above for an example of how to do this.

Global Positioning System

2008-02-07T03:11:15Z

Matt Turpin: /* Circuit */

==Objective==

The goal of this assignment is to provide the code and circuitry necessary to retrieve data from a Parallax GPS Receiver Module.

==Overview==

The Parallax GPS (Global Positioning System) Receiver Module is a fully integrated, low-cost unit with an on-board patch antenna. It provides standard, raw NMEA0183 (National Marine Electronics Association) strings or specific data from up to 12 satellites via its serial command interface. It can provide the current time, date, latitude, longitude, altitude, speed, travel direction, and other data.

The goal of the project was to set up a one-way connection between the PIC and the GPS Receiver Module, in which the PIC interprets the raw data collected by the GPS Receiver Module and displays it in a user-friendly format on a parallel LCD (Liquid Crystal Display). Specifically for this project, there are three sets of information that can be displayed: Position (Latitude / Longitude); Time & Number of Satellites Detectable; Velocity / Direction of Movement.

We will first discuss the circuitry of PIC-GPS connection, followed by the method used to allow the PIC to gather data from the GPS Module, and finally how to display specific information on the parallel LCD.

==Circuit==

The four primary components used in this circuit are:

* Controller (PIC)
* Parallax GPS Receiver Module
* Liquid Crystal Display
* Three buttons

Image 1 shows the connection between the PIC and GPS Receiver Module.

Image 2 shows the connection between the PIC and LCD.

==Code==

[[media:ParallaxGPS.c|See full code here]]

Include headers and set serial rate to 4800 baud

#include <18F4520.h>
#fuses HS,NOWDT,PUT,NOLVP
#use delay(clock=20000000)
#use rs232(baud=4800, rcv=PIN_C1) //can use any pin to read from GPS, but define it here
#include "flex_lcd.c" //included to allow easy writing to a parallel LCD display

Variable declarations and start of main loop

char letter[300];
int go = 0,wait = 0,commacount = 0,dataoutput = 1,j = 0;
int16 i;
int16 comma[90];

void main()
{
lcd_init();
while(TRUE)
{

One of the most important aspects of this code is waiting for signal to return to high. Without this section, the rs232 command could end up in the middle of the output of the GPS and render all information unusable. This loop waits for the signal to remain high for over 2 bytes to ensure it is at the stop position before beginning to read.

for (wait=0;wait<20;) //for loop used to wait until signal has reset. 20*50us=1ms>two bytes of ones at 4800 baud
{
if (input(PIN_C1)==1)
{
wait++;
}
else if (input(pin_c1)==0)
{
wait = 0;
}
delay_us(50);
}

After getting into the data loop, all data is recorded into a 300 character matrix letter

for(i=0;i<300;i++) //record 300 characters into letter matrix
{
letter[i]= getc();
}

The data is then parsed into sets of commas.

for(i=0;i<300;i++) //parse matrix for commas (ascii=44 for a comma)
{
if (letter[i] == 44)
{
comma[commacount] = i;
commacount++;
}
}

Counting variables are reset to zero at the end of the while loop

go = 0; //reset testing variables back to zero
commacount=0;

To finish the program, data must be converted into a usable format and output to the LCD screen. See full code above for an example of how to do this.