[[ME 333 final projects]]

[[Image:Team-21-main-picture.JPG|right|Our Final Design|thumb|500px]] 

==Team Members==
*Brian Kephart - Electrical Engineering Class of 2009
*Jonathan Shih - Mechanical Engineering Class of 2009
*Kristi Bond - Mechanical Engineering Class of 2008

==Overview==

A clear sphere is filled with grains of different sizes. Our apparatus rotates this ball about two different axis based on a series of user inputs. The user inputs the specific values for things such as angle and rotational speed into Matlab. Our device takes these inputs and processes them using a series of master and slave PICs to appropriately control the motors. The motors then turn for the input duration at the desired speed causing the ball to spin correctly due to the frictional connection between both motors and the sphere or lazy susan, respectively.

This apparatus will be used for the study of granular flow and the mixing of particles within the sphere. It was important to leave the ball as visible as possible to allow for pictures to be taken of the grains within from many angles. With this apparatus we hope to aide the study of granular flow theory and allow the researches to use the device for many different applications.

==Mechanical Set-up==

====Main Housing====

The main housing, or case, for our design is composed of the following pieces.

*One 13.5” x 12” x ¾” plywood rectangle
*One 13.5” x 12” x ¾” plywood rectangle with a 3.5” diameter circle removed from the center
*Two 12” x 2.5”x ¾” plywood rectangles

The two larger rectangles form the top and bottom of the set-up with the two smaller rectangles placed vertically between to form a box with two open ends on the front and back face.

====Ball Support====

Three ball casters are placed on vertical mounts around the center circle of the top piece of the housing at equal angles. These casters prevent the ball from moving in any horizontal direction so it is only free to rotate. One of these casters is adjustable to allow the user to make sure the ball is correctly supported above the drive wheel. The force of gravity is strong enough to prevent the ball from moving up and out of the housing and also ensures a good connection with the drive wheel that is placed directly under the center of the sphere.

====Main Drive Wheel====

The main drive wheel is centered under the rotating sphere. The wheel is mounted onto a ¼” aluminum shaft which is connected to the Pittman motor with a flexible coupling and is also supported by a sleeve bearing on the other side of the wheel.

====Lazy Susan====

The main drive wheel with its corresponding motor and other components are all mounted on top of a lazy susan that is centered on the bottom piece of the housing and secured with screws. This lazy susan allows rotational motion but prevents movement in any other direction allowing the wheel to turn but always have the same center of contact with the sphere above. It is important to ensure that the drive wheel has a good connection with the sphere above because the frictional force between the wheel and the sphere must be as large as possible so that as the wheel spins the ball spins at the same rate.

====Position Control Motor====

A second motor is used in our design to turn the lazy susan. The motor is mounted vertically through the top plate. Another, smaller, drive wheel is mounted directly to the motor shaft and then aligned with only the top, free half of the lazy susan. A second, idler wheel is mounted on the bottom plate, so the drive wheel is sandwiched between this wheel and the lazy susan. This ensures that the drive wheel is always in contact with the lazy susan because the idler wheel exerts only a normal force. Again, this is to ensure there is no slip between the lazy susan and the drive wheel so it is automatically controlled more easily.

====Complete Parts List====

<table border=1>
<tr><th>Part</th><th>Part No.</th><th>Qty</th>
<tr><td>Pittman GM8224 motor </td><td>---</td><td>2</td>
<tr><td>Helical Beam Set-Screw Shaft Coupling</td><td> 9861T508 </td><td>1</td>
<tr><td>Mounted Sleeve Bearing</td><td>5912K21 </td><td>1</td>
<tr><td>Flange Mount Ball Caster</td><td>5674K77 </td><td>3</td>
<tr><td>Lazy Susan</td><td>1443T2</td><td>1</td>
<tr><td>Drive Wheel</td><td>60885K23 </td><td>1</td>
<tr><td>Small Drive Wheel</td><td>2471K12 </td><td>1</td>
<tr><td>Idler Wheel</td><td>60885K79 </td><td>1</td>
<tr><td>1/4” Aluminum Rod</td><td>---</td><td>---</td>
<tr><td>Aluminum Sheet Metal</td><td>---</td><td>---</td>
<tr><td>Plywood</td><td>---</td><td>---</td>
</table>

==Circuitry==

===Summary===
Our project was unique in that we relied on the use of three different PICs to precisely coordinate the motion of our ball. The main reason for this was because the 18F4520 chip only has enough encoder inputs for one Pittman motor.

===Component List===
<table border=1>
<tr><th>Part</th><th>Part No.</th><th>Qty</th>
<tr><td>PIC18F4520 Prototyping Board</td><td>---</td><td>1</td>
<tr><td>Microchip 8-bit PIC Microcontroller</td><td>PIC18F4520</td><td>3</td>
<tr><td>Pittman Motor with Encoder</td><td>GM8224</td><td>3</td>
<tr><td>Hex Inverter Chip</td><td>SN74HC04</td><td>1</td>
<tr><td>Counter Chip</td><td>LS7083</td><td>2</td>
<tr><td>H-Bridge Chip</td><td>L293</td><td>1</td>
<tr><td>Diodes</td><td>1N4001</td><td>8</td>
<tr><td>10K Resistor</td><td>---</td><td>2</td>
<tr><td>Hall Effect Sensor</td><td>A3240LUA-T</td><td>1</td>
<tr><td>Big Cat Super Strong Magnet</td><td>PM20134</td><td>1</td>
</table>

===Set Up===
The electrical design for our project was pretty basic. All of our components (including the Pittman motors) were powered with 5V DC.

PICs

The three PICs communicated via I2C, which enabled us to control the two motors by telling the master PIC what to do (more information can be found [[I2C communication between PICs|here]]). We designated the PIC on the 18F4520 Prototyping Board as the "Master" and the other two PICs as the "Slaves." It is important to connect the clock from the prototyping board to the two Slave PICs, but the two main lines of communication are shared on pin 18 (RC3) on each chip, and pin 23 (RC4).

H-Bridge

Each slave PIC sends an individual pulse to one of the two H-bridges (the L298 has two). The pulse width determines the direction and speed of each motor. At 50% duty cycle, the motor is at rest, while at 0 and 100% duty cycles the motor runs at maximum speed but in opposite directions. Pin 16 from the first slave PIC needs to connect to pin 10 on the L298, while other other should connect to pin 5.

Hex Inverter

Now pins 5 and 10 from the H-bridge needs to go into pins 1 and 13 on the hex inverter chip. The outputs of these two need to go back the the H-bridge as an inverted signal for pulse width modulation (pin 1 to L298's pin 12, and pin 14 to L298's pin 7).

Counter

The last main component that needs to be implemented in the counter chip. This enables us to take fewer counts from the high encoder on the Pittman motors to control the movement of the motor. Pins 4 and 5 are used to connect directly to the blue and yellow lines on each Pittman encoder. Pins 1, 3, and 6 should all be hooked to ground, while pin 2 should be +5V. Pins 7 and 8 should connect to pins 15 and 6, respectively on the slave PIC that is correspondent to this counter chip.

===Schematic===
Here is a visual representation of how our circuit components fit together: 
[[Image:Team-21-circuit.JPG|left|Team Granular Flow Schematic|thumb|400px]]

[[Image:Team-21-circuit-image.JPG|left|Team Granular Flow Circuit|thumb|300px]]
 

==Programming==

===Code Overview===

Three sets of code were required for our project: the MATLAB code for the user interface, C code for the master PIC, and C code for the slave PICs. The MATLAB code set up a GUI for intuitive control of the ball. The master PIC code read all the serial communication from MATLAB and converted it into appropriate I2C commands for the slave PICs, which were completely dedicated to motor control and encoding. All required code is provided below (note an additional code MotorControllerFunctions.c which is used by the master PIC as well).

===PIC Code===

[[Media:BKSBallMasterv1.c|BKSBallMasterv1.c]] 
[[Media:BKSMotorControllerFunctions.c|BKSMotorControllerFunctions.c]] 
[[Media:BKSBallSlavev1.c|BKSBallSlavev1.c]]

===MATLAB Code===

The GUIDE toolset in MATLAB was used to create the GUI.

[[Media:BKSBallControl.m|BKSBallControl.m]] 
[[Media:BKSBallControl.fig|BKSBallControl.fig]]

==Results==

Das.

2008-03-21T10:41:07Z

JonathanShih: /* PIC Code */

[[ME 333 final projects]]

[[Image:Team-21-main-picture.JPG|right|Our Final Design|thumb|500px]] 

==Team Members==
*Brian Kephart - Electrical Engineering Class of 2009
*Jonathan Shih - Mechanical Engineering Class of 2009
*Kristi Bond - Mechanical Engineering Class of 2008

==Overview==

A clear sphere is filled with grains of different sizes. Our apparatus rotates this ball about two different axis based on a series of user inputs. The user inputs the specific values for things such as angle and rotational speed into Matlab. Our device takes these inputs and processes them using a series of master and slave PICs to appropriately control the motors. The motors then turn for the input duration at the desired speed causing the ball to spin correctly due to the frictional connection between both motors and the sphere or lazy susan, respectively.

This apparatus will be used for the study of granular flow and the mixing of particles within the sphere. It was important to leave the ball as visible as possible to allow for pictures to be taken of the grains within from many angles. With this apparatus we hope to aide the study of granular flow theory and allow the researches to use the device for many different applications.

==Mechanical Set-up==

====Main Housing====

The main housing, or case, for our design is composed of the following pieces.

*One 13.5” x 12” x ¾” plywood rectangle
*One 13.5” x 12” x ¾” plywood rectangle with a 3.5” diameter circle removed from the center
*Two 12” x 2.5”x ¾” plywood rectangles

The two larger rectangles form the top and bottom of the set-up with the two smaller rectangles placed vertically between to form a box with two open ends on the front and back face.

====Ball Support====

Three ball casters are placed on vertical mounts around the center circle of the top piece of the housing at equal angles. These casters prevent the ball from moving in any horizontal direction so it is only free to rotate. One of these casters is adjustable to allow the user to make sure the ball is correctly supported above the drive wheel. The force of gravity is strong enough to prevent the ball from moving up and out of the housing and also ensures a good connection with the drive wheel that is placed directly under the center of the sphere.

====Main Drive Wheel====

The main drive wheel is centered under the rotating sphere. The wheel is mounted onto a ¼” aluminum shaft which is connected to the Pittman motor with a flexible coupling and is also supported by a sleeve bearing on the other side of the wheel.

====Lazy Susan====

The main drive wheel with its corresponding motor and other components are all mounted on top of a lazy susan that is centered on the bottom piece of the housing and secured with screws. This lazy susan allows rotational motion but prevents movement in any other direction allowing the wheel to turn but always have the same center of contact with the sphere above. It is important to ensure that the drive wheel has a good connection with the sphere above because the frictional force between the wheel and the sphere must be as large as possible so that as the wheel spins the ball spins at the same rate.

====Position Control Motor====

A second motor is used in our design to turn the lazy susan. The motor is mounted vertically through the top plate. Another, smaller, drive wheel is mounted directly to the motor shaft and then aligned with only the top, free half of the lazy susan. A second, idler wheel is mounted on the bottom plate, so the drive wheel is sandwiched between this wheel and the lazy susan. This ensures that the drive wheel is always in contact with the lazy susan because the idler wheel exerts only a normal force. Again, this is to ensure there is no slip between the lazy susan and the drive wheel so it is automatically controlled more easily.

====Complete Parts List====

<table border=1>
<tr><th>Part</th><th>Part No.</th><th>Qty</th>
<tr><td>Pittman GM8224 motor </td><td>---</td><td>2</td>
<tr><td>Helical Beam Set-Screw Shaft Coupling</td><td> 9861T508 </td><td>1</td>
<tr><td>Mounted Sleeve Bearing</td><td>5912K21 </td><td>1</td>
<tr><td>Flange Mount Ball Caster</td><td>5674K77 </td><td>3</td>
<tr><td>Lazy Susan</td><td>1443T2</td><td>1</td>
<tr><td>Drive Wheel</td><td>60885K23 </td><td>1</td>
<tr><td>Small Drive Wheel</td><td>2471K12 </td><td>1</td>
<tr><td>Idler Wheel</td><td>60885K79 </td><td>1</td>
<tr><td>1/4” Aluminum Rod</td><td>---</td><td>---</td>
<tr><td>Aluminum Sheet Metal</td><td>---</td><td>---</td>
<tr><td>Plywood</td><td>---</td><td>---</td>
</table>

==Circuitry==

===Summary===
Our project was unique in that we relied on the use of three different PICs to precisely coordinate the motion of our ball. The main reason for this was because the 18F4520 chip only has enough encoder inputs for one Pittman motor.

===Component List===
<table border=1>
<tr><th>Part</th><th>Part No.</th><th>Qty</th>
<tr><td>PIC18F4520 Prototyping Board</td><td>---</td><td>1</td>
<tr><td>Microchip 8-bit PIC Microcontroller</td><td>PIC18F4520</td><td>3</td>
<tr><td>Pittman Motor with Encoder</td><td>GM8224</td><td>3</td>
<tr><td>Hex Inverter Chip</td><td>SN74HC04</td><td>1</td>
<tr><td>Counter Chip</td><td>LS7083</td><td>2</td>
<tr><td>H-Bridge Chip</td><td>L293</td><td>1</td>
<tr><td>Diodes</td><td>1N4001</td><td>8</td>
<tr><td>10K Resistor</td><td>---</td><td>2</td>
<tr><td>Hall Effect Sensor</td><td>A3240LUA-T</td><td>1</td>
<tr><td>Big Cat Super Strong Magnet</td><td>PM20134</td><td>1</td>
</table>

===Set Up===
The electrical design for our project was pretty basic. All of our components (including the Pittman motors) were powered with 5V DC.

PICs

The three PICs communicated via I2C, which enabled us to control the two motors by telling the master PIC what to do (more information can be found [[I2C communication between PICs|here]]). We designated the PIC on the 18F4520 Prototyping Board as the "Master" and the other two PICs as the "Slaves." It is important to connect the clock from the prototyping board to the two Slave PICs, but the two main lines of communication are shared on pin 18 (RC3) on each chip, and pin 23 (RC4).

H-Bridge

Each slave PIC sends an individual pulse to one of the two H-bridges (the L298 has two). The pulse width determines the direction and speed of each motor. At 50% duty cycle, the motor is at rest, while at 0 and 100% duty cycles the motor runs at maximum speed but in opposite directions. Pin 16 from the first slave PIC needs to connect to pin 10 on the L298, while other other should connect to pin 5.

Hex Inverter

Now pins 5 and 10 from the H-bridge needs to go into pins 1 and 13 on the hex inverter chip. The outputs of these two need to go back the the H-bridge as an inverted signal for pulse width modulation (pin 1 to L298's pin 12, and pin 14 to L298's pin 7).

Counter

The last main component that needs to be implemented in the counter chip. This enables us to take fewer counts from the high encoder on the Pittman motors to control the movement of the motor. Pins 4 and 5 are used to connect directly to the blue and yellow lines on each Pittman encoder. Pins 1, 3, and 6 should all be hooked to ground, while pin 2 should be +5V. Pins 7 and 8 should connect to pins 15 and 6, respectively on the slave PIC that is correspondent to this counter chip.

===Schematic===
Here is a visual representation of how our circuit components fit together:

[[Image:Team-21-circuit.JPG|left|Team Granular Flow Schematic|thumb|400px]]

[[Image:Team-21-circuit-image.JPG|left|Team Granular Flow Circuit|thumb|300px]]
 
 

==Programming==

===Code Overview===

===PIC Code===

[[Media:BKSBallMasterv1.c|BKSBallMasterv1.c]] 
[[Media:BKSBallSlavev1.c|BKSBallSlavev1.c]]

===MATLAB Code===

The GUIDE toolset in MATLAB was used to create the GUI.

[[Media:BKSBallControl.m|BKSBallControl.m]] 
[[Media:BKSBallControl.fig|BKSBallControl.fig]]

2008-03-21T10:28:39Z

JonathanShih:

File:BKSBallMasterv1.c

2008-03-21T10:28:15Z

JonathanShih:

File:BKSBallControl.fig

2008-03-21T10:27:55Z

JonathanShih:

File:BKSBallControl.m

2008-03-21T10:27:23Z

JonathanShih:

ME 333 final projects

2008-03-21T10:25:22Z

JonathanShih: /* Granular Flow Rotating Sphere */

'''[[ME 333 end of course schedule]]'''

__TOC__

== ME 333 Final Projects 2008 ==

=== [[IR Tracker]] ===

[[Image:IR_Tracker_Main.jpg|right|thumb|200px]]

The IR Tracker (aka "Spot") is a device that follows a moving infrared light. It continuously detects the position of an infrared emitter in two axes, and then tracks the emitter with a laser. [http://depot.northwestern.edu/mht363/public_html/IR%20Track/Mar%2019%20IR%20tracker.mp4 See Spot Run.]

 

=== [[Robot Snake]] ===
[[Image:HLSSnakeMain.jpg|right|thumb|200px]]

This remote control robotic snake uses servo motors with a traveling sine wave motion profile to mimic serpentine motion. The robotic snake is capable of moving forward, left, right and in reverse.
[http://www.youtube.com/watch?v=r_GOOFLnI6w Video of the robot snake]

 

=== [[Programmable Stiffness Joint]] ===

[[Image:SteelToePic2.jpg|thumb|200px|The 'Steel Toe' programmable stiffness joint|right]]

The Programmable Stiffness Joint varies rotational stiffness as desired by the user. It is the first step in modeling the mechanical impedance of the human ankle joint (both stiffness and damping) for the purpose of determining the respective breakdown of the two properties over the gait cycle.

 

=== [[Magnetic based sample purification]] ===

 

=== [[Continuously Variable Transmission]] ===

[[image:CVT_setup1.jpg|thumb|200px]]

This prototype is a proof of concept model of a variable ratio transmission to be implemented in the 2008-2009 Formula SAE competition vehicle. The gear ratio is determined by the distances between the pulley halves which are controllable electronically.

 

=== [[Granular Flow Rotating Sphere]] ===
[[Image:Team-21-main-picture.JPG|right|thumb|200px]]
This device will be used to study the granular flow of particles within a rotating sphere. The sphere is filled with grains of varying size and then rotated about two different axes according to a series of position and angular velocity inputs.

 

=== [[Vibratory Clock]] ===

[[Image:Vibratory_Clock.jpg|right|thumb|Vibratory Clock|200px]]

The Vibratory Clock allows a small object to act as an hour "hand" on a horizontal circular platform that is actuated from underneath by three speakers. The object slides around the circular platform, impelled by friction forces due to the vibration. [http://www.youtube.com/watch?v=KhgTNCfdwZw Check it out!]

 

=== [[WiiMouse]] ===

[[Image:HPIM1027.jpg|right|thumb|200px]]

The WiiMouse is a handheld remote that can be used to move a cursor on a windows-based PC, via accelerometer input captured through device movement.

 

=== [[Intelligent Oscillation Controller]] ===

[[image:ME333_learning_oscillator.jpg|thumb|200px]]

This device "learns" a forcing function that is applied to a spring and mass system to match an arbitrary, periodic acceleration profile.

 

=== [[Baseball]] ===

[[Image:Baseball_Playfield.jpg|Sweet Baseball Game|right|thumb|200px]]

An interactive baseball game inspired by pinball, featuring pitching, batting, light up bases and a scoreboard to keep track of the game.

 

=== [[Ball Balancing Challenge]] ===

[[Image:Ballbalancechallenge.JPG|right|thumb|200px]]

An interactive game involving ball balancing on a touchscreen with touchscreen feedback and joystick action.

Granular Flow Rotating Sphere

2008-03-21T08:17:01Z

JonathanShih: /* Schematic */

[[ME 333 final projects]]

[[Image:Team-21-main-picture.JPG|right|Our Final Design|thumb|500px]] 

==Team Members==
*Brian Kephart - Electrical Engineering Class of 2009
*Jonathan Shih - Mechanical Engineering Class of 2009
*Kristi Bond - Mechanical Engineering Class of 2008

==Overview==

A clear sphere is filled with grains of different sizes. Our apparatus rotates this ball about two different axis based on a series of user inputs. The user inputs the specific values for things such as angle and rotational speed into Matlab. Our device takes these inputs and processes them using a series of master and slave PICs to appropriately control the motors. The motors then turn for the input duration at the desired speed causing the ball to spin correctly due to the frictional connection between both motors and the sphere or lazy susan, respectively.

This apparatus will be used for the study of granular flow and the mixing of particles within the sphere. It was important to leave the ball as visible as possible to allow for pictures to be taken of the grains within from many angles. With this apparatus we hope to aide the study of granular flow theory and allow the researches to use the device for many different applications.

==Mechanical Set-up==

====Main Housing====

The main housing, or case, for our design is composed of the following pieces.

*One 13.5” x 12” x ¾” plywood rectangle
*One 13.5” x 12” x ¾” plywood rectangle with a 3.5” diameter circle removed from the center
*Two 12” x 2.5”x ¾” plywood rectangles

The two larger rectangles form the top and bottom of the set-up with the two smaller rectangles placed vertically between to form a box with two open ends on the front and back face.

====Ball Support====

Three ball casters are placed on vertical mounts around the center circle of the top piece of the housing at equal angles. These casters prevent the ball from moving in any horizontal direction so it is only free to rotate. One of these casters is adjustable to allow the user to make sure the ball is correctly supported above the drive wheel. The force of gravity is strong enough to prevent the ball from moving up and out of the housing and also ensures a good connection with the drive wheel that is placed directly under the center of the sphere.

====Main Drive Wheel====

The main drive wheel is centered under the rotating sphere. The wheel is mounted onto a ¼” aluminum shaft which is connected to the Pittman motor with a flexible coupling and is also supported by a sleeve bearing on the other side of the wheel.

====Lazy Susan====

The main drive wheel with its corresponding motor and other components are all mounted on top of a lazy susan that is centered on the bottom piece of the housing and secured with screws. This lazy susan allows rotational motion but prevents movement in any other direction allowing the wheel to turn but always have the same center of contact with the sphere above. It is important to ensure that the drive wheel has a good connection with the sphere above because the frictional force between the wheel and the sphere must be as large as possible so that as the wheel spins the ball spins at the same rate.

====Position Control Motor====

A second motor is used in our design to turn the lazy susan. The motor is mounted vertically through the top plate. Another, smaller, drive wheel is mounted directly to the motor shaft and then aligned with only the top, free half of the lazy susan. A second, idler wheel is mounted on the bottom plate, so the drive wheel is sandwiched between this wheel and the lazy susan. This ensures that the drive wheel is always in contact with the lazy susan because the idler wheel exerts only a normal force. Again, this is to ensure there is no slip between the lazy susan and the drive wheel so it is automatically controlled more easily.

====Complete Parts List====

<table border=1>
<tr><th>Part</th><th>Part No.</th><th>Qty</th>
<tr><td>Pittman GM8224 motor </td><td>---</td><td>2</td>
<tr><td>Helical Beam Set-Screw Shaft Coupling</td><td> 9861T508 </td><td>1</td>
<tr><td>Mounted Sleeve Bearing</td><td>5912K21 </td><td>1</td>
<tr><td>Flange Mount Ball Caster</td><td>5674K77 </td><td>3</td>
<tr><td>Lazy Susan</td><td>1443T2</td><td>1</td>
<tr><td>Drive Wheel</td><td>60885K23 </td><td>1</td>
<tr><td>Small Drive Wheel</td><td>2471K12 </td><td>1</td>
<tr><td>Idler Wheel</td><td>60885K79 </td><td>1</td>
<tr><td>1/4” Aluminum Rod</td><td>---</td><td>---</td>
<tr><td>Aluminum Sheet Metal</td><td>---</td><td>---</td>
<tr><td>Plywood</td><td>---</td><td>---</td>
</table>

==Circuitry==

===Summary===
Our project was unique in that we relied on the use of three different PICs to precisely coordinate the motion of our ball. The main reason for this was because the 18F4520 chip only has enough encoder inputs for one Pittman motor.

===Component List===
<table border=1>
<tr><th>Part</th><th>Part No.</th><th>Qty</th>
<tr><td>PIC18F4520 Prototyping Board</td><td>---</td><td>1</td>
<tr><td>Microchip 8-bit PIC Microcontroller</td><td>PIC18F4520</td><td>3</td>
<tr><td>Pittman Motor with Encoder</td><td>GM8224</td><td>3</td>
<tr><td>Hex Inverter Chip</td><td>SN74HC04</td><td>1</td>
<tr><td>Counter Chip</td><td>LS7083</td><td>2</td>
<tr><td>H-Bridge Chip</td><td>L293</td><td>1</td>
<tr><td>Diodes</td><td>1N4001</td><td>8</td>
<tr><td>10K Resistor</td><td>---</td><td>2</td>
<tr><td>Hall Effect Sensor</td><td>A3240LUA-T</td><td>1</td>
<tr><td>Big Cat Super Strong Magnet</td><td>PM20134</td><td>1</td>
</table>

===Set Up===
The electrical design for our project was pretty basic. All of our components (including the Pittman motors) were powered with 5V DC.

PICs

The three PICs communicated via I2C, which enabled us to control the two motors by telling the master PIC what to do (more information can be found [[I2C communication between PICs|here]]). We designated the PIC on the 18F4520 Prototyping Board as the "Master" and the other two PICs as the "Slaves." It is important to connect the clock from the prototyping board to the two Slave PICs, but the two main lines of communication are shared on pin 18 (RC3) on each chip, and pin 23 (RC4).

H-Bridge

Each slave PIC sends an individual pulse to one of the two H-bridges (the L298 has two). The pulse width determines the direction and speed of each motor. At 50% duty cycle, the motor is at rest, while at 0 and 100% duty cycles the motor runs at maximum speed but in opposite directions. Pin 16 from the first slave PIC needs to connect to pin 10 on the L298, while other other should connect to pin 5.

Hex Inverter

Now pins 5 and 10 from the H-bridge needs to go into pins 1 and 13 on the hex inverter chip. The outputs of these two need to go back the the H-bridge as an inverted signal for pulse width modulation (pin 1 to L298's pin 12, and pin 14 to L298's pin 7).

Counter

The last main component that needs to be implemented in the counter chip. This enables us to take fewer counts from the high encoder on the Pittman motors to control the movement of the motor. Pins 4 and 5 are used to connect directly to the blue and yellow lines on each Pittman encoder. Pins 1, 3, and 6 should all be hooked to ground, while pin 2 should be +5V. Pins 7 and 8 should connect to pins 15 and 6, respectively on the slave PIC that is correspondent to this counter chip.

===Schematic===
Here is a visual representation of how our circuit components fit together:

[[Image:Team-21-circuit.JPG|left|Team Granular Flow Schematic|thumb|400px]]

[[Image:Team-21-circuit-image.JPG|left|Team Granular Flow Circuit|thumb|300px]] 

==PIC Code==

==Matlab Code==

Storing constant data in program memory

2008-02-21T01:36:11Z

JonathanShih: /* Using a Loop to Write Constant Data */

== Original Assignment ==

Your PIC has a relatively large amount of program memory (32 Kbytes) but relatively little data memory (1536 bytes). For some applications, we want to have lookup tables or calibration data stored on our PIC, but we don't want it hogging data memory. This project is to demonstrate how to write a program that stores constant data in program memory. Test your ability to do this by creating a look-up table for the sin function. This is a 1-d array with integer index corresponding to an angle (e.g., numbers 0 to 89 if the index is in degrees; angles in other quadrants can be determined by simple transformations). Depending on your choice of int8, int16, or float to represent the number, what angle resolution can you use for the index before you reach the limits of program memory?

See p. 43 of the PIC MCU C Compiler book.

Finally, give sample code for storing data in the EEPROM, too.

== Overview ==
The PIC has a relatively large amount of flash program memory (32 Kbytes) but relatively little data memory (1536 bytes of SRAM), as well as a very small amount of EEPROM (256 bytes). For some applications, we want to have lookup tables or calibration data stored on our PIC, but we don't want it hogging data memory. The CCS C Compiler provides a few different ways to use program memory for data, discussed below. We have also provided an example of how to create a look-up table for the sine function to illustrate one of these methods.

=== Constant Data ===
The CONST qualifier will place variables into flash program memory. If the keyword CONST is used before the identifier, the identifier is treated as a constant. These constants need to be initialized and cannot be changed at run-time.

The ROM qualifier puts data into flash program memory with 3 bytes per instruction space. The address used for ROM data is a true byte address not a physical address. The & operator can be used on ROM variables even though the address is logical not physical. Physical memory space is how the data is laid out on the memory in hardware, and may be spaced apart. This is in contrast to logical, or virtual memory, which is how the software views the memory.

The syntax is: const ''type'' ''name''[''size''] = {''values''}
Here's an example storing a list of numbers from 1 to 10 in program memory:
const int iCanCount[10] = {1,2,3,4,5,6,7,8,9,10};

You must initialize the constant variable when you declare it or the compiler will spit out an error at you. This means you cannot use a loop to directly initialize the constant variable (in the case of large arrays). It is also not possible to use a temporary variable to run calculations in a loop before storing in a constant variable because the compiler will not let you declare new variables after running the calculations in the loop.

=== #ROM Directive ===
Another method that can be used to assign data to program memory is the #ROM directive.

The syntax is: #rom address = {data, data, ... , data}

The following example places the numbers 1, 3, 5, 7, 9 into ROM addresses starting at 0x2000:

#rom 0x2000 = {1,3,5,7,9}

You can also put strings into program memory using the #ROM directive:

#rom 0x3000 = {"mechatronicsrocks"}

=== Built-in Functions ===
The compiler provides built in functions to place data in program memory.

write_program_eeprom(address,data);
* Writes data to program memory. data is stored in 16-bit chunks.

write_program_memory(address, dataptr, count);
* Writes count bytes of data from dataptr to address in program memory.
* Every fourth byte of data will not be written, this needs to be filled with 0x00.

== Code ==

===#ROM Directive Examples===
Writes sine values to ROM addresses starting at 0x1000
#rom 0x1000 = {0,0.017452,0.034899,0.052336,0.069756,0.087156,0.104528,0.121869,0.139173,0.156434,
0.173648,0.190809,0.207912,0.224951,0.241922,0.258819,0.275637,0.292372,0.309017,0.325568,
0.34202,0.358368,0.374607,0.390731,0.406737,0.422618,0.438371,0.45399,0.469472,0.48481,0.5,
0.515038,0.529919,0.544639,0.559193,0.573576,0.587785,0.601815,0.615661,0.62932,0.642788,
0.656059,0.669131,0.681998,0.694658,0.707107,0.71934,0.731354,0.743145,0.75471,0.766044,
0.777146,0.788011,0.798636,0.809017,0.819152,0.829038,0.838671,0.848048,0.857167,0.866025,
0.87462,0.882948,0.891007,0.898794,0.906308,0.913545,0.920505,0.927184,0.93358,0.939693,
0.945519,0.951057,0.956305,0.961262,0.965926,0.970296,0.97437,0.978148,0.981627,0.984808,
0.987688,0.990268,0.992546,0.994522,0.996195,0.997564,0.99863,0.999391,0.999848};

===Creating a look-up table for the sine function using CONST===

With values of sine from 0-89°, we can calculate sine values for all 360°. Below is code storing a table of sine values from 0-89° with a angle resolution of 1° and algorithm for calculating sine values for 90-360°.

const float sineTable[90] =
{0,0.017452,0.034899,0.052336,0.069756,0.087156,0.104528,0.121869,0.139173,0.156434,
0.173648,0.190809,0.207912,0.224951,0.241922,0.258819,0.275637,0.292372,0.309017,0.325568,
0.34202,0.358368,0.374607,0.390731,0.406737,0.422618,0.438371,0.45399,0.469472,0.48481,0.5,
0.515038,0.529919,0.544639,0.559193,0.573576,0.587785,0.601815,0.615661,0.62932,0.642788,
0.656059,0.669131,0.681998,0.694658,0.707107,0.71934,0.731354,0.743145,0.75471,0.766044,
0.777146,0.788011,0.798636,0.809017,0.819152,0.829038,0.838671,0.848048,0.857167,0.866025,
0.87462,0.882948,0.891007,0.898794,0.906308,0.913545,0.920505,0.927184,0.93358,0.939693,
0.945519,0.951057,0.956305,0.961262,0.965926,0.970296,0.97437,0.978148,0.981627,0.984808,
0.987688,0.990268,0.992546,0.994522,0.996195,0.997564,0.99863,0.999391,0.999848};

//To look up sine values from the table, you could use a function like the following:
float sineLookup(index){
i = index % 360; //Is there a better way to implement this?
if (i >= 0 && i < 90)
return sineTable[i];
else if (i >= 90 && i < 180)
return sineTable[179-i];
else if (i >= 180 && i < 270)
return -sineTable[180-i];
else if (i >= 270 && i < 360)
return -sineTable[359-i];
end
}

===Using a Loop to Write Constant Data===
Although we must initialize a constant variable when we declare it, it is possible to use loops to calculate an array, which is then stored into program memory via other means.

The code below creates a list of 100 integers using a loop and writes them to program memory:

#include <stdlibm.h>
int * listptr;
int i;
listptr = calloc(1000, sizeof(int)); //allocates memory space for temporary variable
for(i=0x1000;i<=0x13e8;i++){
listptr[i]=i;
write_program_memory(i, listptr[i], 1);}
free(listptr); //deallocates memory used by temporary variable for future use

The data can be retrieved by read_program_memory(address, pointer, count) :ex. read_program_memory(0x1000,listptr,1);

===Memory Management===

The above sine table stores values as floats and is 360 bytes in size. Since the PIC has 32 KB of program memory, we could theoretically hold a sine lookup table precise to 0.01125° (32000/360 = 88.8x larger size; 1°/88.8 = 0.01125°).

*int8 = 8 bit number (1 byte); range 0 to 255 (2-3 digits)
*int16 = 16 bit number (2 bytes); range 0 to 65535 (4-5 digits)
*float = 32 bit number (4 bytes); range -1.5x10^45 to 3.4x10^38 (7-8 digits)

const int8 sineTable[90] = ...

Because int8 cannot hold decimal values, and can only have up to 256 different values, a table made with int8 values might be difficult.
A more realistic version using int16 would be more useful, and could start off like this:

{0,175,349,523,697,872,1045,1219,1392,1564,1736,
1908,2079,2250,2419,2588,2756,2924,3090,3256...}

In your main program, you could insert a function that divides all these values by 10,000 to obtain the decimal value for the sine table.
In the previous example, a sine table would take up 180 bytes. We could theoretically hold a sine lookup table precise to 0.00562° (32000/180 = 177.8x larger size; 1°/177.8 = 0.00562°).

===Creating a sine look-up table using EEPROM===

Writing a sine table to EEPROM:

float data[4];
for (i = 0,i <= 90>>2, i++)
for (j = 0,j<4,j++)
data[j]=sineTable[i<<2 + j];
end
write_program_eeprom(i,data);
end

To read, use:

read_program_eeprom(address)

==References==
*PIC MCU C Compiler
*PICmicro MCU C
*http://en.wikipedia.org/wiki/Memory_address

Storing constant data in program memory

2008-02-21T01:24:39Z

JonathanShih: /* References */

== Original Assignment ==

Your PIC has a relatively large amount of program memory (32 Kbytes) but relatively little data memory (1536 bytes). For some applications, we want to have lookup tables or calibration data stored on our PIC, but we don't want it hogging data memory. This project is to demonstrate how to write a program that stores constant data in program memory. Test your ability to do this by creating a look-up table for the sin function. This is a 1-d array with integer index corresponding to an angle (e.g., numbers 0 to 89 if the index is in degrees; angles in other quadrants can be determined by simple transformations). Depending on your choice of int8, int16, or float to represent the number, what angle resolution can you use for the index before you reach the limits of program memory?

See p. 43 of the PIC MCU C Compiler book.

Finally, give sample code for storing data in the EEPROM, too.

== Overview ==
The PIC has a relatively large amount of flash program memory (32 Kbytes) but relatively little data memory (1536 bytes of SRAM), as well as a very small amount of EEPROM (256 bytes). For some applications, we want to have lookup tables or calibration data stored on our PIC, but we don't want it hogging data memory. The CCS C Compiler provides a few different ways to use program memory for data, discussed below. We have also provided an example of how to create a look-up table for the sine function to illustrate one of these methods.

=== Constant Data ===
The CONST qualifier will place variables into flash program memory. If the keyword CONST is used before the identifier, the identifier is treated as a constant. These constants need to be initialized and cannot be changed at run-time.

The ROM qualifier puts data into flash program memory with 3 bytes per instruction space. The address used for ROM data is a true byte address not a physical address. The & operator can be used on ROM variables even though the address is logical not physical. Physical memory space is how the data is laid out on the memory in hardware, and may be spaced apart. This is in contrast to logical, or virtual memory, which is how the software views the memory.

The syntax is: const ''type'' ''name''[''size''] = {''values''}
Here's an example storing a list of numbers from 1 to 10 in program memory:
const int iCanCount[10] = {1,2,3,4,5,6,7,8,9,10};

You must initialize the constant variable when you declare it or the compiler will spit out an error at you. This means you cannot use a loop to directly initialize the constant variable (in the case of large arrays). It is also not possible to use a temporary variable to run calculations in a loop before storing in a constant variable because the compiler will not let you declare new variables after running the calculations in the loop.

=== #ROM Directive ===
Another method that can be used to assign data to program memory is the #ROM directive.

The syntax is: #rom address = {data, data, ... , data}

The following example places the numbers 1, 3, 5, 7, 9 into ROM addresses starting at 0x2000:

#rom 0x2000 = {1,3,5,7,9}

You can also put strings into program memory using the #ROM directive:

#rom 0x3000 = {"mechatronicsrocks"}

=== Built-in Functions ===
The compiler provides built in functions to place data in program memory.

write_program_eeprom(address,data);
* Writes data to program memory. data is stored in 16-bit chunks.

write_program_memory(address, dataptr, count);
* Writes count bytes of data from dataptr to address in program memory.
* Every fourth byte of data will not be written, this needs to be filled with 0x00.

== Code ==

===#ROM Directive Examples===
Writes sine values to ROM addresses starting at 0x1000
#rom 0x1000 = {0,0.017452,0.034899,0.052336,0.069756,0.087156,0.104528,0.121869,0.139173,0.156434,
0.173648,0.190809,0.207912,0.224951,0.241922,0.258819,0.275637,0.292372,0.309017,0.325568,
0.34202,0.358368,0.374607,0.390731,0.406737,0.422618,0.438371,0.45399,0.469472,0.48481,0.5,
0.515038,0.529919,0.544639,0.559193,0.573576,0.587785,0.601815,0.615661,0.62932,0.642788,
0.656059,0.669131,0.681998,0.694658,0.707107,0.71934,0.731354,0.743145,0.75471,0.766044,
0.777146,0.788011,0.798636,0.809017,0.819152,0.829038,0.838671,0.848048,0.857167,0.866025,
0.87462,0.882948,0.891007,0.898794,0.906308,0.913545,0.920505,0.927184,0.93358,0.939693,
0.945519,0.951057,0.956305,0.961262,0.965926,0.970296,0.97437,0.978148,0.981627,0.984808,
0.987688,0.990268,0.992546,0.994522,0.996195,0.997564,0.99863,0.999391,0.999848};

===Creating a look-up table for the sine function using CONST===

With values of sine from 0-89°, we can calculate sine values for all 360°. Below is code storing a table of sine values from 0-89° with a angle resolution of 1° and algorithm for calculating sine values for 90-360°.

const float sineTable[90] =
{0,0.017452,0.034899,0.052336,0.069756,0.087156,0.104528,0.121869,0.139173,0.156434,
0.173648,0.190809,0.207912,0.224951,0.241922,0.258819,0.275637,0.292372,0.309017,0.325568,
0.34202,0.358368,0.374607,0.390731,0.406737,0.422618,0.438371,0.45399,0.469472,0.48481,0.5,
0.515038,0.529919,0.544639,0.559193,0.573576,0.587785,0.601815,0.615661,0.62932,0.642788,
0.656059,0.669131,0.681998,0.694658,0.707107,0.71934,0.731354,0.743145,0.75471,0.766044,
0.777146,0.788011,0.798636,0.809017,0.819152,0.829038,0.838671,0.848048,0.857167,0.866025,
0.87462,0.882948,0.891007,0.898794,0.906308,0.913545,0.920505,0.927184,0.93358,0.939693,
0.945519,0.951057,0.956305,0.961262,0.965926,0.970296,0.97437,0.978148,0.981627,0.984808,
0.987688,0.990268,0.992546,0.994522,0.996195,0.997564,0.99863,0.999391,0.999848};

//To look up sine values from the table, you could use a function like the following:
float sineLookup(index){
i = index % 360; //Is there a better way to implement this?
if (i >= 0 && i < 90)
return sineTable[i];
else if (i >= 90 && i < 180)
return sineTable[179-i];
else if (i >= 180 && i < 270)
return -sineTable[180-i];
else if (i >= 270 && i < 360)
return -sineTable[359-i];
end
}

===Using a Loop to Write Constant Data===
Although we must initialize a constant variable when we declare it, it is possible to use loops to calculate an array, which is then stored into program memory via other means.

The code below creates a list of 100 integers using a loop and writes them to program memory:
#include <stdlibm.h>
int * listptr;
int i;
listptr = calloc(100, sizeof(int)); //allocates memory space for temporary variable
for(i=0x1000;i<=0x1064;i++){
listptr[i]=i;
write_program_memory(i, listptr[i], 1);}
free(listptr); //deallocates memory used by temporary variable for future use

The data can be retrieved by

===Memory Management===

The above sine table stores values as floats and is 360 bytes in size. Since the PIC has 32 KB of program memory, we could theoretically hold a sine lookup table precise to 0.01125° (32000/360 = 88.8x larger size; 1°/88.8 = 0.01125°).

*int8 = 8 bit number (1 byte); range 0 to 255 (2-3 digits)
*int16 = 16 bit number (2 bytes); range 0 to 65535 (4-5 digits)
*float = 32 bit number (4 bytes); range -1.5x10^45 to 3.4x10^38 (7-8 digits)

const int8 sineTable[90] = ...

Because int8 cannot hold decimal values, and can only have up to 256 different values, a table made with int8 values might be difficult.
A more realistic version using int16 would be more useful, and could start off like this:

{0,175,349,523,697,872,1045,1219,1392,1564,1736,
1908,2079,2250,2419,2588,2756,2924,3090,3256...}

In your main program, you could insert a function that divides all these values by 10,000 to obtain the decimal value for the sine table.
In the previous example, a sine table would take up 180 bytes. We could theoretically hold a sine lookup table precise to 0.00562° (32000/180 = 177.8x larger size; 1°/177.8 = 0.00562°).

===Creating a sine look-up table using EEPROM===

Writing a sine table to EEPROM:

float data[4];
for (i = 0,i <= 90>>2, i++)
for (j = 0,j<4,j++)
data[j]=sineTable[i<<2 + j];
end
write_program_eeprom(i,data);
end

To read, use:

read_program_eeprom(address)

==References==
*PIC MCU C Compiler
*PICmicro MCU C
http://en.wikipedia.org/wiki/Memory_address

Storing constant data in program memory

2008-02-21T00:40:27Z

JonathanShih: /* Code */

== Original Assignment ==

Your PIC has a relatively large amount of program memory (32 Kbytes) but relatively little data memory (1536 bytes). For some applications, we want to have lookup tables or calibration data stored on our PIC, but we don't want it hogging data memory. This project is to demonstrate how to write a program that stores constant data in program memory. Test your ability to do this by creating a look-up table for the sin function. This is a 1-d array with integer index corresponding to an angle (e.g., numbers 0 to 89 if the index is in degrees; angles in other quadrants can be determined by simple transformations). Depending on your choice of int8, int16, or float to represent the number, what angle resolution can you use for the index before you reach the limits of program memory?

See p. 43 of the PIC MCU C Compiler book.

Finally, give sample code for storing data in the EEPROM, too.

== Overview ==
The PIC has a relatively large amount of flash program memory (32 Kbytes) but relatively little data memory (1536 bytes of SRAM), as well as a very small amount of EEPROM (256 bytes). For some applications, we want to have lookup tables or calibration data stored on our PIC, but we don't want it hogging data memory. The CCS C Compiler provides a few different ways to use program memory for data, discussed below. We have also provided an example of how to create a look-up table for the sine function to illustrate one of these methods.

=== Constant Data ===
The CONST qualifier will place variables into flash program memory. If the keyword CONST is used before the identifier, the identifier is treated as a constant. These constants need to be initialized and cannot be changed at run-time.

The ROM qualifier puts data into flash program memory with 3 bytes per instruction space. The address used for ROM data is a true byte address not a physical address. The & operator can be used on ROM variables even though the address is logical not physical. Physical memory space is how the data is laid out on the memory in hardware, and may be spaced apart. This is in contrast to logical, or virtual memory, which is how the software views the memory.

The syntax is: const ''type'' ''name''[''size''] = {''values''}
Here's an example storing a list of numbers from 1 to 10 in program memory:
const int iCanCount[10] = {1,2,3,4,5,6,7,8,9,10};

You must initialize the constant variable when you declare it or the compiler will spit out an error at you. This means you cannot use a loop to directly initialize the constant variable (in the case of large arrays). It is also not possible to use a temporary variable to run calculations in a loop before storing in a constant variable because the compiler will not let you declare new variables after running the calculations in the loop.

=== #ROM Directive ===
Another method that can be used to assign data to program memory is the #ROM directive.

The syntax is: #rom address = {data, data, ... , data}

The following example places the numbers 1, 3, 5, 7, 9 into ROM addresses starting at 0x2000:

#rom 0x2000 = {1,3,5,7,9}

You can also put strings into program memory using the #ROM directive:

#rom 0x3000 = {"mechatronicsrocks"}

=== Built-in Functions ===
The compiler provides built in functions to place data in program memory.

write_program_eeprom(address,data);
* Writes data to program memory. data is stored in 16-bit chunks.

write_program_memory(address, dataptr, count);
* Writes count bytes of data from dataptr to address in program memory.
* Every fourth byte of data will not be written, this needs to be filled with 0x00.

== Code ==

===#ROM Directive Examples===
Writes sine values to ROM addresses starting at 0x1000
#rom 0x1000 = {0,0.017452,0.034899,0.052336,0.069756,0.087156,0.104528,0.121869,0.139173,0.156434,
0.173648,0.190809,0.207912,0.224951,0.241922,0.258819,0.275637,0.292372,0.309017,0.325568,
0.34202,0.358368,0.374607,0.390731,0.406737,0.422618,0.438371,0.45399,0.469472,0.48481,0.5,
0.515038,0.529919,0.544639,0.559193,0.573576,0.587785,0.601815,0.615661,0.62932,0.642788,
0.656059,0.669131,0.681998,0.694658,0.707107,0.71934,0.731354,0.743145,0.75471,0.766044,
0.777146,0.788011,0.798636,0.809017,0.819152,0.829038,0.838671,0.848048,0.857167,0.866025,
0.87462,0.882948,0.891007,0.898794,0.906308,0.913545,0.920505,0.927184,0.93358,0.939693,
0.945519,0.951057,0.956305,0.961262,0.965926,0.970296,0.97437,0.978148,0.981627,0.984808,
0.987688,0.990268,0.992546,0.994522,0.996195,0.997564,0.99863,0.999391,0.999848};

===Creating a look-up table for the sine function using CONST===

With values of sine from 0-89°, we can calculate sine values for all 360°. Below is code storing a table of sine values from 0-89° with a angle resolution of 1° and algorithm for calculating sine values for 90-360°.

const float sineTable[90] =
{0,0.017452,0.034899,0.052336,0.069756,0.087156,0.104528,0.121869,0.139173,0.156434,
0.173648,0.190809,0.207912,0.224951,0.241922,0.258819,0.275637,0.292372,0.309017,0.325568,
0.34202,0.358368,0.374607,0.390731,0.406737,0.422618,0.438371,0.45399,0.469472,0.48481,0.5,
0.515038,0.529919,0.544639,0.559193,0.573576,0.587785,0.601815,0.615661,0.62932,0.642788,
0.656059,0.669131,0.681998,0.694658,0.707107,0.71934,0.731354,0.743145,0.75471,0.766044,
0.777146,0.788011,0.798636,0.809017,0.819152,0.829038,0.838671,0.848048,0.857167,0.866025,
0.87462,0.882948,0.891007,0.898794,0.906308,0.913545,0.920505,0.927184,0.93358,0.939693,
0.945519,0.951057,0.956305,0.961262,0.965926,0.970296,0.97437,0.978148,0.981627,0.984808,
0.987688,0.990268,0.992546,0.994522,0.996195,0.997564,0.99863,0.999391,0.999848};

//To look up sine values from the table, you could use a function like the following:
float sineLookup(index){
i = index % 360; //Is there a better way to implement this?
if (i >= 0 && i < 90)
return sineTable[i];
else if (i >= 90 && i < 180)
return sineTable[179-i];
else if (i >= 180 && i < 270)
return -sineTable[180-i];
else if (i >= 270 && i < 360)
return -sineTable[359-i];
end
}

===Using a Loop to Write Constant Data===
Although we must initialize a constant variable when we declare it, it is possible to use loops to calculate an array, which is then stored into program memory via other means.

The code below creates a list of 100 integers using a loop and writes them to program memory:
#include <stdlibm.h>
int * listptr;
int i;
listptr = calloc(100, sizeof(int)); //allocates memory space for temporary variable
for(i=0x1000;i<=0x1064;i++){
listptr[i]=i;
write_program_memory(i, listptr[i], 1);}
free(listptr); //deallocates memory used by temporary variable for future use

The data can be retrieved by

===Memory Management===

The above sine table stores values as floats and is 360 bytes in size. Since the PIC has 32 KB of program memory, we could theoretically hold a sine lookup table precise to 0.01125° (32000/360 = 88.8x larger size; 1°/88.8 = 0.01125°).

*int8 = 8 bit number (1 byte); range 0 to 255 (2-3 digits)
*int16 = 16 bit number (2 bytes); range 0 to 65535 (4-5 digits)
*float = 32 bit number (4 bytes); range -1.5x10^45 to 3.4x10^38 (7-8 digits)

const int8 sineTable[90] = ...

Because int8 cannot hold decimal values, and can only have up to 256 different values, a table made with int8 values might be difficult.
A more realistic version using int16 would be more useful, and could start off like this:

{0,175,349,523,697,872,1045,1219,1392,1564,1736,
1908,2079,2250,2419,2588,2756,2924,3090,3256...}

In your main program, you could insert a function that divides all these values by 10,000 to obtain the decimal value for the sine table.
In the previous example, a sine table would take up 180 bytes. We could theoretically hold a sine lookup table precise to 0.00562° (32000/180 = 177.8x larger size; 1°/177.8 = 0.00562°).

===Creating a sine look-up table using EEPROM===

Writing a sine table to EEPROM:

float data[4];
for (i = 0,i <= 90>>2, i++)
for (j = 0,j<4,j++)
data[j]=sineTable[i<<2 + j];
end
write_program_eeprom(i,data);
end

To read, use:

read_program_eeprom(address)

==References==
*PIC MCU C Compiler
*PICmicro MCU C

Storing constant data in program memory

2008-02-21T00:09:13Z

JonathanShih: /* Constant Data */

== Original Assignment ==

Your PIC has a relatively large amount of program memory (32 Kbytes) but relatively little data memory (1536 bytes). For some applications, we want to have lookup tables or calibration data stored on our PIC, but we don't want it hogging data memory. This project is to demonstrate how to write a program that stores constant data in program memory. Test your ability to do this by creating a look-up table for the sin function. This is a 1-d array with integer index corresponding to an angle (e.g., numbers 0 to 89 if the index is in degrees; angles in other quadrants can be determined by simple transformations). Depending on your choice of int8, int16, or float to represent the number, what angle resolution can you use for the index before you reach the limits of program memory?

See p. 43 of the PIC MCU C Compiler book.

Finally, give sample code for storing data in the EEPROM, too.

== Overview ==
The PIC has a relatively large amount of flash program memory (32 Kbytes) but relatively little data memory (1536 bytes of SRAM), as well as a very small amount of EEPROM (256 bytes). For some applications, we want to have lookup tables or calibration data stored on our PIC, but we don't want it hogging data memory. The CCS C Compiler provides a few different ways to use program memory for data, discussed below. We have also provided an example of how to create a look-up table for the sine function to illustrate one of these methods.

=== Constant Data ===
The CONST qualifier will place variables into flash program memory. If the keyword CONST is used before the identifier, the identifier is treated as a constant. These constants need to be initialized and cannot be changed at run-time.

The ROM qualifier puts data into flash program memory with 3 bytes per instruction space. The address used for ROM data is a true byte address not a physical address. The & operator can be used on ROM variables even though the address is logical not physical. Physical memory space is how the data is laid out on the memory in hardware, and may be spaced apart. This is in contrast to logical, or virtual memory, which is how the software views the memory.

The syntax is: const ''type'' ''name''[''size''] = {''values''}
Here's an example storing a list of numbers from 1 to 10 in program memory:
const int iCanCount[10] = {1,2,3,4,5,6,7,8,9,10};

You must initialize the constant variable when you declare it or the compiler will spit out an error at you. This means you cannot use a loop to directly initialize the constant variable (in the case of large arrays). It is also not possible to use a temporary variable to run calculations in a loop before storing in a constant variable because the compiler will not let you declare new variables after running the calculations in the loop.

=== #ROM Directive ===
Another method that can be used to assign data to program memory is the #ROM directive.

The syntax is: #rom address = {data, data, ... , data}

The following example places the numbers 1, 3, 5, 7, 9 into ROM addresses starting at 0x2000:

#rom 0x2000 = {1,3,5,7,9}

You can also put strings into program memory using the #ROM directive:

#rom 0x3000 = {"mechatronicsrocks"}

=== Built-in Functions ===
The compiler provides built in functions to place data in program memory.

write_program_eeprom(address,data);
* Writes data to program memory. data is stored in 16-bit chunks.

write_program_memory(address, dataptr, count);
* Writes count bytes of data from dataptr to address in program memory.
* Every fourth byte of data will not be written, this needs to be filled with 0x00.

== Code ==

===#ROM Directive Examples===
Writes sine values to ROM addresses starting at 0x1000
#rom 0x1000 = {0,0.017452,0.034899,0.052336,0.069756,0.087156,0.104528,0.121869,0.139173,0.156434,
0.173648,0.190809,0.207912,0.224951,0.241922,0.258819,0.275637,0.292372,0.309017,0.325568,
0.34202,0.358368,0.374607,0.390731,0.406737,0.422618,0.438371,0.45399,0.469472,0.48481,0.5,
0.515038,0.529919,0.544639,0.559193,0.573576,0.587785,0.601815,0.615661,0.62932,0.642788,
0.656059,0.669131,0.681998,0.694658,0.707107,0.71934,0.731354,0.743145,0.75471,0.766044,
0.777146,0.788011,0.798636,0.809017,0.819152,0.829038,0.838671,0.848048,0.857167,0.866025,
0.87462,0.882948,0.891007,0.898794,0.906308,0.913545,0.920505,0.927184,0.93358,0.939693,
0.945519,0.951057,0.956305,0.961262,0.965926,0.970296,0.97437,0.978148,0.981627,0.984808,
0.987688,0.990268,0.992546,0.994522,0.996195,0.997564,0.99863,0.999391,0.999848};

===Creating a look-up table for the sine function using CONST===

*int8 = 8 bit number (1 byte); range 0 to 255 (2-3 digits)
*int16 = 16 bit number (2 bytes); range 0 to 65535 (4-5 digits)
*float = 32 bit number (4 bytes); range -1.5x10^45 to 3.4x10^38 (7-8 digits)

With values of sine from 0-89°, we can calculate sine values for all 360°. Below is code storing a table of sine values from 0-89° with a angle resolution of 1° and algorithm for calculating sine values for 90-360°.

const float sineTable[90] =
{0,0.017452,0.034899,0.052336,0.069756,0.087156,0.104528,0.121869,0.139173,0.156434,
0.173648,0.190809,0.207912,0.224951,0.241922,0.258819,0.275637,0.292372,0.309017,0.325568,
0.34202,0.358368,0.374607,0.390731,0.406737,0.422618,0.438371,0.45399,0.469472,0.48481,0.5,
0.515038,0.529919,0.544639,0.559193,0.573576,0.587785,0.601815,0.615661,0.62932,0.642788,
0.656059,0.669131,0.681998,0.694658,0.707107,0.71934,0.731354,0.743145,0.75471,0.766044,
0.777146,0.788011,0.798636,0.809017,0.819152,0.829038,0.838671,0.848048,0.857167,0.866025,
0.87462,0.882948,0.891007,0.898794,0.906308,0.913545,0.920505,0.927184,0.93358,0.939693,
0.945519,0.951057,0.956305,0.961262,0.965926,0.970296,0.97437,0.978148,0.981627,0.984808,
0.987688,0.990268,0.992546,0.994522,0.996195,0.997564,0.99863,0.999391,0.999848};

//To look up sine values from the table, you could use a function like the following:
float sineLookup(index){
i = index % 360; //Is there a better way to implement this?
if (i >= 0 && i < 90)
return sineTable[i];
else if (i >= 90 && i < 180)
return sineTable[179-i];
else if (i >= 180 && i < 270)
return -sineTable[180-i];
else if (i >= 270 && i < 360)
return -sineTable[359-i];
end
}

===Using a Loop to Write Constant Data===

===Memory Management===

This table stores values as floats and is 360 bytes in size. Since the PIC has 32 KB of program memory, we could theoretically hold a sine lookup table precise to 0.01125° (32000/360 = 88.8x larger size; 1°/88.8 = 0.01125°).

const int8 sineTable[90] = ...

Because int8 cannot hold decimal values, and can only have up to 256 different values, a table made with int8 values might be difficult.
A more realistic version using int16 would be more useful, and could start off like this:

{0,175,349,523,697,872,1045,1219,1392,1564,1736,
1908,2079,2250,2419,2588,2756,2924,3090,3256...}

In your main program, you could insert a function that divides all these values by 10,000 to obtain the decimal value for the sine table.
In the previous example, a sine table would take up 180 bytes. We could theoretically hold a sine lookup table precise to 0.00562° (32000/180 = 177.8x larger size; 1°/177.8 = 0.00562°).

===Creating a sine look-up table using EEPROM===

Writing a sine table to EEPROM:

float data[4];
for (i = 0,i <= 90>>2, i++)
for (j = 0,j<4,j++)
data[j]=sineTable[i<<2 + j];
end
write_program_eeprom(i,data);
end

To read, use:

read_program_eeprom(address)

==References==
*PIC MCU C Compiler
*PICmicro MCU C

Storing constant data in program memory

2008-02-20T23:38:06Z

JonathanShih: /* Code */

== Original Assignment ==

Your PIC has a relatively large amount of program memory (32 Kbytes) but relatively little data memory (1536 bytes). For some applications, we want to have lookup tables or calibration data stored on our PIC, but we don't want it hogging data memory. This project is to demonstrate how to write a program that stores constant data in program memory. Test your ability to do this by creating a look-up table for the sin function. This is a 1-d array with integer index corresponding to an angle (e.g., numbers 0 to 89 if the index is in degrees; angles in other quadrants can be determined by simple transformations). Depending on your choice of int8, int16, or float to represent the number, what angle resolution can you use for the index before you reach the limits of program memory?

See p. 43 of the PIC MCU C Compiler book.

Finally, give sample code for storing data in the EEPROM, too.

== Overview ==
The PIC has a relatively large amount of flash program memory (32 Kbytes) but relatively little data memory (1536 bytes of SRAM), as well as a very small amount of EEPROM (256 bytes). For some applications, we want to have lookup tables or calibration data stored on our PIC, but we don't want it hogging data memory. The CCS C Compiler provides a few different ways to use program memory for data, discussed below. We have also provided an example of how to create a look-up table for the sine function to illustrate one of these methods.

=== Constant Data ===
The CONST qualifier will place variables into program memory. If the keyword CONST is used before the identifier, the identifier is treated as a constant. These constants need to be initialized and cannot be changed at run-time.

The ROM qualifier puts data in program memory with 3 bytes per instruction space. The address used for ROM data is a true byte address not a physical address. The & operator can be used on ROM variables even though the address is logical not physical.

The syntax is: const ''type'' ''name''[''size''] = {''values''}
Here's an example storing a list of numbers from 1 to 10 in program memory:
const int iCanCount[10] = {1,2,3,4,5,6,7,8,9,10};

You must initialize the constant variable when you declare it or the compiler will spit out an error at you. Which means, unfortunately, you can't do something like:

const int listOfNumbers[100];
for (i = 0; i < 100; i++)
listOfNumbers[i] = i;
end

It is also not possible to use a temporary variable to run calculations in a loop before storing in a constant variable because the compiler will not let you declare new variables after running the calculations in the loop.

=== #ROM Directive ===
Another method that can be used to assign data to program memory is the #ROM directive.

The syntax is: #rom address = {data, data, ... , data}

The following example places the numbers 1, 3, 5, 7, 9 into ROM addresses starting at 0x2000:

#rom 0x2000 = {1, 3, 5, 7, 9}

You can also put strings into program memory using the #ROM directive:

#rom 0x3000 = {"mechatronicsrocks"}

=== Built-in Functions ===
The compiler provides built in functions to place data in program memory.

write_program_eeprom(address,data);
* Writes data to program memory. data is stored in 16-bit chunks.

write_program_memory(address, dataptr, count);
* Writes count bytes of data from dataptr to address in program memory.
* Every fourth byte of data will not be written, this needs to be filled with 0x00.

== Code ==

===#ROM Directive Examples===
Writes sine values to ROM addresses starting at 0x1000
#rom 0x1000 = {0,0.017452,0.034899,0.052336,0.069756,0.087156,0.104528,0.121869,0.139173,0.156434,
0.173648,0.190809,0.207912,0.224951,0.241922,0.258819,0.275637,0.292372,0.309017,0.325568,
0.34202,0.358368,0.374607,0.390731,0.406737,0.422618,0.438371,0.45399,0.469472,0.48481,0.5,
0.515038,0.529919,0.544639,0.559193,0.573576,0.587785,0.601815,0.615661,0.62932,0.642788,
0.656059,0.669131,0.681998,0.694658,0.707107,0.71934,0.731354,0.743145,0.75471,0.766044,
0.777146,0.788011,0.798636,0.809017,0.819152,0.829038,0.838671,0.848048,0.857167,0.866025,
0.87462,0.882948,0.891007,0.898794,0.906308,0.913545,0.920505,0.927184,0.93358,0.939693,
0.945519,0.951057,0.956305,0.961262,0.965926,0.970296,0.97437,0.978148,0.981627,0.984808,
0.987688,0.990268,0.992546,0.994522,0.996195,0.997564,0.99863,0.999391,0.999848};

===Creating a look-up table for the sine function using CONST===

*int8 = 8 bit number (1 byte); range 0 to 255 (2-3 digits)
*int16 = 16 bit number (2 bytes); range 0 to 65535 (4-5 digits)
*float = 32 bit number (4 bytes); range -1.5x10^45 to 3.4x10^38 (7-8 digits)

With values of sine from 0-89°, we can calculate sine values for all 360°. Below is code storing a table of sine values from 0-89° with a angle resolution of 1° and algorithm for calculating sine values for 90-360°.

const float sineTable[90] =
{0,0.017452,0.034899,0.052336,0.069756,0.087156,0.104528,0.121869,0.139173,0.156434,
0.173648,0.190809,0.207912,0.224951,0.241922,0.258819,0.275637,0.292372,0.309017,0.325568,
0.34202,0.358368,0.374607,0.390731,0.406737,0.422618,0.438371,0.45399,0.469472,0.48481,0.5,
0.515038,0.529919,0.544639,0.559193,0.573576,0.587785,0.601815,0.615661,0.62932,0.642788,
0.656059,0.669131,0.681998,0.694658,0.707107,0.71934,0.731354,0.743145,0.75471,0.766044,
0.777146,0.788011,0.798636,0.809017,0.819152,0.829038,0.838671,0.848048,0.857167,0.866025,
0.87462,0.882948,0.891007,0.898794,0.906308,0.913545,0.920505,0.927184,0.93358,0.939693,
0.945519,0.951057,0.956305,0.961262,0.965926,0.970296,0.97437,0.978148,0.981627,0.984808,
0.987688,0.990268,0.992546,0.994522,0.996195,0.997564,0.99863,0.999391,0.999848};

//To look up sine values from the table, you could use a function like the following:
float sineLookup(index){
i = index % 360; //Is there a better way to implement this?
if (i >= 0 && i < 90)
return sineTable[i];
else if (i >= 90 && i < 180)
return sineTable[179-i];
else if (i >= 180 && i < 270)
return -sineTable[180-i];
else if (i >= 270 && i < 360)
return -sineTable[359-i];
end
}

===Using a Loop to Write Constant Data===

===Memory Management===

This table stores values as floats and is 360 bytes in size. Since the PIC has 32 KB of program memory, we could theoretically hold a sine lookup table precise to 0.01125° (32000/360 = 88.8x larger size; 1°/88.8 = 0.01125°).

const int8 sineTable[90] = ...

Because int8 cannot hold decimal values, and can only have up to 256 different values, a table made with int8 values might be difficult.
A more realistic version using int16 would be more useful, and could start off like this:

{0,175,349,523,697,872,1045,1219,1392,1564,1736,
1908,2079,2250,2419,2588,2756,2924,3090,3256...}

In your main program, you could insert a function that divides all these values by 10,000 to obtain the decimal value for the sine table.
In the previous example, a sine table would take up 180 bytes. We could theoretically hold a sine lookup table precise to 0.00562° (32000/180 = 177.8x larger size; 1°/177.8 = 0.00562°).

===Creating a sine look-up table using EEPROM===

Writing a sine table to EEPROM:

float data[4];
for (i = 0,i <= 90>>2, i++)
for (j = 0,j<4,j++)
data[j]=sineTable[i<<2 + j];
end
write_program_eeprom(i,data);
end

To read, use:

read_program_eeprom(address)

==References==

Storing constant data in program memory

2008-02-20T23:36:32Z

JonathanShih: /* Constant Data */

== Original Assignment ==

Your PIC has a relatively large amount of program memory (32 Kbytes) but relatively little data memory (1536 bytes). For some applications, we want to have lookup tables or calibration data stored on our PIC, but we don't want it hogging data memory. This project is to demonstrate how to write a program that stores constant data in program memory. Test your ability to do this by creating a look-up table for the sin function. This is a 1-d array with integer index corresponding to an angle (e.g., numbers 0 to 89 if the index is in degrees; angles in other quadrants can be determined by simple transformations). Depending on your choice of int8, int16, or float to represent the number, what angle resolution can you use for the index before you reach the limits of program memory?

See p. 43 of the PIC MCU C Compiler book.

Finally, give sample code for storing data in the EEPROM, too.

== Overview ==
The PIC has a relatively large amount of flash program memory (32 Kbytes) but relatively little data memory (1536 bytes of SRAM), as well as a very small amount of EEPROM (256 bytes). For some applications, we want to have lookup tables or calibration data stored on our PIC, but we don't want it hogging data memory. The CCS C Compiler provides a few different ways to use program memory for data, discussed below. We have also provided an example of how to create a look-up table for the sine function to illustrate one of these methods.

=== Constant Data ===
The CONST qualifier will place variables into program memory. If the keyword CONST is used before the identifier, the identifier is treated as a constant. These constants need to be initialized and cannot be changed at run-time.

The ROM qualifier puts data in program memory with 3 bytes per instruction space. The address used for ROM data is a true byte address not a physical address. The & operator can be used on ROM variables even though the address is logical not physical.

The syntax is: const ''type'' ''name''[''size''] = {''values''}
Here's an example storing a list of numbers from 1 to 10 in program memory:
const int iCanCount[10] = {1,2,3,4,5,6,7,8,9,10};

You must initialize the constant variable when you declare it or the compiler will spit out an error at you. Which means, unfortunately, you can't do something like:

const int listOfNumbers[100];
for (i = 0; i < 100; i++)
listOfNumbers[i] = i;
end

It is also not possible to use a temporary variable to run calculations in a loop before storing in a constant variable because the compiler will not let you declare new variables after running the calculations in the loop.

=== #ROM Directive ===
Another method that can be used to assign data to program memory is the #ROM directive.

The syntax is: #rom address = {data, data, ... , data}

The following example places the numbers 1, 3, 5, 7, 9 into ROM addresses starting at 0x2000:

#rom 0x2000 = {1, 3, 5, 7, 9}

You can also put strings into program memory using the #ROM directive:

#rom 0x3000 = {"mechatronicsrocks"}

=== Built-in Functions ===
The compiler provides built in functions to place data in program memory.

write_program_eeprom(address,data);
* Writes data to program memory. data is stored in 16-bit chunks.

write_program_memory(address, dataptr, count);
* Writes count bytes of data from dataptr to address in program memory.
* Every fourth byte of data will not be written, this needs to be filled with 0x00.

== Code ==

===#ROM Directive Examples===
Writes sine values to ROM addresses starting at 0x1000
#rom 0x1000 = {0,0.017452,0.034899,0.052336,0.069756,0.087156,0.104528,0.121869,0.139173,0.156434,
0.173648,0.190809,0.207912,0.224951,0.241922,0.258819,0.275637,0.292372,0.309017,0.325568,
0.34202,0.358368,0.374607,0.390731,0.406737,0.422618,0.438371,0.45399,0.469472,0.48481,0.5,
0.515038,0.529919,0.544639,0.559193,0.573576,0.587785,0.601815,0.615661,0.62932,0.642788,
0.656059,0.669131,0.681998,0.694658,0.707107,0.71934,0.731354,0.743145,0.75471,0.766044,
0.777146,0.788011,0.798636,0.809017,0.819152,0.829038,0.838671,0.848048,0.857167,0.866025,
0.87462,0.882948,0.891007,0.898794,0.906308,0.913545,0.920505,0.927184,0.93358,0.939693,
0.945519,0.951057,0.956305,0.961262,0.965926,0.970296,0.97437,0.978148,0.981627,0.984808,
0.987688,0.990268,0.992546,0.994522,0.996195,0.997564,0.99863,0.999391,0.999848};

===Creating a look-up table for the sine function using CONST===

*int8 = 8 bit number (1 byte); range 0 to 255 (2-3 digits)
*int16 = 16 bit number (2 bytes); range 0 to 65535 (4-5 digits)
*float = 32 bit number (4 bytes); range -1.5x10^45 to 3.4x10^38 (7-8 digits)

With values of sine from 0-89°, we can calculate sine values for all 360°. Below is code storing a table of sine values from 0-89° with a angle resolution of 1° and algorithm for calculating sine values for 90-360°.

const float sineTable[90] =
{0,0.017452,0.034899,0.052336,0.069756,0.087156,0.104528,0.121869,0.139173,0.156434,
0.173648,0.190809,0.207912,0.224951,0.241922,0.258819,0.275637,0.292372,0.309017,0.325568,
0.34202,0.358368,0.374607,0.390731,0.406737,0.422618,0.438371,0.45399,0.469472,0.48481,0.5,
0.515038,0.529919,0.544639,0.559193,0.573576,0.587785,0.601815,0.615661,0.62932,0.642788,
0.656059,0.669131,0.681998,0.694658,0.707107,0.71934,0.731354,0.743145,0.75471,0.766044,
0.777146,0.788011,0.798636,0.809017,0.819152,0.829038,0.838671,0.848048,0.857167,0.866025,
0.87462,0.882948,0.891007,0.898794,0.906308,0.913545,0.920505,0.927184,0.93358,0.939693,
0.945519,0.951057,0.956305,0.961262,0.965926,0.970296,0.97437,0.978148,0.981627,0.984808,
0.987688,0.990268,0.992546,0.994522,0.996195,0.997564,0.99863,0.999391,0.999848};

//To look up sine values from the table, you could use a function like the following:
float sineLookup(index){
i = index % 360; //Is there a better way to implement this?
if (i >= 0 && i < 90)
return sineTable[i];
else if (i >= 90 && i < 180)
return sineTable[179-i];
else if (i >= 180 && i < 270)
return -sineTable[180-i];
else if (i >= 270 && i < 360)
return -sineTable[359-i];
end
}

===Memory Management===

This table stores values as floats and is 360 bytes in size. Since the PIC has 32 KB of program memory, we could theoretically hold a sine lookup table precise to 0.01125° (32000/360 = 88.8x larger size; 1°/88.8 = 0.01125°).

const int8 sineTable[90] = ...

Because int8 cannot hold decimal values, and can only have up to 256 different values, a table made with int8 values might be difficult.
A more realistic version using int16 would be more useful, and could start off like this:

{0,175,349,523,697,872,1045,1219,1392,1564,1736,
1908,2079,2250,2419,2588,2756,2924,3090,3256...}

In your main program, you could insert a function that divides all these values by 10,000 to obtain the decimal value for the sine table.
In the previous example, a sine table would take up 180 bytes. We could theoretically hold a sine lookup table precise to 0.00562° (32000/180 = 177.8x larger size; 1°/177.8 = 0.00562°).

===Creating a sine look-up table using EEPROM===

Writing a sine table to EEPROM:

float data[4];
for (i = 0,i <= 90>>2, i++)
for (j = 0,j<4,j++)
data[j]=sineTable[i<<2 + j];
end
write_program_eeprom(i,data);
end

To read, use:

read_program_eeprom(address)

==References==

Storing constant data in program memory

2008-02-20T18:31:30Z

JonathanShih: /* Overview */

== Original Assignment ==

Your PIC has a relatively large amount of program memory (32 Kbytes) but relatively little data memory (1536 bytes). For some applications, we want to have lookup tables or calibration data stored on our PIC, but we don't want it hogging data memory. This project is to demonstrate how to write a program that stores constant data in program memory. Test your ability to do this by creating a look-up table for the sin function. This is a 1-d array with integer index corresponding to an angle (e.g., numbers 0 to 89 if the index is in degrees; angles in other quadrants can be determined by simple transformations). Depending on your choice of int8, int16, or float to represent the number, what angle resolution can you use for the index before you reach the limits of program memory?

See p. 43 of the PIC MCU C Compiler book.

Finally, give sample code for storing data in the EEPROM, too.

== Overview ==
The PIC has a relatively large amount of flash program memory (32 Kbytes) but relatively little data memory (1536 bytes of SRAM), as well as a very small amount of EEPROM (256 bytes). For some applications, we want to have lookup tables or calibration data stored on our PIC, but we don't want it hogging data memory. The CCS C Compiler provides a few different ways to use program memory for data, discussed below. We have also provided an example of how to create a look-up table for the sine function to illustrate one of these methods.

=== Constant Data ===
The CONST qualifier will place variables into program memory. If the keyword CONST is used before the identifier, the identifier is treated as a constant. These constants need to be initialized and cannot be changed at run-time.

The ROM qualifier puts data in program memory with 3 bytes per instruction space. The address used for ROM data is a true byte address not a physical address. The & operator can be used on ROM variables even though the address is logical not physical.

The syntax is: const ''type'' ''name''[''size''] = {''values''}
Here's an example storing a list of numbers from 1 to 10 in program memory:
const int iCanCount[10] = {1,2,3,4,5,6,7,8,9,10};

You must initialize the constant variable when you declare it or the compiler will spit out an error at you. Which means, unfortunately, you can't do something like:

const int listOfNumbers[100];
for (i = 0; i < 100; i++)
listOfNumbers[i] = i;
end

What you may be able to do, though, is this:
int * temp;
temp = (int*) calloc(num, sizeof(int)); //allocates memory space for temporary variable
for (i = 0; i < 100; i++)
temp[i] = i;
end
const int listOfNumbers[100] = temp; //still need to try this...
free(temp); //deallocates memory used by temporary variable for future use

=== #ROM Directive ===
Another method that can be used to assign data to program memory is the #ROM directive.

The syntax is: #rom address = {data, data, ... , data}

The following example places the numbers 1, 3, 5, 7, 9 into ROM addresses starting at 0x2000:

#rom 0x2000 = {1, 3, 5, 7, 9}

You can also put strings into program memory using the #ROM directive:

#rom 0x3000 = {"mechatronicsrocks"}

=== Built-in Functions ===
The compiler provides built in functions to place data in program memory.

write_program_eeprom(address,data);
* Writes data to program memory. data is stored in 16-bit chunks.

write_program_memory(address, dataptr, count);
* Writes count bytes of data from dataptr to address in program memory.
* Every fourth byte of data will not be written, this needs to be filled with 0x00.

== Code ==

===#ROM Directive Examples===
Writes sine values to ROM addresses starting at 0x1000
#rom 0x1000 = {0,0.017452,0.034899,0.052336,0.069756,0.087156,0.104528,0.121869,0.139173,0.156434,
0.173648,0.190809,0.207912,0.224951,0.241922,0.258819,0.275637,0.292372,0.309017,0.325568,
0.34202,0.358368,0.374607,0.390731,0.406737,0.422618,0.438371,0.45399,0.469472,0.48481,0.5,
0.515038,0.529919,0.544639,0.559193,0.573576,0.587785,0.601815,0.615661,0.62932,0.642788,
0.656059,0.669131,0.681998,0.694658,0.707107,0.71934,0.731354,0.743145,0.75471,0.766044,
0.777146,0.788011,0.798636,0.809017,0.819152,0.829038,0.838671,0.848048,0.857167,0.866025,
0.87462,0.882948,0.891007,0.898794,0.906308,0.913545,0.920505,0.927184,0.93358,0.939693,
0.945519,0.951057,0.956305,0.961262,0.965926,0.970296,0.97437,0.978148,0.981627,0.984808,
0.987688,0.990268,0.992546,0.994522,0.996195,0.997564,0.99863,0.999391,0.999848};

===Creating a look-up table for the sine function using CONST===

*int8 = 8 bit number (1 byte); range 0 to 255 (2-3 digits)
*int16 = 16 bit number (2 bytes); range 0 to 65535 (4-5 digits)
*float = 32 bit number (4 bytes); range -1.5x10^45 to 3.4x10^38 (7-8 digits)

With values of sine from 0-89°, we can calculate sine values for all 360°. Below is code storing a table of sine values from 0-89° with a angle resolution of 1° and algorithm for calculating sine values for 90-360°.

const float sineTable[90] =
{0,0.017452,0.034899,0.052336,0.069756,0.087156,0.104528,0.121869,0.139173,0.156434,
0.173648,0.190809,0.207912,0.224951,0.241922,0.258819,0.275637,0.292372,0.309017,0.325568,
0.34202,0.358368,0.374607,0.390731,0.406737,0.422618,0.438371,0.45399,0.469472,0.48481,0.5,
0.515038,0.529919,0.544639,0.559193,0.573576,0.587785,0.601815,0.615661,0.62932,0.642788,
0.656059,0.669131,0.681998,0.694658,0.707107,0.71934,0.731354,0.743145,0.75471,0.766044,
0.777146,0.788011,0.798636,0.809017,0.819152,0.829038,0.838671,0.848048,0.857167,0.866025,
0.87462,0.882948,0.891007,0.898794,0.906308,0.913545,0.920505,0.927184,0.93358,0.939693,
0.945519,0.951057,0.956305,0.961262,0.965926,0.970296,0.97437,0.978148,0.981627,0.984808,
0.987688,0.990268,0.992546,0.994522,0.996195,0.997564,0.99863,0.999391,0.999848};

//To look up sine values from the table, you could use a function like the following:
float sineLookup(index){
i = index % 360; //Is there a better way to implement this?
if (i >= 0 && i < 90)
return sineTable[i];
else if (i >= 90 && i < 180)
return sineTable[179-i];
else if (i >= 180 && i < 270)
return -sineTable[180-i];
else if (i >= 270 && i < 360)
return -sineTable[359-i];
end
}

===Memory Management===

This table stores values as floats and is 360 bytes in size. Since the PIC has 32 KB of program memory, we could theoretically hold a sine lookup table precise to 0.01125° (32000/360 = 88.8x larger size; 1°/88.8 = 0.01125°).

const int8 sineTable[90] = ...

Because int8 cannot hold decimal values, and can only have up to 256 different values, a table made with int8 values might be difficult.
A more realistic version using int16 would be more useful, and could start off like this:

{0,175,349,523,697,872,1045,1219,1392,1564,1736,
1908,2079,2250,2419,2588,2756,2924,3090,3256...}

In your main program, you could insert a function that divides all these values by 10,000 to obtain the decimal value for the sine table.
In the previous example, a sine table would take up 180 bytes. We could theoretically hold a sine lookup table precise to 0.00562° (32000/180 = 177.8x larger size; 1°/177.8 = 0.00562°).

===Creating a sine look-up table using EEPROM===

Writing a sine table to EEPROM:

float data[4];
for (i = 0,i <= 90>>2, i++)
for (j = 0,j<4,j++)
data[j]=sineTable[i<<2 + j];
end
write_program_eeprom(i,data);
end

To read, use:

read_program_eeprom(address)

==References==

Storing constant data in program memory

2008-02-20T18:29:27Z

JonathanShih: /* Code */

== Original Assignment ==

Your PIC has a relatively large amount of program memory (32 Kbytes) but relatively little data memory (1536 bytes). For some applications, we want to have lookup tables or calibration data stored on our PIC, but we don't want it hogging data memory. This project is to demonstrate how to write a program that stores constant data in program memory. Test your ability to do this by creating a look-up table for the sin function. This is a 1-d array with integer index corresponding to an angle (e.g., numbers 0 to 89 if the index is in degrees; angles in other quadrants can be determined by simple transformations). Depending on your choice of int8, int16, or float to represent the number, what angle resolution can you use for the index before you reach the limits of program memory?

See p. 43 of the PIC MCU C Compiler book.

Finally, give sample code for storing data in the EEPROM, too.

== Overview ==
The PIC has a relatively large amount of program memory (32 Kbytes) but relatively little data memory (1536 bytes). For some applications, we want to have lookup tables or calibration data stored on our PIC, but we don't want it hogging data memory. The CCS C Compiler provides a few different ways to use program memory for data, discussed below. We have also provided an example of how to create a look-up table for the sine function to illustrate one of these methods.

32 KB of flash program memory
1536 bytes SRAM
256 bytes EEPROM

=== Constant Data ===
The CONST qualifier will place variables into program memory. If the keyword CONST is used before the identifier, the identifier is treated as a constant. These constants need to be initialized and cannot be changed at run-time.

The ROM qualifier puts data in program memory with 3 bytes per instruction space. The address used for ROM data is a true byte address not a physical address. The & operator can be used on ROM variables even though the address is logical not physical.

The syntax is: const ''type'' ''name''[''size''] = {''values''}
Here's an example storing a list of numbers from 1 to 10 in program memory:
const int iCanCount[10] = {1,2,3,4,5,6,7,8,9,10};

You must initialize the constant variable when you declare it or the compiler will spit out an error at you. Which means, unfortunately, you can't do something like:

const int listOfNumbers[100];
for (i = 0; i < 100; i++)
listOfNumbers[i] = i;
end

What you may be able to do, though, is this:
int * temp;
temp = (int*) calloc(num, sizeof(int)); //allocates memory space for temporary variable
for (i = 0; i < 100; i++)
temp[i] = i;
end
const int listOfNumbers[100] = temp; //still need to try this...
free(temp); //deallocates memory used by temporary variable for future use

=== #ROM Directive ===
Another method that can be used to assign data to program memory is the #ROM directive.

The syntax is: #rom address = {data, data, ... , data}

The following example places the numbers 1, 3, 5, 7, 9 into ROM addresses starting at 0x2000:

#rom 0x2000 = {1, 3, 5, 7, 9}

You can also put strings into program memory using the #ROM directive:

#rom 0x3000 = {"mechatronicsrocks"}

=== Built-in Functions ===
The compiler provides built in functions to place data in program memory.

write_program_eeprom(address,data);
* Writes data to program memory. data is stored in 16-bit chunks.

write_program_memory(address, dataptr, count);
* Writes count bytes of data from dataptr to address in program memory.
* Every fourth byte of data will not be written, this needs to be filled with 0x00.

== Code ==

===#ROM Directive Examples===
Writes sine values to ROM addresses starting at 0x1000
#rom 0x1000 = {0,0.017452,0.034899,0.052336,0.069756,0.087156,0.104528,0.121869,0.139173,0.156434,
0.173648,0.190809,0.207912,0.224951,0.241922,0.258819,0.275637,0.292372,0.309017,0.325568,
0.34202,0.358368,0.374607,0.390731,0.406737,0.422618,0.438371,0.45399,0.469472,0.48481,0.5,
0.515038,0.529919,0.544639,0.559193,0.573576,0.587785,0.601815,0.615661,0.62932,0.642788,
0.656059,0.669131,0.681998,0.694658,0.707107,0.71934,0.731354,0.743145,0.75471,0.766044,
0.777146,0.788011,0.798636,0.809017,0.819152,0.829038,0.838671,0.848048,0.857167,0.866025,
0.87462,0.882948,0.891007,0.898794,0.906308,0.913545,0.920505,0.927184,0.93358,0.939693,
0.945519,0.951057,0.956305,0.961262,0.965926,0.970296,0.97437,0.978148,0.981627,0.984808,
0.987688,0.990268,0.992546,0.994522,0.996195,0.997564,0.99863,0.999391,0.999848};

===Creating a look-up table for the sine function using CONST===

*int8 = 8 bit number (1 byte); range 0 to 255 (2-3 digits)
*int16 = 16 bit number (2 bytes); range 0 to 65535 (4-5 digits)
*float = 32 bit number (4 bytes); range -1.5x10^45 to 3.4x10^38 (7-8 digits)

With values of sine from 0-89°, we can calculate sine values for all 360°. Below is code storing a table of sine values from 0-89° with a angle resolution of 1° and algorithm for calculating sine values for 90-360°.

const float sineTable[90] =
{0,0.017452,0.034899,0.052336,0.069756,0.087156,0.104528,0.121869,0.139173,0.156434,
0.173648,0.190809,0.207912,0.224951,0.241922,0.258819,0.275637,0.292372,0.309017,0.325568,
0.34202,0.358368,0.374607,0.390731,0.406737,0.422618,0.438371,0.45399,0.469472,0.48481,0.5,
0.515038,0.529919,0.544639,0.559193,0.573576,0.587785,0.601815,0.615661,0.62932,0.642788,
0.656059,0.669131,0.681998,0.694658,0.707107,0.71934,0.731354,0.743145,0.75471,0.766044,
0.777146,0.788011,0.798636,0.809017,0.819152,0.829038,0.838671,0.848048,0.857167,0.866025,
0.87462,0.882948,0.891007,0.898794,0.906308,0.913545,0.920505,0.927184,0.93358,0.939693,
0.945519,0.951057,0.956305,0.961262,0.965926,0.970296,0.97437,0.978148,0.981627,0.984808,
0.987688,0.990268,0.992546,0.994522,0.996195,0.997564,0.99863,0.999391,0.999848};

//To look up sine values from the table, you could use a function like the following:
float sineLookup(index){
i = index % 360; //Is there a better way to implement this?
if (i >= 0 && i < 90)
return sineTable[i];
else if (i >= 90 && i < 180)
return sineTable[179-i];
else if (i >= 180 && i < 270)
return -sineTable[180-i];
else if (i >= 270 && i < 360)
return -sineTable[359-i];
end
}

===Memory Management===

This table stores values as floats and is 360 bytes in size. Since the PIC has 32 KB of program memory, we could theoretically hold a sine lookup table precise to 0.01125° (32000/360 = 88.8x larger size; 1°/88.8 = 0.01125°).

const int8 sineTable[90] = ...

Because int8 cannot hold decimal values, and can only have up to 256 different values, a table made with int8 values might be difficult.
A more realistic version using int16 would be more useful, and could start off like this:

{0,175,349,523,697,872,1045,1219,1392,1564,1736,
1908,2079,2250,2419,2588,2756,2924,3090,3256...}

In your main program, you could insert a function that divides all these values by 10,000 to obtain the decimal value for the sine table.
In the previous example, a sine table would take up 180 bytes. We could theoretically hold a sine lookup table precise to 0.00562° (32000/180 = 177.8x larger size; 1°/177.8 = 0.00562°).

===Creating a sine look-up table using EEPROM===

Writing a sine table to EEPROM:

float data[4];
for (i = 0,i <= 90>>2, i++)
for (j = 0,j<4,j++)
data[j]=sineTable[i<<2 + j];
end
write_program_eeprom(i,data);
end

To read, use:

read_program_eeprom(address)

==References==

Storing constant data in program memory

2008-02-20T18:21:02Z

JonathanShih: /* Constant Data */

== Original Assignment ==

Your PIC has a relatively large amount of program memory (32 Kbytes) but relatively little data memory (1536 bytes). For some applications, we want to have lookup tables or calibration data stored on our PIC, but we don't want it hogging data memory. This project is to demonstrate how to write a program that stores constant data in program memory. Test your ability to do this by creating a look-up table for the sin function. This is a 1-d array with integer index corresponding to an angle (e.g., numbers 0 to 89 if the index is in degrees; angles in other quadrants can be determined by simple transformations). Depending on your choice of int8, int16, or float to represent the number, what angle resolution can you use for the index before you reach the limits of program memory?

See p. 43 of the PIC MCU C Compiler book.

Finally, give sample code for storing data in the EEPROM, too.

== Overview ==
The PIC has a relatively large amount of program memory (32 Kbytes) but relatively little data memory (1536 bytes). For some applications, we want to have lookup tables or calibration data stored on our PIC, but we don't want it hogging data memory. The CCS C Compiler provides a few different ways to use program memory for data, discussed below. We have also provided an example of how to create a look-up table for the sine function to illustrate one of these methods.

32 KB of flash program memory
1536 bytes SRAM
256 bytes EEPROM

=== Constant Data ===
The CONST qualifier will place variables into program memory. If the keyword CONST is used before the identifier, the identifier is treated as a constant. These constants need to be initialized and cannot be changed at run-time.

The ROM qualifier puts data in program memory with 3 bytes per instruction space. The address used for ROM data is a true byte address not a physical address. The & operator can be used on ROM variables even though the address is logical not physical.

The syntax is: const ''type'' ''name''[''size''] = {''values''}
Here's an example storing a list of numbers from 1 to 10 in program memory:
const int iCanCount[10] = {1,2,3,4,5,6,7,8,9,10};

You must initialize the constant variable when you declare it or the compiler will spit out an error at you. Which means, unfortunately, you can't do something like:

const int listOfNumbers[100];
for (i = 0; i < 100; i++)
listOfNumbers[i] = i;
end

What you may be able to do, though, is this:
int * temp;
temp = (int*) calloc(num, sizeof(int)); //allocates memory space for temporary variable
for (i = 0; i < 100; i++)
temp[i] = i;
end
const int listOfNumbers[100] = temp; //still need to try this...
free(temp); //deallocates memory used by temporary variable for future use

=== #ROM Directive ===
Another method that can be used to assign data to program memory is the #ROM directive.

The syntax is: #rom address = {data, data, ... , data}

The following example places the numbers 1, 3, 5, 7, 9 into ROM addresses starting at 0x2000:

#rom 0x2000 = {1, 3, 5, 7, 9}

You can also put strings into program memory using the #ROM directive:

#rom 0x3000 = {"mechatronicsrocks"}

=== Built-in Functions ===
The compiler provides built in functions to place data in program memory.

write_program_eeprom(address,data);
* Writes data to program memory. data is stored in 16-bit chunks.

write_program_memory(address, dataptr, count);
* Writes count bytes of data from dataptr to address in program memory.
* Every fourth byte of data will not be written, this needs to be filled with 0x00.

== Code ==

===#ROM Directive Examples===
Writes sine values to ROM addresses starting at 0x1000
#rom 0x1000 = {0,0.017452,0.034899,0.052336,0.069756,0.087156,0.104528,0.121869,0.139173,0.156434,
0.173648,0.190809,0.207912,0.224951,0.241922,0.258819,0.275637,0.292372,0.309017,0.325568,
0.34202,0.358368,0.374607,0.390731,0.406737,0.422618,0.438371,0.45399,0.469472,0.48481,0.5,
0.515038,0.529919,0.544639,0.559193,0.573576,0.587785,0.601815,0.615661,0.62932,0.642788,
0.656059,0.669131,0.681998,0.694658,0.707107,0.71934,0.731354,0.743145,0.75471,0.766044,
0.777146,0.788011,0.798636,0.809017,0.819152,0.829038,0.838671,0.848048,0.857167,0.866025,
0.87462,0.882948,0.891007,0.898794,0.906308,0.913545,0.920505,0.927184,0.93358,0.939693,
0.945519,0.951057,0.956305,0.961262,0.965926,0.970296,0.97437,0.978148,0.981627,0.984808,
0.987688,0.990268,0.992546,0.994522,0.996195,0.997564,0.99863,0.999391,0.999848};

===Creating a look-up table for the sine function using CONST===

*int8 = 8 bit number (1 byte); range 0 to 255 (2-3 digits)
*int16 = 16 bit number (2 bytes); range 0 to 65535 (4-5 digits)
*float = 32 bit number (4 bytes); range -1.5x10^45 to 3.4x10^38 (7-8 digits)

With values of sine from 0-89°, we can calculate sine values for all 360°. Below is code storing a table of sine values from 0-89° with a angle resolution of 1° and algorithm for calculating sine values for 90-360°.

const float sineTable[90] =
{0,0.017452,0.034899,0.052336,0.069756,0.087156,0.104528,0.121869,0.139173,0.156434,
0.173648,0.190809,0.207912,0.224951,0.241922,0.258819,0.275637,0.292372,0.309017,0.325568,
0.34202,0.358368,0.374607,0.390731,0.406737,0.422618,0.438371,0.45399,0.469472,0.48481,0.5,
0.515038,0.529919,0.544639,0.559193,0.573576,0.587785,0.601815,0.615661,0.62932,0.642788,
0.656059,0.669131,0.681998,0.694658,0.707107,0.71934,0.731354,0.743145,0.75471,0.766044,
0.777146,0.788011,0.798636,0.809017,0.819152,0.829038,0.838671,0.848048,0.857167,0.866025,
0.87462,0.882948,0.891007,0.898794,0.906308,0.913545,0.920505,0.927184,0.93358,0.939693,
0.945519,0.951057,0.956305,0.961262,0.965926,0.970296,0.97437,0.978148,0.981627,0.984808,
0.987688,0.990268,0.992546,0.994522,0.996195,0.997564,0.99863,0.999391,0.999848};

//To look up sine values from the table, you could use a function like the following:
float sineLookup(index){
i = index % 360; //Is there a better way to implement this?
if (i >= 0 && i < 90)
return sineTable[i];
else if (i >= 90 && i < 180)
return sineTable[179-i];
else if (i >= 180 && i < 270)
return -sineTable[180-i];
else if (i >= 270 && i < 360)
return -sineTable[359-i];
end
}

===Memory Management===

This table stores values as floats and is 360 bytes in size. Since the PIC has 32 KB of program memory, we could theoretically hold a sine lookup table precise to 0.01125° (32000/360 = 88.8x larger size; 1°/88.8 = 0.01125°).

const int8 sineTable[90] = ...

Because int8 cannot hold decimal values, and can only have up to 256 different values, a table made with int8 values might be difficult.
A more realistic version using int16 would be more useful, and could start off like this:

{0,175,349,523,697,872,1045,1219,1392,1564,1736,
1908,2079,2250,2419,2588,2756,2924,3090,3256...}

In your main program, you could insert a function that divides all these values by 10,000 to obtain the decimal value for the sine table.
In the previous example, a sine table would take up 180 bytes. We could theoretically hold a sine lookup table precise to 0.00562° (32000/180 = 177.8x larger size; 1°/177.8 = 0.00562°).

===Creating a sine look-up table using EEPROM===

Writing a sine table to EEPROM:

float data[4];
for (i = 0,i <= 90>>2, i++)
for (j = 0,j<4,j++)
data[j]=sineTable[i<<2 + j];
end
write_program_eeprom(i,data);
end

To read, use:

read_program_eeprom(address)

Storing constant data in program memory

2008-02-20T18:19:57Z

JonathanShih: /* Constant Data */

== Original Assignment ==

Your PIC has a relatively large amount of program memory (32 Kbytes) but relatively little data memory (1536 bytes). For some applications, we want to have lookup tables or calibration data stored on our PIC, but we don't want it hogging data memory. This project is to demonstrate how to write a program that stores constant data in program memory. Test your ability to do this by creating a look-up table for the sin function. This is a 1-d array with integer index corresponding to an angle (e.g., numbers 0 to 89 if the index is in degrees; angles in other quadrants can be determined by simple transformations). Depending on your choice of int8, int16, or float to represent the number, what angle resolution can you use for the index before you reach the limits of program memory?

See p. 43 of the PIC MCU C Compiler book.

Finally, give sample code for storing data in the EEPROM, too.

== Overview ==
The PIC has a relatively large amount of program memory (32 Kbytes) but relatively little data memory (1536 bytes). For some applications, we want to have lookup tables or calibration data stored on our PIC, but we don't want it hogging data memory. The CCS C Compiler provides a few different ways to use program memory for data, discussed below. We have also provided an example of how to create a look-up table for the sine function to illustrate one of these methods.

32 KB of flash program memory
1536 bytes SRAM
256 bytes EEPROM

=== Constant Data ===
The CONST qualifier will place variables into program memory. If the keyword CONST is used before the identifier, the identifier is treated as a constant. These constants need to be initialized and cannot be changed at run-time.

The ROM qualifier puts data in program memory with 3 bytes per instruction space. The address used for ROM data is a true byte address not a physical address. The & operator can be used on ROM variables even though the address is logical not physical.

The syntax is: const ''type'' ''name''[''size''] = {''values''}
Here's an example storing a list of numbers from 1 to 10 in program memory:
const int iCanCount[10] = {1,2,3,4,5,6,7,8,9,10};

You must initialize the constant variable when you declare it or the compiler will spit out an error at you. Which means, unfortunately, you can't do something like:

const int listOfNumbers[100];
for (i = 0; i < 100; i++)
listOfNumbers[i] = i;
end

What you may be able to do, though, is this:
int * temp;
temp = (int*) calloc(num, sizeof(int));
for (i = 0; i < 100; i++)
temp[i] = i;
end
const int listOfNumbers[100] = temp;
free(temp); //still need to try this

=== #ROM Directive ===
Another method that can be used to assign data to program memory is the #ROM directive.

The syntax is: #rom address = {data, data, ... , data}

The following example places the numbers 1, 3, 5, 7, 9 into ROM addresses starting at 0x2000:

#rom 0x2000 = {1, 3, 5, 7, 9}

You can also put strings into program memory using the #ROM directive:

#rom 0x3000 = {"mechatronicsrocks"}

=== Built-in Functions ===
The compiler provides built in functions to place data in program memory.

write_program_eeprom(address,data);
* Writes data to program memory. data is stored in 16-bit chunks.

write_program_memory(address, dataptr, count);
* Writes count bytes of data from dataptr to address in program memory.
* Every fourth byte of data will not be written, this needs to be filled with 0x00.

== Code ==

===#ROM Directive Examples===
Writes sine values to ROM addresses starting at 0x1000
#rom 0x1000 = {0,0.017452,0.034899,0.052336,0.069756,0.087156,0.104528,0.121869,0.139173,0.156434,
0.173648,0.190809,0.207912,0.224951,0.241922,0.258819,0.275637,0.292372,0.309017,0.325568,
0.34202,0.358368,0.374607,0.390731,0.406737,0.422618,0.438371,0.45399,0.469472,0.48481,0.5,
0.515038,0.529919,0.544639,0.559193,0.573576,0.587785,0.601815,0.615661,0.62932,0.642788,
0.656059,0.669131,0.681998,0.694658,0.707107,0.71934,0.731354,0.743145,0.75471,0.766044,
0.777146,0.788011,0.798636,0.809017,0.819152,0.829038,0.838671,0.848048,0.857167,0.866025,
0.87462,0.882948,0.891007,0.898794,0.906308,0.913545,0.920505,0.927184,0.93358,0.939693,
0.945519,0.951057,0.956305,0.961262,0.965926,0.970296,0.97437,0.978148,0.981627,0.984808,
0.987688,0.990268,0.992546,0.994522,0.996195,0.997564,0.99863,0.999391,0.999848};

===Creating a look-up table for the sine function using CONST===

*int8 = 8 bit number (1 byte); range 0 to 255 (2-3 digits)
*int16 = 16 bit number (2 bytes); range 0 to 65535 (4-5 digits)
*float = 32 bit number (4 bytes); range -1.5x10^45 to 3.4x10^38 (7-8 digits)

With values of sine from 0-89°, we can calculate sine values for all 360°. Below is code storing a table of sine values from 0-89° with a angle resolution of 1° and algorithm for calculating sine values for 90-360°.

const float sineTable[90] =
{0,0.017452,0.034899,0.052336,0.069756,0.087156,0.104528,0.121869,0.139173,0.156434,
0.173648,0.190809,0.207912,0.224951,0.241922,0.258819,0.275637,0.292372,0.309017,0.325568,
0.34202,0.358368,0.374607,0.390731,0.406737,0.422618,0.438371,0.45399,0.469472,0.48481,0.5,
0.515038,0.529919,0.544639,0.559193,0.573576,0.587785,0.601815,0.615661,0.62932,0.642788,
0.656059,0.669131,0.681998,0.694658,0.707107,0.71934,0.731354,0.743145,0.75471,0.766044,
0.777146,0.788011,0.798636,0.809017,0.819152,0.829038,0.838671,0.848048,0.857167,0.866025,
0.87462,0.882948,0.891007,0.898794,0.906308,0.913545,0.920505,0.927184,0.93358,0.939693,
0.945519,0.951057,0.956305,0.961262,0.965926,0.970296,0.97437,0.978148,0.981627,0.984808,
0.987688,0.990268,0.992546,0.994522,0.996195,0.997564,0.99863,0.999391,0.999848};

//To look up sine values from the table, you could use a function like the following:
float sineLookup(index){
i = index % 360; //Is there a better way to implement this?
if (i >= 0 && i < 90)
return sineTable[i];
else if (i >= 90 && i < 180)
return sineTable[179-i];
else if (i >= 180 && i < 270)
return -sineTable[180-i];
else if (i >= 270 && i < 360)
return -sineTable[359-i];
end
}

===Memory Management===

This table stores values as floats and is 360 bytes in size. Since the PIC has 32 KB of program memory, we could theoretically hold a sine lookup table precise to 0.01125° (32000/360 = 88.8x larger size; 1°/88.8 = 0.01125°).

const int8 sineTable[90] = ...

Because int8 cannot hold decimal values, and can only have up to 256 different values, a table made with int8 values might be difficult.
A more realistic version using int16 would be more useful, and could start off like this:

{0,175,349,523,697,872,1045,1219,1392,1564,1736,
1908,2079,2250,2419,2588,2756,2924,3090,3256...}

In your main program, you could insert a function that divides all these values by 10,000 to obtain the decimal value for the sine table.
In the previous example, a sine table would take up 180 bytes. We could theoretically hold a sine lookup table precise to 0.00562° (32000/180 = 177.8x larger size; 1°/177.8 = 0.00562°).

===Creating a sine look-up table using EEPROM===

Writing a sine table to EEPROM:

float data[4];
for (i = 0,i <= 90>>2, i++)
for (j = 0,j<4,j++)
data[j]=sineTable[i<<2 + j];
end
write_program_eeprom(i,data);
end

To read, use:

read_program_eeprom(address)

Storing constant data in program memory

2008-02-14T00:56:28Z

JonathanShih: /* Overview */

== Original Assignment ==

Your PIC has a relatively large amount of program memory (32 Kbytes) but relatively little data memory (1536 bytes). For some applications, we want to have lookup tables or calibration data stored on our PIC, but we don't want it hogging data memory. This project is to demonstrate how to write a program that stores constant data in program memory. Test your ability to do this by creating a look-up table for the sin function. This is a 1-d array with integer index corresponding to an angle (e.g., numbers 0 to 89 if the index is in degrees; angles in other quadrants can be determined by simple transformations). Depending on your choice of int8, int16, or float to represent the number, what angle resolution can you use for the index before you reach the limits of program memory?

See p. 43 of the PIC MCU C Compiler book.

Finally, give sample code for storing data in the EEPROM, too.

== Overview ==
The PIC has a relatively large amount of program memory (32 Kbytes) but relatively little data memory (1536 bytes). For some applications, we want to have lookup tables or calibration data stored on our PIC, but we don't want it hogging data memory. The CCS C Compiler provides a few different ways to use program memory for data, discussed below. We have also provided an example of how to create a look-up table for the sine function to illustrate one of these methods.

32 KB of flash program memory
1536 bytes SRAM
256 bytes EEPROM

=== Constant Data ===
The CONST qualifier will place variables into program memory. If the keyword CONST is used before the identifier, the identifier is treated as a constant. These constants need to be initialized and cannot be changed at run-time.

The ROM qualifier puts data in program memory with 3 bytes per instruction space. The address used for ROM data is a true byte address not a physical address. The & operator can be used on ROM variables even though the address is logical not physical.

The syntax is: const ''type'' ''name''[''size''] = {''values''}
Here's an example storing a list of numbers from 1 to 10 in program memory:
const int iCanCount[10] = {1,2,3,4,5,6,7,8,9,10};

You must initialize the constant variable when you declare it or the compiler will spit out an error at you. Which means, unfortunately, you can't do something like:

const int listOfNumbers[100];
for (i = 0; i < 100; i++)
listOfNumbers[i] = i;
end

What you may be able to do, though, is this:
int temp[100];
for (i = 0; i < 100; i++)
temp[i] = i;
end
const int listOfNumbers[100] = temp; //still need to try this

=== #ROM Directive ===
Another method that can be used to assign data to program memory is the #ROM directive.

The syntax is: #rom address = {data, data, ... , data}

The following example places the numbers 1, 3, 5, 7, 9 into ROM addresses starting at 0x2000:

#rom 0x2000 = {1, 3, 5, 7, 9}

You can also put strings into program memory using the #ROM directive:

#rom 0x3000 = {"mechatronicsrocks"}

=== Built-in Functions ===
The compiler provides built in functions to place data in program memory.

write_program_eeprom(address,data);
* Writes data to program memory. data is stored in 16-bit chunks.

write_program_memory(address, dataptr, count);
* Writes count bytes of data from dataptr to address in program memory.
* Every fourth byte of data will not be written, this needs to be filled with 0x00.

== Code ==

===#ROM Directive Examples===
Writes sine values to ROM addresses starting at 0x1000
#rom 0x1000 = {0,0.017452,0.034899,0.052336,0.069756,0.087156,0.104528,0.121869,0.139173,0.156434,
0.173648,0.190809,0.207912,0.224951,0.241922,0.258819,0.275637,0.292372,0.309017,0.325568,
0.34202,0.358368,0.374607,0.390731,0.406737,0.422618,0.438371,0.45399,0.469472,0.48481,0.5,
0.515038,0.529919,0.544639,0.559193,0.573576,0.587785,0.601815,0.615661,0.62932,0.642788,
0.656059,0.669131,0.681998,0.694658,0.707107,0.71934,0.731354,0.743145,0.75471,0.766044,
0.777146,0.788011,0.798636,0.809017,0.819152,0.829038,0.838671,0.848048,0.857167,0.866025,
0.87462,0.882948,0.891007,0.898794,0.906308,0.913545,0.920505,0.927184,0.93358,0.939693,
0.945519,0.951057,0.956305,0.961262,0.965926,0.970296,0.97437,0.978148,0.981627,0.984808,
0.987688,0.990268,0.992546,0.994522,0.996195,0.997564,0.99863,0.999391,0.999848};

===Creating a look-up table for the sine function using CONST===

*int8 = 8 bit number (1 byte); range 0 to 255 (2-3 digits)
*int16 = 16 bit number (2 bytes); range 0 to 65535 (4-5 digits)
*float = 32 bit number (4 bytes); range -1.5x10^45 to 3.4x10^38 (7-8 digits)

With values of sine from 0-89°, we can calculate sine values for all 360°. Below is code storing a table of sine values from 0-89° with a angle resolution of 1° and algorithm for calculating sine values for 90-360°.

const float sineTable[90] =
{0,0.017452,0.034899,0.052336,0.069756,0.087156,0.104528,0.121869,0.139173,0.156434,
0.173648,0.190809,0.207912,0.224951,0.241922,0.258819,0.275637,0.292372,0.309017,0.325568,
0.34202,0.358368,0.374607,0.390731,0.406737,0.422618,0.438371,0.45399,0.469472,0.48481,0.5,
0.515038,0.529919,0.544639,0.559193,0.573576,0.587785,0.601815,0.615661,0.62932,0.642788,
0.656059,0.669131,0.681998,0.694658,0.707107,0.71934,0.731354,0.743145,0.75471,0.766044,
0.777146,0.788011,0.798636,0.809017,0.819152,0.829038,0.838671,0.848048,0.857167,0.866025,
0.87462,0.882948,0.891007,0.898794,0.906308,0.913545,0.920505,0.927184,0.93358,0.939693,
0.945519,0.951057,0.956305,0.961262,0.965926,0.970296,0.97437,0.978148,0.981627,0.984808,
0.987688,0.990268,0.992546,0.994522,0.996195,0.997564,0.99863,0.999391,0.999848};

//To look up sine values from the table, you could use a function like the following:
float sineLookup(index){
i = index % 360; //Is there a better way to implement this?
if (i >= 0 && i < 90)
return sineTable[i];
else if (i >= 90 && i < 180)
return sineTable[179-i];
else if (i >= 180 && i < 270)
return -sineTable[180-i];
else if (i >= 270 && i < 360)
return -sineTable[359-i];
end
}

===Memory Management===

This table stores values as floats and is 360 bytes in size. Since the PIC has 32 KB of program memory, we could theoretically hold a sine lookup table precise to 0.01125° (32000/360 = 88.8x larger size; 1°/88.8 = 0.01125°).

const int8 sineTable[90] = ...

Because int8 cannot hold decimal values, and can only have up to 256 different values, a table made with int8 values might be difficult.
A more realistic version using int16 would be more useful, and could start off like this:

{0,175,349,523,697,872,1045,1219,1392,1564,1736,
1908,2079,2250,2419,2588,2756,2924,3090,3256...}

In your main program, you could insert a function that divides all these values by 10,000 to obtain the decimal value for the sine table.
In the previous example, a sine table would take up 180 bytes. We could theoretically hold a sine lookup table precise to 0.00562° (32000/180 = 177.8x larger size; 1°/177.8 = 0.00562°).

===Creating a sine look-up table using EEPROM===

Writing a sine table to EEPROM:

float data[4];
for (i = 0,i <= 90>>2, i++)
for (j = 0,j<4,j++)
data[j]=sineTable[i<<2 + j];
end
write_program_eeprom(i,data);
end

To read, use:

read_program_eeprom(address)

Storing constant data in program memory

2008-02-14T00:43:30Z

JonathanShih: /* Constant Data */

== Original Assignment ==

Your PIC has a relatively large amount of program memory (32 Kbytes) but relatively little data memory (1536 bytes). For some applications, we want to have lookup tables or calibration data stored on our PIC, but we don't want it hogging data memory. This project is to demonstrate how to write a program that stores constant data in program memory. Test your ability to do this by creating a look-up table for the sin function. This is a 1-d array with integer index corresponding to an angle (e.g., numbers 0 to 89 if the index is in degrees; angles in other quadrants can be determined by simple transformations). Depending on your choice of int8, int16, or float to represent the number, what angle resolution can you use for the index before you reach the limits of program memory?

See p. 43 of the PIC MCU C Compiler book.

Finally, give sample code for storing data in the EEPROM, too.

== Overview ==
The PIC has a relatively large amount of program memory (32 Kbytes) but relatively little data memory (1536 bytes). For some applications, we want to have lookup tables or calibration data stored on our PIC, but we don't want it hogging data memory. The CCS C Compiler provides a few different ways to use program memory for data, discussed below. We have also provided an example of how to create a look-up table for the sin function to illustrate one of these methods.

=== Constant Data ===
The CONST qualifier will place variables into program memory. If the keyword CONST is used before the identifier, the identifier is treated as a constant. These constants need to be initialized and cannot be changed at run-time.

The ROM qualifier puts data in program memory with 3 bytes per instruction space. The address used for ROM data is a true byte address not a physical address. The & operator can be used on ROM variables even though the address is logical not physical.

The syntax is: const ''type'' ''name''[''size''] = {''values''}
Here's an example storing a list of numbers from 1 to 10 in program memory:
const int iCanCount[10] = {1,2,3,4,5,6,7,8,9,10};

You must initialize the constant variable when you declare it or the compiler will spit out an error at you. Which means, unfortunately, you can't do something like:

const int listOfNumbers[100];
for (i = 0; i < 100; i++)
listOfNumbers[i] = i;
end

What you may be able to do, though, is this:
int temp[100];
for (i = 0; i < 100; i++)
temp[i] = i;
end
const int listOfNumbers[100] = temp; //still need to try this

=== #ROM Directive ===
Another method that can be used to assign data to program memory is the #ROM directive.

The syntax is: #rom address = {data, data, ... , data}

The following example places the numbers 1, 3, 5, 7, 9 into ROM addresses starting at 0x2000:

#rom 0x2000 = {1, 3, 5, 7, 9}

You can also put strings into program memory using the #ROM directive:

#rom 0x3000 = {"mechatronicsrocks"}

=== Built-in Functions ===
The compiler provides built in functions to place data in program memory.

write_program_eeprom(address,data);
* Writes data to program memory. data is stored in 16-bit chunks.

write_program_memory(address, dataptr, count);
* Writes count bytes of data from dataptr to address in program memory.
* Every fourth byte of data will not be written, this needs to be filled with 0x00.

== Code ==

===#ROM Directive Examples===
Writes sine values to ROM addresses starting at 0x1000
#rom 0x1000 = {0,0.017452,0.034899,0.052336,0.069756,0.087156,0.104528,0.121869,0.139173,0.156434,
0.173648,0.190809,0.207912,0.224951,0.241922,0.258819,0.275637,0.292372,0.309017,0.325568,
0.34202,0.358368,0.374607,0.390731,0.406737,0.422618,0.438371,0.45399,0.469472,0.48481,0.5,
0.515038,0.529919,0.544639,0.559193,0.573576,0.587785,0.601815,0.615661,0.62932,0.642788,
0.656059,0.669131,0.681998,0.694658,0.707107,0.71934,0.731354,0.743145,0.75471,0.766044,
0.777146,0.788011,0.798636,0.809017,0.819152,0.829038,0.838671,0.848048,0.857167,0.866025,
0.87462,0.882948,0.891007,0.898794,0.906308,0.913545,0.920505,0.927184,0.93358,0.939693,
0.945519,0.951057,0.956305,0.961262,0.965926,0.970296,0.97437,0.978148,0.981627,0.984808,
0.987688,0.990268,0.992546,0.994522,0.996195,0.997564,0.99863,0.999391,0.999848};

===Creating a look-up table for the sine function using CONST===

*int8 = 8 bit number (1 byte); range 0 to 255 (2-3 digits)
*int16 = 16 bit number (2 bytes); range 0 to 65535 (4-5 digits)
*float = 32 bit number (4 bytes); range -1.5x10^45 to 3.4x10^38 (7-8 digits)

With values of sine from 0-89°, we can calculate sine values for all 360°. Below is code storing a table of sine values from 0-89° with a angle resolution of 1° and algorithm for calculating sine values for 90-360°.

const float sineTable[90] =
{0,0.017452,0.034899,0.052336,0.069756,0.087156,0.104528,0.121869,0.139173,0.156434,
0.173648,0.190809,0.207912,0.224951,0.241922,0.258819,0.275637,0.292372,0.309017,0.325568,
0.34202,0.358368,0.374607,0.390731,0.406737,0.422618,0.438371,0.45399,0.469472,0.48481,0.5,
0.515038,0.529919,0.544639,0.559193,0.573576,0.587785,0.601815,0.615661,0.62932,0.642788,
0.656059,0.669131,0.681998,0.694658,0.707107,0.71934,0.731354,0.743145,0.75471,0.766044,
0.777146,0.788011,0.798636,0.809017,0.819152,0.829038,0.838671,0.848048,0.857167,0.866025,
0.87462,0.882948,0.891007,0.898794,0.906308,0.913545,0.920505,0.927184,0.93358,0.939693,
0.945519,0.951057,0.956305,0.961262,0.965926,0.970296,0.97437,0.978148,0.981627,0.984808,
0.987688,0.990268,0.992546,0.994522,0.996195,0.997564,0.99863,0.999391,0.999848};

//To look up sine values from the table, you could use a function like the following:
float sineLookup(index){
i = index % 360; //Is there a better way to implement this?
if (i >= 0 && i < 90)
return sineTable[i];
else if (i >= 90 && i < 180)
return sineTable[179-i];
else if (i >= 180 && i < 270)
return -sineTable[180-i];
else if (i >= 270 && i < 360)
return -sineTable[359-i];
end
}

===Memory Management===

This table stores values as floats and is 360 bytes in size. Since the PIC has 32 KB of program memory, we could theoretically hold a sine lookup table precise to 0.01125° (32000/360 = 88.8x larger size; 1°/88.8 = 0.01125°).

const int8 sineTable[90] = ...

Because int8 cannot hold decimal values, and can only have up to 256 different values, a table made with int8 values might be difficult.
A more realistic version using int16 would be more useful, and could start off like this:

{0,175,349,523,697,872,1045,1219,1392,1564,1736,
1908,2079,2250,2419,2588,2756,2924,3090,3256...}

In your main program, you could insert a function that divides all these values by 10,000 to obtain the decimal value for the sine table.
In the previous example, a sine table would take up 180 bytes. We could theoretically hold a sine lookup table precise to 0.00562° (32000/180 = 177.8x larger size; 1°/177.8 = 0.00562°).

===Creating a sine look-up table using EEPROM===

Writing a sine table to EEPROM:

float data[4];
for (i = 0,i <= 90>>2, i++)
for (j = 0,j<4,j++)
data[j]=sineTable[i<<2 + j];
end
write_program_eeprom(i,data);
end

To read, use:

read_program_eeprom(address)

Storing constant data in program memory

2008-02-13T23:33:19Z

JonathanShih: /* Constant Data */

== Original Assignment ==

Your PIC has a relatively large amount of program memory (32 Kbytes) but relatively little data memory (1536 bytes). For some applications, we want to have lookup tables or calibration data stored on our PIC, but we don't want it hogging data memory. This project is to demonstrate how to write a program that stores constant data in program memory. Test your ability to do this by creating a look-up table for the sin function. This is a 1-d array with integer index corresponding to an angle (e.g., numbers 0 to 89 if the index is in degrees; angles in other quadrants can be determined by simple transformations). Depending on your choice of int8, int16, or float to represent the number, what angle resolution can you use for the index before you reach the limits of program memory?

See p. 43 of the PIC MCU C Compiler book.

Finally, give sample code for storing data in the EEPROM, too.

== Overview ==
The PIC has a relatively large amount of program memory (32 Kbytes) but relatively little data memory (1536 bytes). For some applications, we want to have lookup tables or calibration data stored on our PIC, but we don't want it hogging data memory. The CCS C Compiler provides a few different ways to use program memory for data, discussed below. We have also provided an example of how to create a look-up table for the sin function to illustrate one of these methods.

=== Constant Data ===
The CONST qualifier will place variables into program memory. If the keyword CONST is used before the identifier, the identifier is treated as a constant. These constants need to be initialized and cannot be changed at run-time.

The ROM qualifier puts data in program memory with 3 bytes per instruction space. The address used for ROM data is a true byte address not a physical address. The & operator can be used on ROM variables even though the address is logical not physical.

The syntax is: const type id[cexpr] = {value}

You must initialize the constant variable when you declare it or the compiler will spit out an error at you. Which means, unfortunately, you can't do something like:

const int listOfNumbers[100];
for (i = 0; i < 100; i++)
listOfNumbers[i] = i;
end

What you may be able to do, though, is this:
int temp[100];
for (i = 0; i < 100; i++)
temp[i] = i;
end
const int listOfNumbers[100] = temp;

=== #ROM Directive ===
Another method that can be used to assign data to program memory is the #ROM directive.

The syntax is: #rom address = {data, data, ... , data}

The following example places the numbers 1, 3, 5, 7, 9 into ROM addresses starting at 0x2000:

#rom 0x2000 = {1, 3, 5, 7, 9}

You can also put strings into program memory using the #ROM directive:

#rom 0x3000 = {"mechatronicsrocks"}

=== Built-in Functions ===
The compiler provides built in functions to place data in program memory.

write_program_eeprom(address,data);
* Writes data to program memory. data is stored in 16-bit chunks.

write_program_memory(address, dataptr, count);
* Writes count bytes of data from dataptr to address in program memory.
* Every fourth byte of data will not be written, this needs to be filled with 0x00.

== Code ==

===#ROM Directive Examples===
Writes sine values to ROM addresses starting at 0x1000
#rom 0x1000 = {0,0.017452,0.034899,0.052336,0.069756,0.087156,0.104528,0.121869,0.139173,0.156434,
0.173648,0.190809,0.207912,0.224951,0.241922,0.258819,0.275637,0.292372,0.309017,0.325568,
0.34202,0.358368,0.374607,0.390731,0.406737,0.422618,0.438371,0.45399,0.469472,0.48481,0.5,
0.515038,0.529919,0.544639,0.559193,0.573576,0.587785,0.601815,0.615661,0.62932,0.642788,
0.656059,0.669131,0.681998,0.694658,0.707107,0.71934,0.731354,0.743145,0.75471,0.766044,
0.777146,0.788011,0.798636,0.809017,0.819152,0.829038,0.838671,0.848048,0.857167,0.866025,
0.87462,0.882948,0.891007,0.898794,0.906308,0.913545,0.920505,0.927184,0.93358,0.939693,
0.945519,0.951057,0.956305,0.961262,0.965926,0.970296,0.97437,0.978148,0.981627,0.984808,
0.987688,0.990268,0.992546,0.994522,0.996195,0.997564,0.99863,0.999391,0.999848};

===Creating a look-up table for the sine function using CONST===

*int8 = 8 bit number (1 byte); range 0 to 255 (2-3 digits)
*int16 = 16 bit number (2 bytes); range 0 to 65535 (4-5 digits)
*float = 32 bit number (4 bytes); range -1.5x10^45 to 3.4x10^38 (7-8 digits)

With values of sine from 0-89°, we can calculate sine values for all 360°. Below is code storing a table of sine values from 0-89° with a angle resolution of 1° and algorithm for calculating sine values for 90-360°.

const float sineTable[90] =
{0,0.017452,0.034899,0.052336,0.069756,0.087156,0.104528,0.121869,0.139173,0.156434,
0.173648,0.190809,0.207912,0.224951,0.241922,0.258819,0.275637,0.292372,0.309017,0.325568,
0.34202,0.358368,0.374607,0.390731,0.406737,0.422618,0.438371,0.45399,0.469472,0.48481,0.5,
0.515038,0.529919,0.544639,0.559193,0.573576,0.587785,0.601815,0.615661,0.62932,0.642788,
0.656059,0.669131,0.681998,0.694658,0.707107,0.71934,0.731354,0.743145,0.75471,0.766044,
0.777146,0.788011,0.798636,0.809017,0.819152,0.829038,0.838671,0.848048,0.857167,0.866025,
0.87462,0.882948,0.891007,0.898794,0.906308,0.913545,0.920505,0.927184,0.93358,0.939693,
0.945519,0.951057,0.956305,0.961262,0.965926,0.970296,0.97437,0.978148,0.981627,0.984808,
0.987688,0.990268,0.992546,0.994522,0.996195,0.997564,0.99863,0.999391,0.999848};

//To look up sine values from the table, you could use a function like the following:
float sineLookup(index){
i = index % 360; //Is there a better way to implement this?
if (i >= 0 && i < 90)
return sineTable[i];
else if (i >= 90 && i < 180)
return sineTable[179-i];
else if (i >= 180 && i < 270)
return -sineTable[180-i];
else if (i >= 270 && i < 360)
return -sineTable[359-i];
end
}

===Memory Management===

This table stores values as floats and is 360 bytes in size. Since the PIC has 32 KB of program memory, we could theoretically hold a sine lookup table precise to 0.01125° (32000/360 = 88.8x larger size; 1°/88.8 = 0.01125°).

const int8 sineTable[90] = ...

Because int8 cannot hold decimal values, and can only have up to 256 different values, a table made with int8 values might be difficult.
A more realistic version using int16 would be more useful, and could start off like this:

{0,175,349,523,697,872,1045,1219,1392,1564,1736,
1908,2079,2250,2419,2588,2756,2924,3090,3256...}

In your main program, you could insert a function that divides all these values by 10,000 to obtain the decimal value for the sine table.
In the previous example, a sine table would take up 180 bytes. We could theoretically hold a sine lookup table precise to 0.00562° (32000/180 = 177.8x larger size; 1°/177.8 = 0.00562°).

===Creating a sine look-up table using EEPROM===

Writing a sine table to EEPROM:

float data[4];
for (i = 0,i <= 90>>2, i++)
for (j = 0,j<4,j++)
data[j]=sineTable[i<<2 + j];
end
write_program_eeprom(i,data);
end

To read, use:

read_program_eeprom(address)

Storing constant data in program memory

2008-02-13T23:29:55Z

JonathanShih: /* Circuit */

== Original Assignment ==

Your PIC has a relatively large amount of program memory (32 Kbytes) but relatively little data memory (1536 bytes). For some applications, we want to have lookup tables or calibration data stored on our PIC, but we don't want it hogging data memory. This project is to demonstrate how to write a program that stores constant data in program memory. Test your ability to do this by creating a look-up table for the sin function. This is a 1-d array with integer index corresponding to an angle (e.g., numbers 0 to 89 if the index is in degrees; angles in other quadrants can be determined by simple transformations). Depending on your choice of int8, int16, or float to represent the number, what angle resolution can you use for the index before you reach the limits of program memory?

See p. 43 of the PIC MCU C Compiler book.

Finally, give sample code for storing data in the EEPROM, too.

== Overview ==
The PIC has a relatively large amount of program memory (32 Kbytes) but relatively little data memory (1536 bytes). For some applications, we want to have lookup tables or calibration data stored on our PIC, but we don't want it hogging data memory. The CCS C Compiler provides a few different ways to use program memory for data, discussed below. We have also provided an example of how to create a look-up table for the sin function to illustrate one of these methods.

=== Constant Data ===
The CONST qualifier will place variables into program memory. If the keyword CONST is used before the identifier, the identifier is treated as a constant. These constants need to be initialized and cannot be changed at run-time.

The ROM qualifier puts data in program memory with 3 bytes per instruction space. The address used for ROM data is a true byte address not a physical address. The & operator can be used on ROM variables even though the address is logical not physical.

The syntax is: const type id[cexpr] = {value}

You must initialize the constant variable when you declare it or the compiler will spit out an error at you. Which means, unfortunately, you can't do something like:

const int listOfNumbers[100];
for (i = 0; i < 100; i++)
listOfNumbers[i] = i;
end

=== #ROM Directive ===
Another method that can be used to assign data to program memory is the #ROM directive.

The syntax is: #rom address = {data, data, ... , data}

The following example places the numbers 1, 3, 5, 7, 9 into ROM addresses starting at 0x2000:

#rom 0x2000 = {1, 3, 5, 7, 9}

You can also put strings into program memory using the #ROM directive:

#rom 0x3000 = {"mechatronicsrocks"}

=== Built-in Functions ===
The compiler provides built in functions to place data in program memory.

write_program_eeprom(address,data);
* Writes data to program memory. data is stored in 16-bit chunks.

write_program_memory(address, dataptr, count);
* Writes count bytes of data from dataptr to address in program memory.
* Every fourth byte of data will not be written, this needs to be filled with 0x00.

== Code ==

===#ROM Directive Examples===
Writes sine values to ROM addresses starting at 0x1000
#rom 0x1000 = {0,0.017452,0.034899,0.052336,0.069756,0.087156,0.104528,0.121869,0.139173,0.156434,
0.173648,0.190809,0.207912,0.224951,0.241922,0.258819,0.275637,0.292372,0.309017,0.325568,
0.34202,0.358368,0.374607,0.390731,0.406737,0.422618,0.438371,0.45399,0.469472,0.48481,0.5,
0.515038,0.529919,0.544639,0.559193,0.573576,0.587785,0.601815,0.615661,0.62932,0.642788,
0.656059,0.669131,0.681998,0.694658,0.707107,0.71934,0.731354,0.743145,0.75471,0.766044,
0.777146,0.788011,0.798636,0.809017,0.819152,0.829038,0.838671,0.848048,0.857167,0.866025,
0.87462,0.882948,0.891007,0.898794,0.906308,0.913545,0.920505,0.927184,0.93358,0.939693,
0.945519,0.951057,0.956305,0.961262,0.965926,0.970296,0.97437,0.978148,0.981627,0.984808,
0.987688,0.990268,0.992546,0.994522,0.996195,0.997564,0.99863,0.999391,0.999848};

===Creating a look-up table for the sine function using CONST===

*int8 = 8 bit number (1 byte); range 0 to 255 (2-3 digits)
*int16 = 16 bit number (2 bytes); range 0 to 65535 (4-5 digits)
*float = 32 bit number (4 bytes); range -1.5x10^45 to 3.4x10^38 (7-8 digits)

With values of sine from 0-89°, we can calculate sine values for all 360°. Below is code storing a table of sine values from 0-89° with a angle resolution of 1° and algorithm for calculating sine values for 90-360°.

const float sineTable[90] =
{0,0.017452,0.034899,0.052336,0.069756,0.087156,0.104528,0.121869,0.139173,0.156434,
0.173648,0.190809,0.207912,0.224951,0.241922,0.258819,0.275637,0.292372,0.309017,0.325568,
0.34202,0.358368,0.374607,0.390731,0.406737,0.422618,0.438371,0.45399,0.469472,0.48481,0.5,
0.515038,0.529919,0.544639,0.559193,0.573576,0.587785,0.601815,0.615661,0.62932,0.642788,
0.656059,0.669131,0.681998,0.694658,0.707107,0.71934,0.731354,0.743145,0.75471,0.766044,
0.777146,0.788011,0.798636,0.809017,0.819152,0.829038,0.838671,0.848048,0.857167,0.866025,
0.87462,0.882948,0.891007,0.898794,0.906308,0.913545,0.920505,0.927184,0.93358,0.939693,
0.945519,0.951057,0.956305,0.961262,0.965926,0.970296,0.97437,0.978148,0.981627,0.984808,
0.987688,0.990268,0.992546,0.994522,0.996195,0.997564,0.99863,0.999391,0.999848};

//To look up sine values from the table, you could use a function like the following:
float sineLookup(index){
i = index % 360; //Is there a better way to implement this?
if (i >= 0 && i < 90)
return sineTable[i];
else if (i >= 90 && i < 180)
return sineTable[179-i];
else if (i >= 180 && i < 270)
return -sineTable[180-i];
else if (i >= 270 && i < 360)
return -sineTable[359-i];
end
}

===Memory Management===

This table stores values as floats and is 360 bytes in size. Since the PIC has 32 KB of program memory, we could theoretically hold a sine lookup table precise to 0.01125° (32000/360 = 88.8x larger size; 1°/88.8 = 0.01125°).

const int8 sineTable[90] = ...

Because int8 cannot hold decimal values, and can only have up to 256 different values, a table made with int8 values might be difficult.
A more realistic version using int16 would be more useful, and could start off like this:

{0,175,349,523,697,872,1045,1219,1392,1564,1736,
1908,2079,2250,2419,2588,2756,2924,3090,3256...}

In your main program, you could insert a function that divides all these values by 10,000 to obtain the decimal value for the sine table.
In the previous example, a sine table would take up 180 bytes. We could theoretically hold a sine lookup table precise to 0.00562° (32000/180 = 177.8x larger size; 1°/177.8 = 0.00562°).

===Creating a sine look-up table using EEPROM===

Writing a sine table to EEPROM:

float data[4];
for (i = 0,i <= 90>>2, i++)
for (j = 0,j<4,j++)
data[j]=sineTable[i<<2 + j];
end
write_program_eeprom(i,data);
end

To read, use:

read_program_eeprom(address)

Storing constant data in program memory

2008-02-11T10:57:40Z

JonathanShih: /* Constant Data */

== Original Assignment ==

Your PIC has a relatively large amount of program memory (32 Kbytes) but relatively little data memory (1536 bytes). For some applications, we want to have lookup tables or calibration data stored on our PIC, but we don't want it hogging data memory. This project is to demonstrate how to write a program that stores constant data in program memory. Test your ability to do this by creating a look-up table for the sin function. This is a 1-d array with integer index corresponding to an angle (e.g., numbers 0 to 89 if the index is in degrees; angles in other quadrants can be determined by simple transformations). Depending on your choice of int8, int16, or float to represent the number, what angle resolution can you use for the index before you reach the limits of program memory?

See p. 43 of the PIC MCU C Compiler book.

Finally, give sample code for storing data in the EEPROM, too.

== Overview ==
The PIC has a relatively large amount of program memory (32 Kbytes) but relatively little data memory (1536 bytes). For some applications, we want to have lookup tables or calibration data stored on our PIC, but we don't want it hogging data memory. The CCS C Compiler provides a few different ways to use program memory for data, discussed below. We have also provided an example of how to create a look-up table for the sin function to illustrate one of these methods.

=== Constant Data ===
The CONST qualifier will place variables into program memory. If the keyword CONST is used before the identifier, the identifier is treated as a constant. These constants need to be initialized and cannot be changed at run-time.

The ROM qualifier puts data in program memory with 3 bytes per instruction space. The address used for ROM data is a true byte address not a physical address. The & operator can be used on ROM variables even though the address is logical not physical.

The syntax is: const type id[cexpr] = {value}

You must initialize the constant variable when you declare it or the compiler will spit out an error at you. Which means, unfortunately, you can't do something like:

const int listOfNumbers[100];
for (i = 0; i < 100; i++)
listOfNumbers[i] = i;
end

=== #ROM Directive ===
Another method that can be used to assign data to program memory is the #ROM directive.

The syntax is: #rom address = {data, data, ... , data}

The following example places the numbers 1, 3, 5, 7, 9 into ROM addresses starting at 0x2000:

#rom 0x2000 = {1, 3, 5, 7, 9}

You can also put strings into program memory using the #ROM directive:

#rom 0x3000 = {"mechatronicsrocks"}

=== Built-in Functions ===
The compiler provides built in functions to place data in program memory.

write_program_eeprom(address,data);
* Writes data to program memory. data is stored in 16-bit chunks.

write_program_memory(address, dataptr, count);
* Writes count bytes of data from dataptr to address in program memory.
* Every fourth byte of data will not be written, this needs to be filled with 0x00.

== Circuit ==

We have no circuit.

== Code ==

===#ROM Directive Examples===
Writes sine values to ROM addresses starting at 0x1000
#rom 0x1000 = {0,0.017452,0.034899,0.052336,0.069756,0.087156,0.104528,0.121869,0.139173,0.156434,
0.173648,0.190809,0.207912,0.224951,0.241922,0.258819,0.275637,0.292372,0.309017,0.325568,
0.34202,0.358368,0.374607,0.390731,0.406737,0.422618,0.438371,0.45399,0.469472,0.48481,0.5,
0.515038,0.529919,0.544639,0.559193,0.573576,0.587785,0.601815,0.615661,0.62932,0.642788,
0.656059,0.669131,0.681998,0.694658,0.707107,0.71934,0.731354,0.743145,0.75471,0.766044,
0.777146,0.788011,0.798636,0.809017,0.819152,0.829038,0.838671,0.848048,0.857167,0.866025,
0.87462,0.882948,0.891007,0.898794,0.906308,0.913545,0.920505,0.927184,0.93358,0.939693,
0.945519,0.951057,0.956305,0.961262,0.965926,0.970296,0.97437,0.978148,0.981627,0.984808,
0.987688,0.990268,0.992546,0.994522,0.996195,0.997564,0.99863,0.999391,0.999848};

===Creating a look-up table for the sine function using CONST===

*int8 = 8 bit number (1 byte); range 0 to 255 (2-3 digits)
*int16 = 16 bit number (2 bytes); range 0 to 65535 (4-5 digits)
*float = 32 bit number (4 bytes); range -1.5x10^45 to 3.4x10^38 (7-8 digits)

With values of sine from 0-89°, we can calculate sine values for all 360°. Below is code storing a table of sine values from 0-89° with a angle resolution of 1° and algorithm for calculating sine values for 90-360°.

const float sineTable[90] =
{0,0.017452,0.034899,0.052336,0.069756,0.087156,0.104528,0.121869,0.139173,0.156434,
0.173648,0.190809,0.207912,0.224951,0.241922,0.258819,0.275637,0.292372,0.309017,0.325568,
0.34202,0.358368,0.374607,0.390731,0.406737,0.422618,0.438371,0.45399,0.469472,0.48481,0.5,
0.515038,0.529919,0.544639,0.559193,0.573576,0.587785,0.601815,0.615661,0.62932,0.642788,
0.656059,0.669131,0.681998,0.694658,0.707107,0.71934,0.731354,0.743145,0.75471,0.766044,
0.777146,0.788011,0.798636,0.809017,0.819152,0.829038,0.838671,0.848048,0.857167,0.866025,
0.87462,0.882948,0.891007,0.898794,0.906308,0.913545,0.920505,0.927184,0.93358,0.939693,
0.945519,0.951057,0.956305,0.961262,0.965926,0.970296,0.97437,0.978148,0.981627,0.984808,
0.987688,0.990268,0.992546,0.994522,0.996195,0.997564,0.99863,0.999391,0.999848};

//To look up sine values from the table, you could use a function like the following:
float sineLookup(index){
i = index % 360; //Is there a better way to implement this?
if (i >= 0 && i < 90)
return sineTable[i];
else if (i >= 90 && i < 180)
return sineTable[179-i];
else if (i >= 180 && i < 270)
return -sineTable[180-i];
else if (i >= 270 && i < 360)
return -sineTable[359-i];
end
}

===Memory Management===

This table stores values as floats and is 360 bytes in size. Since the PIC has 32 KB of program memory, we could theoretically hold a sine lookup table precise to 0.01125° (32000/360 = 88.8x larger size; 1°/88.8 = 0.01125°).

const int8 sineTable[90] = ...

Because int8 cannot hold decimal values, and can only have up to 256 different values, a table made with int8 values might be difficult.
A more realistic version using int16 would be more useful, and could start off like this:

{0,175,349,523,697,872,1045,1219,1392,1564,1736,
1908,2079,2250,2419,2588,2756,2924,3090,3256...}

In your main program, you could insert a function that divides all these values by 10,000 to obtain the decimal value for the sine table.
In the previous example, a sine table would take up 180 bytes. We could theoretically hold a sine lookup table precise to 0.00562° (32000/180 = 177.8x larger size; 1°/177.8 = 0.00562°).

===Creating a sine look-up table using EEPROM===

Writing a sine table to EEPROM:

float data[4];
for (i = 0,i <= 90>>2, i++)
for (j = 0,j<4,j++)
data[j]=sineTable[i<<2 + j];
end
write_program_eeprom(i,data);
end

To read, use:

read_program_eeprom(address)

Storing constant data in program memory

2008-02-07T18:12:41Z

JonathanShih: /* Creating a sine look-up table using EEPROM */

== Original Assignment ==

Your PIC has a relatively large amount of program memory (32 Kbytes) but relatively little data memory (1536 bytes). For some applications, we want to have lookup tables or calibration data stored on our PIC, but we don't want it hogging data memory. This project is to demonstrate how to write a program that stores constant data in program memory. Test your ability to do this by creating a look-up table for the sin function. This is a 1-d array with integer index corresponding to an angle (e.g., numbers 0 to 89 if the index is in degrees; angles in other quadrants can be determined by simple transformations). Depending on your choice of int8, int16, or float to represent the number, what angle resolution can you use for the index before you reach the limits of program memory?

See p. 43 of the PIC MCU C Compiler book.

Finally, give sample code for storing data in the EEPROM, too.

== Overview ==
The PIC has a relatively large amount of program memory (32 Kbytes) but relatively little data memory (1536 bytes). For some applications, we want to have lookup tables or calibration data stored on our PIC, but we don't want it hogging data memory. The CCS C Compiler provides a few different ways to use program memory for data, discussed below. We have also provided an example of how to create a look-up table for the sin function to illustrate one of these methods.

=== Constant Data ===
The CONST qualifier will place variables into program memory. If the keyword CONST is used before the identifier, the identifier is treated as a constant. These constants need to be initialized and cannot be changed at run-time.

The ROM qualifier puts data in program memory with 3 bytes per instruction space. The address used for ROM data is a true byte address not a physical address. The & operator can be used on ROM variables even though the address is logical not physical.

The syntax is: const type id[cexpr] = {value}

You must initialize the constant variable when you declare it or the compiler will spit out an error at you. Which means, unfortunately, you can't do something like:

for (i = 0; i < 100; i++)
const float listOfNumbers[i] = i;
end

=== #ROM Directive ===
Another method that can be used to assign data to program memory is the #ROM directive.

The syntax is: #rom address = {data, data, ... , data}

The following example places the numbers 1, 3, 5, 7, 9 into ROM addresses starting at 0x2000:

#rom 0x2000 = {1, 3, 5, 7, 9}

You can also put strings into program memory using the #ROM directive:

#rom 0x3000 = {"mechatronicsrocks"}

=== Built-in Functions ===
The compiler provides built in functions to place data in program memory.

write_program_eeprom(address,data);
* Writes data to program memory. data is stored in 16-bit chunks.

write_program_memory(address, dataptr, count);
* Writes count bytes of data from dataptr to address in program memory.
* Every fourth byte of data will not be written, this needs to be filled with 0x00.

== Circuit ==

We have no circuit.

== Code ==

===#ROM Directive Examples===
Writes sine values to ROM addresses starting at 0x1000
#rom 0x1000 = {0,0.017452,0.034899,0.052336,0.069756,0.087156,0.104528,0.121869,0.139173,0.156434,
0.173648,0.190809,0.207912,0.224951,0.241922,0.258819,0.275637,0.292372,0.309017,0.325568,
0.34202,0.358368,0.374607,0.390731,0.406737,0.422618,0.438371,0.45399,0.469472,0.48481,0.5,
0.515038,0.529919,0.544639,0.559193,0.573576,0.587785,0.601815,0.615661,0.62932,0.642788,
0.656059,0.669131,0.681998,0.694658,0.707107,0.71934,0.731354,0.743145,0.75471,0.766044,
0.777146,0.788011,0.798636,0.809017,0.819152,0.829038,0.838671,0.848048,0.857167,0.866025,
0.87462,0.882948,0.891007,0.898794,0.906308,0.913545,0.920505,0.927184,0.93358,0.939693,
0.945519,0.951057,0.956305,0.961262,0.965926,0.970296,0.97437,0.978148,0.981627,0.984808,
0.987688,0.990268,0.992546,0.994522,0.996195,0.997564,0.99863,0.999391,0.999848};

===Creating a look-up table for the sine function using CONST===

*int8 = 8 bit number (1 byte); range 0 to 255 (2-3 digits)
*int16 = 16 bit number (2 bytes); range 0 to 65535 (4-5 digits)
*float = 32 bit number (4 bytes); range -1.5x10^45 to 3.4x10^38 (7-8 digits)

With values of sine from 0-89°, we can calculate sine values for all 360°. Below is code storing a table of sine values from 0-89° with a angle resolution of 1° and algorithm for calculating sine values for 90-360°.

const float sineTable[90] =
{0,0.017452,0.034899,0.052336,0.069756,0.087156,0.104528,0.121869,0.139173,0.156434,
0.173648,0.190809,0.207912,0.224951,0.241922,0.258819,0.275637,0.292372,0.309017,0.325568,
0.34202,0.358368,0.374607,0.390731,0.406737,0.422618,0.438371,0.45399,0.469472,0.48481,0.5,
0.515038,0.529919,0.544639,0.559193,0.573576,0.587785,0.601815,0.615661,0.62932,0.642788,
0.656059,0.669131,0.681998,0.694658,0.707107,0.71934,0.731354,0.743145,0.75471,0.766044,
0.777146,0.788011,0.798636,0.809017,0.819152,0.829038,0.838671,0.848048,0.857167,0.866025,
0.87462,0.882948,0.891007,0.898794,0.906308,0.913545,0.920505,0.927184,0.93358,0.939693,
0.945519,0.951057,0.956305,0.961262,0.965926,0.970296,0.97437,0.978148,0.981627,0.984808,
0.987688,0.990268,0.992546,0.994522,0.996195,0.997564,0.99863,0.999391,0.999848};

//To look up sine values from the table, you could use a function like the following:
float sineLookup(index){
i = index % 360; //Is there a better way to implement this?
if (i >= 0 && i < 90)
return sineTable[i];
else if (i >= 90 && i < 180)
return sineTable[179-i];
else if (i >= 180 && i < 270)
return -sineTable[180-i];
else if (i >= 270 && i < 360)
return -sineTable[359-i];
end
}

===Memory Management===

This table stores values as floats and is 360 bytes in size. Since the PIC has 32 KB of program memory, we could theoretically hold a sine lookup table precise to 0.01125° (32000/360 = 88.8x larger size; 1°/88.8 = 0.01125°).

const int8 sineTable[90] = ...

Because int8 cannot hold decimal values, and can only have up to 256 different values, a table made with int8 values might be difficult.
A more realistic version using int16 would be more useful, and could start off like this:

{0,175,349,523,697,872,1045,1219,1392,1564,1736,
1908,2079,2250,2419,2588,2756,2924,3090,3256...}

In your main program, you could insert a function that divides all these values by 10,000 to obtain the decimal value for the sine table.
In the previous example, a sine table would take up 180 bytes. We could theoretically hold a sine lookup table precise to 0.00562° (32000/180 = 177.8x larger size; 1°/177.8 = 0.00562°).

===Creating a sine look-up table using EEPROM===

Writing a sine table to EEPROM:

float data[4];
for (i = 0,i <= 90>>2, i++)
for (j = 0,j<4,j++)
data[j]=sineTable[i<<2 + j];
end
write_program_eeprom(i,data);
end

To read, use:

read_program_eeprom(address)

Storing constant data in program memory

2008-02-06T18:10:03Z

JonathanShih: /* Creating a sine look-up table using EEPROM */

== Original Assignment ==

Your PIC has a relatively large amount of program memory (32 Kbytes) but relatively little data memory (1536 bytes). For some applications, we want to have lookup tables or calibration data stored on our PIC, but we don't want it hogging data memory. This project is to demonstrate how to write a program that stores constant data in program memory. Test your ability to do this by creating a look-up table for the sin function. This is a 1-d array with integer index corresponding to an angle (e.g., numbers 0 to 89 if the index is in degrees; angles in other quadrants can be determined by simple transformations). Depending on your choice of int8, int16, or float to represent the number, what angle resolution can you use for the index before you reach the limits of program memory?

See p. 43 of the PIC MCU C Compiler book.

Finally, give sample code for storing data in the EEPROM, too.

== Overview ==
The PIC has a relatively large amount of program memory (32 Kbytes) but relatively little data memory (1536 bytes). For some applications, we want to have lookup tables or calibration data stored on our PIC, but we don't want it hogging data memory. The CCS C Compiler provides a few different ways to use program memory for data, discussed below. We have also provided an example of how to create a look-up table for the sin function to illustrate one of these methods.

=== Constant Data ===
The CONST qualifier will place variables into program memory. If the keyword CONST is used before the identifier, the identifier is treated as a constant. These constants need to be initialized and cannot be changed at run-time.

The ROM qualifier puts data in program memory with 3 bytes per instruction space. The address used for ROM data is a true byte address not a physical address. The & operator can be used on ROM variables even though the address is logical not physical.

The syntax is: const type id[cexpr] = {value}

You must initialize the constant variable when you declare it or the compiler will spit out an error at you. Which means, unfortunately, you can't do something like:

for (i = 0; i < 100; i++)
const float listOfNumbers[i] = i;
end

=== #ROM Directive ===
Another method that can be used to assign data to program memory is the #ROM directive.

The syntax is: #rom address = {data, data, ... , data}

The following example places the numbers 1, 3, 5, 7, 9 into ROM addresses starting at 0x2000:

#rom 0x2000 = {1, 3, 5, 7, 9}

You can also put strings into program memory using the #ROM directive:

#rom 0x3000 = {"mechatronicsrocks"}

=== Built-in Functions ===
The compiler provides built in functions to place data in program memory.

write_program_eeprom(address,data);
* Writes data to program memory. data is stored in 16-bit chunks.

write_program_memory(address, dataptr, count);
* Writes count bytes of data from dataptr to address in program memory.
* Every fourth byte of data will not be written, this needs to be filled with 0x00.

== Circuit ==

We has no circuit.

== Code ==

===#ROM Directive Examples===
Writes sine values to ROM addresses starting at 0x1000
#rom 0x1000 = {0,0.017452,0.034899,0.052336,0.069756,0.087156,0.104528,0.121869,0.139173,0.156434,
0.173648,0.190809,0.207912,0.224951,0.241922,0.258819,0.275637,0.292372,0.309017,0.325568,
0.34202,0.358368,0.374607,0.390731,0.406737,0.422618,0.438371,0.45399,0.469472,0.48481,0.5,
0.515038,0.529919,0.544639,0.559193,0.573576,0.587785,0.601815,0.615661,0.62932,0.642788,
0.656059,0.669131,0.681998,0.694658,0.707107,0.71934,0.731354,0.743145,0.75471,0.766044,
0.777146,0.788011,0.798636,0.809017,0.819152,0.829038,0.838671,0.848048,0.857167,0.866025,
0.87462,0.882948,0.891007,0.898794,0.906308,0.913545,0.920505,0.927184,0.93358,0.939693,
0.945519,0.951057,0.956305,0.961262,0.965926,0.970296,0.97437,0.978148,0.981627,0.984808,
0.987688,0.990268,0.992546,0.994522,0.996195,0.997564,0.99863,0.999391,0.999848};

===Creating a look-up table for the sine function using CONST===

*int8 = 8 bit number (1 byte); range 0 to 255 (2-3 digits)
*int16 = 16 bit number (2 bytes); range 0 to 65535 (4-5 digits)
*float = 32 bit number (4 bytes); range -1.5x10^45 to 3.4x10^38 (7-8 digits)

With values of sine from 0-89°, we can calculate sine values for all 360°. Below is code storing a table of sine values from 0-89° with a angle resolution of 1° and algorithm for calculating sine values for 90-360°.

const float sineTable[90] =
{0,0.017452,0.034899,0.052336,0.069756,0.087156,0.104528,0.121869,0.139173,0.156434,
0.173648,0.190809,0.207912,0.224951,0.241922,0.258819,0.275637,0.292372,0.309017,0.325568,
0.34202,0.358368,0.374607,0.390731,0.406737,0.422618,0.438371,0.45399,0.469472,0.48481,0.5,
0.515038,0.529919,0.544639,0.559193,0.573576,0.587785,0.601815,0.615661,0.62932,0.642788,
0.656059,0.669131,0.681998,0.694658,0.707107,0.71934,0.731354,0.743145,0.75471,0.766044,
0.777146,0.788011,0.798636,0.809017,0.819152,0.829038,0.838671,0.848048,0.857167,0.866025,
0.87462,0.882948,0.891007,0.898794,0.906308,0.913545,0.920505,0.927184,0.93358,0.939693,
0.945519,0.951057,0.956305,0.961262,0.965926,0.970296,0.97437,0.978148,0.981627,0.984808,
0.987688,0.990268,0.992546,0.994522,0.996195,0.997564,0.99863,0.999391,0.999848};

//To look up sine values from the table, you could use a function like the following:
float sineLookup(index){
i = index % 360; //Is there a better way to implement this?
if (i >= 0 && i < 90)
return sineTable[i];
else if (i >= 90 && i < 180)
return sineTable[179-i];
else if (i >= 180 && i < 270)
return -sineTable[180-i];
else if (i >= 270 && i < 360)
return -sineTable[359-i];
end
}

===Memory Management===

This table stores values as floats and is 360 bytes in size. Since the PIC has 32 KB of program memory, we could theoretically hold a sine lookup table precise to 0.01125° (32000/360 = 88.8x larger size; 1°/88.8 = 0.01125°).

const int8 sineTable[90] = ...

A table made with int8 values would be able to hold

''insert table of data types and angle resolution possible''
int8, int16, float, double?

===Creating a sine look-up table using EEPROM===

for (i = 0,i < 90, i++)
data[4]=
write_program_eeprom(i>>2,

To read, use:

read_program_eeprom(address)