Mech - User contributions [en]

Intelligent Oscillation Controller

2008-03-20T14:26:13Z

SandeepPrabhu: /* Circuitry */

== Team Members ==
'''Scott Mcleod:''' ''Electrical Engineering Class of 2009''

'''Brett Pihl:''' ''Mechanical Engineering Class of 2008''

'''Sandeep Prabhu:''' ''Mechanical Engineering Class of 2008
''

== Overview ==

The overall goal of this project is to create a system that induces a forcing function upon a basic, spring, mass, wall system to achieve an arbitrary periodic acceleration profile (a combination of a 10 and 20 Hz sine wave for our system) on the mass. An accelerometer is mounted upon the mass in the system. A PIC microprocessor records this acceleration data as well as controls a speaker (with the help of a DAC) that provides the external force to the system. This PIC communicates with MATLAB via Serial RS-232 communication. MATLAB processes this data and sends back a control signal for the speaker. After several iterations the actual mass acceleration profile begins to match the chosen profile it is told to "learn."

== Mechanics ==

The basic mechanical system for this device is a simple one, but must be assembled with precision. The major components are the speaker, linear ball bearings on a precision rod, and a spring. First, the speaker is mounted perpendicular to the ground. This must then be attached via a rod to the mass. We tried several approaches, but what seemed to be the best solution was to epoxy about a one inch section of PVC pipe to the center of the speaker. The diameter of the pipe we used matched the diameter of the junction in the speaker where the cone turns from concave to convex. This pipe also had two tapped holes running along the length of the section for a plate to attach to. The plate attached to this PVC also had a threaded hole in the center for the rod that attaches to the mass. The forces exerted by the speaker are small enough (our measurements show only about 3 Newtons) that only about an 8 ounce mass is needed. The bearing we used didn't require any additional mass to satisfy this constraint. The other end of the rod simply attached to the block which we machined and mounted atop the bearing. A piece of sheet metal was screwed into the other side of the block with spacers. This piece of metal is used to anchor spring to the mass, and allows the spring to easily be removed. A similar piece of sheet metal is attached to the wall on the opposite side of the spring. However, this sheet has a vertical slot about an eighth of an inch wide cut from the bottom. This allows the coil of the spring to slide up further on the plate, thereby creating a more solid connection.

It is important to design each component with all other components in mind at the same time. Mainly, making sure that the linear slide is level, and the rod attached to the speaker is centered, level, and in line with the mount on the mass and spring on the opposite side of the mass. This will help to ensure that all motion in the system is one dimensional.

The above was not the first iteration of our mechanical design. We originally had a homemade linear slide. However, we found the lack of precision resulted in unreliable bode plots of the system due to loose tolerances of the design creating side-to-side motion. The first iteration also had the rod epoxied directly to the mass and speaker. During initial testing the connection between the speaker and rod actually severed.

This current design is advantageous because it is modular. The threaded rod allows for minor distance changes to ensure the spring attached to the wall is at its natural rest length. To attach it the plate is detached from the PVC on the speaker and screwed onto the rod. With the spring detached, the other end of the rod is screwed into the threaded hole on the mass. Finally, the plate is then screwed into the PVC through the threaded holes. The non-permanent spring attachment also allows for springs with different k-values to be added to the system. If the spring is longer or shorter then desired, a simple change in rod length is all that is needed to incorporate the new spring into the system.

== Circuitry ==

[[Image:LearningOscMC |thumb|150px|right| Main Circuit]]

[[Image:LearningOscAM |thumb|150px|right| Accelerometer on mass]]

The main elements of the circuit were a PIC, DAC ([[http://hades.mech.northwestern.edu/wiki/index.php/PIC18F4520:_Serial_Digital-to-Analog_Conversion Digital-to-Analog converter]]) and accelerometer. The PIC would store a discretized sine waveform with integer values from 0-255. It would then output a function of this sine wave (our control signal) to the DAC. The analog signal output from the DAC would be sent to the amplifier, which would then power the speaker. The accelerometer on the mass would feedback the actual acceleration profile of the mass back to Matlab. Matlab would then recompute the next control signal and repeat the cycle until the mass was moving with the desired acceleration profile.

== Programming ==
=== PIC Code ===
In our project, a PIC was used to drive the speaker via its I2C digital-to-analog converter and record accelerometer values at fixed intervals. Since the control system’s algorithm requires too much processing for the PIC, all the computations are performed in Matlab after the accelerometer data is transported to a computer via a serial cable. This setup simplified the program for the PIC.

To generate the waveform of voltage levels sent to the speaker, a single quantized period was used. Since the waveform is periodic in nature, the wave can be repeated indefinitely in a continuous fashion. The nature of our processing algorithm constrained the number of samples for the accelerometer data to be equal to the number of samples for the control voltage.

Since our system used a waveform of fixed intervals, we used an interrupt service routine (ISR) to change the wave and record accelerations at precise intervals. We chose to sample each signal every 1ms (as this is an achievable I2C speed and ISR). To oscillate our system at 10 and 20Hz, we needed at least 100 samples per waveform (1/10Hz / 1ms = 100 samples/waveform). For this reason, we created two 100-byte long vectors for the control voltage ‘u’, and the acceleration data ‘acc’.

[[Media:ME333_Learning_Oscillator_pic_main.c|'''PIC Learning Control''']]
[[Media:ME333_Learning_Oscillator_pic_bode.c|'''PIC Bode Plot Generator''']]

=== Matlab Code ===
The Matlab code simply follows the protocol as established above. The user specifies in Matlab the parameters for the amplitude and phase of the desired acceleration waveform. *Note that the frequencies of these waves are set to 10 and 20Hz (as constrained by the transfer functions captured from the Bode and the periodic nature of 100 samples/wave).

Below are the 4 m files used in Matlab. Their names must be changed to the last part of their filenames as they are functions.

[[Media:ME333_Learning_Oscillator_main.m|'''Main Matlab Loop''']]
[[Media:ME333_Learning_Oscillator_learn.m|'''Learning Control Algorithm''']]
[[Media:ME333_Learning_Oscillator_smooth.m|'''Smoothing Algorithm''']]
[[Media:ME333_Learning_Oscillator_startplot.m|'''Plot Initialization Code''']]
[[Media:ME333_Learning_Oscillator_bode.m|'''Bode Plot Generator''']]

=== Program Flow ===

[[Image:Oscillator_Program_Flow.jpg|center|thumb|400px|Program Flow]]

=== Control System ===
To “learn” the control voltages to create a desired waveform, a simple proportional control system was used. We should note much of this code was developed, tested and debugged by Tom Vose, who was invaluable to our final project. Below is our understanding of Tom’s control algorithm.

The system first guesses a control voltage of all zeros. This ideally results in no forcing of the speaker and a flat response of acceleration. After this initial guess, the program uses proportional control to match the desired acceleration waveform. Mathematically, it multiplies the error by a proportional factor k. The error is computed by subtracting the Fast Fourier Transform (fft) of the measured acceleration from the fft of the desired acceleration. This error is multiplied by the proportional control k, and two discrete Bode plot values corresponding to the transfer function of voltage to acceleration at 10 and 20Hz. The resulting signal is the control signal u, in the frequency domain. From here, the control signal is converted back to the time domain via an inverse fft, and sent to the PIC. All of the math is computed in discrete time, for the waveforms of 100 samples long. Below is a block diagram of this control system. Note that it is in the standard unity feedback form.

[[Image:Oscillator_Control_System.jpg|center|933x200 px|Learning Control System]]

== Results ==
Below are three tests performed on various superpositions of sin waves at 10 and 20Hz. We have adjusted the phase of the waves to produce different results.

<gallery Caption="Matlab Plots Acceleration Desired vs. Experimental Acceleration">
Image:Oscillator_test1.jpg|Wave 1
Image:Oscillator_test2.jpg|Wave 2
Image:Oscillator_test3.jpg|Wave 3
</gallery>

Each diagram, shows one period of an acceleration profile. The faint blue curve in the left subplot is the desired acceleration motion. The red lines on top of the blue curve are experimental accelerations as recorded by the pic. We can see that the red lines converge on top of the desired blue motion. The right subplot (green) shows the learned voltage waveform to create the desired acceleration profile.

Each wave follows the equation below with the given parameters:

acceleration_desired = amp1*sin(2*pi*base_freq*t+phi1) + amp2*sin(2*pi*(2*base_freq)*t+phi2)

Wave 1: phi1 = 1, phi2 = 2
Wave 2: phi1 = 0, phi2 = 0
Wave 3: phi1 = 1, phi2 = 0

== Potential Applications ==

A common question regarding this project is its applications to the real world. In the Northwestern University LIMS lab, a similar type of undertaking is being researched, but on a much grander scale. This same type of oscillation control is being done for 6 dimensions (X, Y, Z, Roll, Pitch, Yaw). However, the microprocessors used in this type of control are extremely expensive, and this one dimensional test of a learning system provides a possibly cheaper solution. The six dimensional control system has possible real-world applications in product assembly.

== Reflections ==
Great results were achieved from the learning algorithm. For engineers working on it in the future, here are some topics for further investigation to get a more complete understanding about the control system:

* In this project, the control signal was manually phase-shifted by pi radians before outputting it to the speaker
** This made the algorithm work perfectly
** It is not well-understood why this step was necessary
** The algorithm would not work otherwise

* In the input for the FFT, the transfer function used in this project did not have an imaginary component
** The robust algorithm still worked perfectly, and would shift phase and 'learn' when the program was run
** In future experiments, a transfer function including an imaginary term could be used, to fully utilize the capabilities of the algorithm

* Faster learning
** The various constants in the algorithm equations can be tweaked for faster learning
** Currently, it takes about 10-20 iterations to hit the desired waveform
** More rapid learning would be a huge benefit in real-world applications

== References ==
* [http://electronics.howstuffworks.com/speaker5.htm How speakers work]
* [[Iterative Learning Control]]
* [http://lims.mech.northwestern.edu/~lynch/ Professor Kevin Lynch]
* [http://lims.mech.northwestern.edu/students/vose/ Tom Vose], author of the learning algorithm used in this project

Intelligent Oscillation Controller

2008-03-20T14:25:37Z

SandeepPrabhu: /* Circuitry */

== Team Members ==
'''Scott Mcleod:''' ''Electrical Engineering Class of 2009''

'''Brett Pihl:''' ''Mechanical Engineering Class of 2008''

'''Sandeep Prabhu:''' ''Mechanical Engineering Class of 2008
''

== Overview ==

The overall goal of this project is to create a system that induces a forcing function upon a basic, spring, mass, wall system to achieve an arbitrary periodic acceleration profile (a combination of a 10 and 20 Hz sine wave for our system) on the mass. An accelerometer is mounted upon the mass in the system. A PIC microprocessor records this acceleration data as well as controls a speaker (with the help of a DAC) that provides the external force to the system. This PIC communicates with MATLAB via Serial RS-232 communication. MATLAB processes this data and sends back a control signal for the speaker. After several iterations the actual mass acceleration profile begins to match the chosen profile it is told to "learn."

== Mechanics ==

The basic mechanical system for this device is a simple one, but must be assembled with precision. The major components are the speaker, linear ball bearings on a precision rod, and a spring. First, the speaker is mounted perpendicular to the ground. This must then be attached via a rod to the mass. We tried several approaches, but what seemed to be the best solution was to epoxy about a one inch section of PVC pipe to the center of the speaker. The diameter of the pipe we used matched the diameter of the junction in the speaker where the cone turns from concave to convex. This pipe also had two tapped holes running along the length of the section for a plate to attach to. The plate attached to this PVC also had a threaded hole in the center for the rod that attaches to the mass. The forces exerted by the speaker are small enough (our measurements show only about 3 Newtons) that only about an 8 ounce mass is needed. The bearing we used didn't require any additional mass to satisfy this constraint. The other end of the rod simply attached to the block which we machined and mounted atop the bearing. A piece of sheet metal was screwed into the other side of the block with spacers. This piece of metal is used to anchor spring to the mass, and allows the spring to easily be removed. A similar piece of sheet metal is attached to the wall on the opposite side of the spring. However, this sheet has a vertical slot about an eighth of an inch wide cut from the bottom. This allows the coil of the spring to slide up further on the plate, thereby creating a more solid connection.

It is important to design each component with all other components in mind at the same time. Mainly, making sure that the linear slide is level, and the rod attached to the speaker is centered, level, and in line with the mount on the mass and spring on the opposite side of the mass. This will help to ensure that all motion in the system is one dimensional.

The above was not the first iteration of our mechanical design. We originally had a homemade linear slide. However, we found the lack of precision resulted in unreliable bode plots of the system due to loose tolerances of the design creating side-to-side motion. The first iteration also had the rod epoxied directly to the mass and speaker. During initial testing the connection between the speaker and rod actually severed.

This current design is advantageous because it is modular. The threaded rod allows for minor distance changes to ensure the spring attached to the wall is at its natural rest length. To attach it the plate is detached from the PVC on the speaker and screwed onto the rod. With the spring detached, the other end of the rod is screwed into the threaded hole on the mass. Finally, the plate is then screwed into the PVC through the threaded holes. The non-permanent spring attachment also allows for springs with different k-values to be added to the system. If the spring is longer or shorter then desired, a simple change in rod length is all that is needed to incorporate the new spring into the system.

== Circuitry ==

[[Image:LearningOscMC |thumb|300px|center| Main Circuit]]

[[Image:LearningOscAM |thumb|300px|right| Accelerometer on mass]]

The main elements of the circuit were a PIC, DAC ([[http://hades.mech.northwestern.edu/wiki/index.php/PIC18F4520:_Serial_Digital-to-Analog_Conversion Digital-to-Analog converter]]) and accelerometer. The PIC would store a discretized sine waveform with integer values from 0-255. It would then output a function of this sine wave (our control signal) to the DAC. The analog signal output from the DAC would be sent to the amplifier, which would then power the speaker. The accelerometer on the mass would feedback the actual acceleration profile of the mass back to Matlab. Matlab would then recompute the next control signal and repeat the cycle until the mass was moving with the desired acceleration profile.

== Programming ==
=== PIC Code ===
In our project, a PIC was used to drive the speaker via its I2C digital-to-analog converter and record accelerometer values at fixed intervals. Since the control system’s algorithm requires too much processing for the PIC, all the computations are performed in Matlab after the accelerometer data is transported to a computer via a serial cable. This setup simplified the program for the PIC.

To generate the waveform of voltage levels sent to the speaker, a single quantized period was used. Since the waveform is periodic in nature, the wave can be repeated indefinitely in a continuous fashion. The nature of our processing algorithm constrained the number of samples for the accelerometer data to be equal to the number of samples for the control voltage.

Since our system used a waveform of fixed intervals, we used an interrupt service routine (ISR) to change the wave and record accelerations at precise intervals. We chose to sample each signal every 1ms (as this is an achievable I2C speed and ISR). To oscillate our system at 10 and 20Hz, we needed at least 100 samples per waveform (1/10Hz / 1ms = 100 samples/waveform). For this reason, we created two 100-byte long vectors for the control voltage ‘u’, and the acceleration data ‘acc’.

[[Media:ME333_Learning_Oscillator_pic_main.c|'''PIC Learning Control''']]
[[Media:ME333_Learning_Oscillator_pic_bode.c|'''PIC Bode Plot Generator''']]

=== Matlab Code ===
The Matlab code simply follows the protocol as established above. The user specifies in Matlab the parameters for the amplitude and phase of the desired acceleration waveform. *Note that the frequencies of these waves are set to 10 and 20Hz (as constrained by the transfer functions captured from the Bode and the periodic nature of 100 samples/wave).

Below are the 4 m files used in Matlab. Their names must be changed to the last part of their filenames as they are functions.

[[Media:ME333_Learning_Oscillator_main.m|'''Main Matlab Loop''']]
[[Media:ME333_Learning_Oscillator_learn.m|'''Learning Control Algorithm''']]
[[Media:ME333_Learning_Oscillator_smooth.m|'''Smoothing Algorithm''']]
[[Media:ME333_Learning_Oscillator_startplot.m|'''Plot Initialization Code''']]
[[Media:ME333_Learning_Oscillator_bode.m|'''Bode Plot Generator''']]

=== Program Flow ===

[[Image:Oscillator_Program_Flow.jpg|center|thumb|400px|Program Flow]]

=== Control System ===
To “learn” the control voltages to create a desired waveform, a simple proportional control system was used. We should note much of this code was developed, tested and debugged by Tom Vose, who was invaluable to our final project. Below is our understanding of Tom’s control algorithm.

The system first guesses a control voltage of all zeros. This ideally results in no forcing of the speaker and a flat response of acceleration. After this initial guess, the program uses proportional control to match the desired acceleration waveform. Mathematically, it multiplies the error by a proportional factor k. The error is computed by subtracting the Fast Fourier Transform (fft) of the measured acceleration from the fft of the desired acceleration. This error is multiplied by the proportional control k, and two discrete Bode plot values corresponding to the transfer function of voltage to acceleration at 10 and 20Hz. The resulting signal is the control signal u, in the frequency domain. From here, the control signal is converted back to the time domain via an inverse fft, and sent to the PIC. All of the math is computed in discrete time, for the waveforms of 100 samples long. Below is a block diagram of this control system. Note that it is in the standard unity feedback form.

[[Image:Oscillator_Control_System.jpg|center|933x200 px|Learning Control System]]

== Results ==
Below are three tests performed on various superpositions of sin waves at 10 and 20Hz. We have adjusted the phase of the waves to produce different results.

<gallery Caption="Matlab Plots Acceleration Desired vs. Experimental Acceleration">
Image:Oscillator_test1.jpg|Wave 1
Image:Oscillator_test2.jpg|Wave 2
Image:Oscillator_test3.jpg|Wave 3
</gallery>

Each diagram, shows one period of an acceleration profile. The faint blue curve in the left subplot is the desired acceleration motion. The red lines on top of the blue curve are experimental accelerations as recorded by the pic. We can see that the red lines converge on top of the desired blue motion. The right subplot (green) shows the learned voltage waveform to create the desired acceleration profile.

Each wave follows the equation below with the given parameters:

acceleration_desired = amp1*sin(2*pi*base_freq*t+phi1) + amp2*sin(2*pi*(2*base_freq)*t+phi2)

Wave 1: phi1 = 1, phi2 = 2
Wave 2: phi1 = 0, phi2 = 0
Wave 3: phi1 = 1, phi2 = 0

== Potential Applications ==

A common question regarding this project is its applications to the real world. In the Northwestern University LIMS lab, a similar type of undertaking is being researched, but on a much grander scale. This same type of oscillation control is being done for 6 dimensions (X, Y, Z, Roll, Pitch, Yaw). However, the microprocessors used in this type of control are extremely expensive, and this one dimensional test of a learning system provides a possibly cheaper solution. The six dimensional control system has possible real-world applications in product assembly.

== Reflections ==
Great results were achieved from the learning algorithm. For engineers working on it in the future, here are some topics for further investigation to get a more complete understanding about the control system:

* In this project, the control signal was manually phase-shifted by pi radians before outputting it to the speaker
** This made the algorithm work perfectly
** It is not well-understood why this step was necessary
** The algorithm would not work otherwise

* In the input for the FFT, the transfer function used in this project did not have an imaginary component
** The robust algorithm still worked perfectly, and would shift phase and 'learn' when the program was run
** In future experiments, a transfer function including an imaginary term could be used, to fully utilize the capabilities of the algorithm

* Faster learning
** The various constants in the algorithm equations can be tweaked for faster learning
** Currently, it takes about 10-20 iterations to hit the desired waveform
** More rapid learning would be a huge benefit in real-world applications

== References ==
* [http://electronics.howstuffworks.com/speaker5.htm How speakers work]
* [[Iterative Learning Control]]
* [http://lims.mech.northwestern.edu/~lynch/ Professor Kevin Lynch]
* [http://lims.mech.northwestern.edu/students/vose/ Tom Vose], author of the learning algorithm used in this project

Intelligent Oscillation Controller

2008-03-20T14:25:19Z

SandeepPrabhu: /* Circuitry */

== Team Members ==
'''Scott Mcleod:''' ''Electrical Engineering Class of 2009''

'''Brett Pihl:''' ''Mechanical Engineering Class of 2008''

'''Sandeep Prabhu:''' ''Mechanical Engineering Class of 2008
''

== Overview ==

The overall goal of this project is to create a system that induces a forcing function upon a basic, spring, mass, wall system to achieve an arbitrary periodic acceleration profile (a combination of a 10 and 20 Hz sine wave for our system) on the mass. An accelerometer is mounted upon the mass in the system. A PIC microprocessor records this acceleration data as well as controls a speaker (with the help of a DAC) that provides the external force to the system. This PIC communicates with MATLAB via Serial RS-232 communication. MATLAB processes this data and sends back a control signal for the speaker. After several iterations the actual mass acceleration profile begins to match the chosen profile it is told to "learn."

== Mechanics ==

The basic mechanical system for this device is a simple one, but must be assembled with precision. The major components are the speaker, linear ball bearings on a precision rod, and a spring. First, the speaker is mounted perpendicular to the ground. This must then be attached via a rod to the mass. We tried several approaches, but what seemed to be the best solution was to epoxy about a one inch section of PVC pipe to the center of the speaker. The diameter of the pipe we used matched the diameter of the junction in the speaker where the cone turns from concave to convex. This pipe also had two tapped holes running along the length of the section for a plate to attach to. The plate attached to this PVC also had a threaded hole in the center for the rod that attaches to the mass. The forces exerted by the speaker are small enough (our measurements show only about 3 Newtons) that only about an 8 ounce mass is needed. The bearing we used didn't require any additional mass to satisfy this constraint. The other end of the rod simply attached to the block which we machined and mounted atop the bearing. A piece of sheet metal was screwed into the other side of the block with spacers. This piece of metal is used to anchor spring to the mass, and allows the spring to easily be removed. A similar piece of sheet metal is attached to the wall on the opposite side of the spring. However, this sheet has a vertical slot about an eighth of an inch wide cut from the bottom. This allows the coil of the spring to slide up further on the plate, thereby creating a more solid connection.

It is important to design each component with all other components in mind at the same time. Mainly, making sure that the linear slide is level, and the rod attached to the speaker is centered, level, and in line with the mount on the mass and spring on the opposite side of the mass. This will help to ensure that all motion in the system is one dimensional.

The above was not the first iteration of our mechanical design. We originally had a homemade linear slide. However, we found the lack of precision resulted in unreliable bode plots of the system due to loose tolerances of the design creating side-to-side motion. The first iteration also had the rod epoxied directly to the mass and speaker. During initial testing the connection between the speaker and rod actually severed.

This current design is advantageous because it is modular. The threaded rod allows for minor distance changes to ensure the spring attached to the wall is at its natural rest length. To attach it the plate is detached from the PVC on the speaker and screwed onto the rod. With the spring detached, the other end of the rod is screwed into the threaded hole on the mass. Finally, the plate is then screwed into the PVC through the threaded holes. The non-permanent spring attachment also allows for springs with different k-values to be added to the system. If the spring is longer or shorter then desired, a simple change in rod length is all that is needed to incorporate the new spring into the system.

== Circuitry ==

[[Image:LearningOscMC |thumb|300px|left| Main Circuit]]

[[Image:LearningOscAM |thumb|300px|right| Accelerometer on mass]]

The main elements of the circuit were a PIC, DAC ([[http://hades.mech.northwestern.edu/wiki/index.php/PIC18F4520:_Serial_Digital-to-Analog_Conversion Digital-to-Analog converter]]) and accelerometer. The PIC would store a discretized sine waveform with integer values from 0-255. It would then output a function of this sine wave (our control signal) to the DAC. The analog signal output from the DAC would be sent to the amplifier, which would then power the speaker. The accelerometer on the mass would feedback the actual acceleration profile of the mass back to Matlab. Matlab would then recompute the next control signal and repeat the cycle until the mass was moving with the desired acceleration profile.

== Programming ==
=== PIC Code ===
In our project, a PIC was used to drive the speaker via its I2C digital-to-analog converter and record accelerometer values at fixed intervals. Since the control system’s algorithm requires too much processing for the PIC, all the computations are performed in Matlab after the accelerometer data is transported to a computer via a serial cable. This setup simplified the program for the PIC.

To generate the waveform of voltage levels sent to the speaker, a single quantized period was used. Since the waveform is periodic in nature, the wave can be repeated indefinitely in a continuous fashion. The nature of our processing algorithm constrained the number of samples for the accelerometer data to be equal to the number of samples for the control voltage.

Since our system used a waveform of fixed intervals, we used an interrupt service routine (ISR) to change the wave and record accelerations at precise intervals. We chose to sample each signal every 1ms (as this is an achievable I2C speed and ISR). To oscillate our system at 10 and 20Hz, we needed at least 100 samples per waveform (1/10Hz / 1ms = 100 samples/waveform). For this reason, we created two 100-byte long vectors for the control voltage ‘u’, and the acceleration data ‘acc’.

[[Media:ME333_Learning_Oscillator_pic_main.c|'''PIC Learning Control''']]
[[Media:ME333_Learning_Oscillator_pic_bode.c|'''PIC Bode Plot Generator''']]

=== Matlab Code ===
The Matlab code simply follows the protocol as established above. The user specifies in Matlab the parameters for the amplitude and phase of the desired acceleration waveform. *Note that the frequencies of these waves are set to 10 and 20Hz (as constrained by the transfer functions captured from the Bode and the periodic nature of 100 samples/wave).

Below are the 4 m files used in Matlab. Their names must be changed to the last part of their filenames as they are functions.

[[Media:ME333_Learning_Oscillator_main.m|'''Main Matlab Loop''']]
[[Media:ME333_Learning_Oscillator_learn.m|'''Learning Control Algorithm''']]
[[Media:ME333_Learning_Oscillator_smooth.m|'''Smoothing Algorithm''']]
[[Media:ME333_Learning_Oscillator_startplot.m|'''Plot Initialization Code''']]
[[Media:ME333_Learning_Oscillator_bode.m|'''Bode Plot Generator''']]

=== Program Flow ===

[[Image:Oscillator_Program_Flow.jpg|center|thumb|400px|Program Flow]]

=== Control System ===
To “learn” the control voltages to create a desired waveform, a simple proportional control system was used. We should note much of this code was developed, tested and debugged by Tom Vose, who was invaluable to our final project. Below is our understanding of Tom’s control algorithm.

The system first guesses a control voltage of all zeros. This ideally results in no forcing of the speaker and a flat response of acceleration. After this initial guess, the program uses proportional control to match the desired acceleration waveform. Mathematically, it multiplies the error by a proportional factor k. The error is computed by subtracting the Fast Fourier Transform (fft) of the measured acceleration from the fft of the desired acceleration. This error is multiplied by the proportional control k, and two discrete Bode plot values corresponding to the transfer function of voltage to acceleration at 10 and 20Hz. The resulting signal is the control signal u, in the frequency domain. From here, the control signal is converted back to the time domain via an inverse fft, and sent to the PIC. All of the math is computed in discrete time, for the waveforms of 100 samples long. Below is a block diagram of this control system. Note that it is in the standard unity feedback form.

[[Image:Oscillator_Control_System.jpg|center|933x200 px|Learning Control System]]

== Results ==
Below are three tests performed on various superpositions of sin waves at 10 and 20Hz. We have adjusted the phase of the waves to produce different results.

<gallery Caption="Matlab Plots Acceleration Desired vs. Experimental Acceleration">
Image:Oscillator_test1.jpg|Wave 1
Image:Oscillator_test2.jpg|Wave 2
Image:Oscillator_test3.jpg|Wave 3
</gallery>

Each diagram, shows one period of an acceleration profile. The faint blue curve in the left subplot is the desired acceleration motion. The red lines on top of the blue curve are experimental accelerations as recorded by the pic. We can see that the red lines converge on top of the desired blue motion. The right subplot (green) shows the learned voltage waveform to create the desired acceleration profile.

Each wave follows the equation below with the given parameters:

acceleration_desired = amp1*sin(2*pi*base_freq*t+phi1) + amp2*sin(2*pi*(2*base_freq)*t+phi2)

Wave 1: phi1 = 1, phi2 = 2
Wave 2: phi1 = 0, phi2 = 0
Wave 3: phi1 = 1, phi2 = 0

== Potential Applications ==

A common question regarding this project is its applications to the real world. In the Northwestern University LIMS lab, a similar type of undertaking is being researched, but on a much grander scale. This same type of oscillation control is being done for 6 dimensions (X, Y, Z, Roll, Pitch, Yaw). However, the microprocessors used in this type of control are extremely expensive, and this one dimensional test of a learning system provides a possibly cheaper solution. The six dimensional control system has possible real-world applications in product assembly.

== Reflections ==
Great results were achieved from the learning algorithm. For engineers working on it in the future, here are some topics for further investigation to get a more complete understanding about the control system:

* In this project, the control signal was manually phase-shifted by pi radians before outputting it to the speaker
** This made the algorithm work perfectly
** It is not well-understood why this step was necessary
** The algorithm would not work otherwise

* In the input for the FFT, the transfer function used in this project did not have an imaginary component
** The robust algorithm still worked perfectly, and would shift phase and 'learn' when the program was run
** In future experiments, a transfer function including an imaginary term could be used, to fully utilize the capabilities of the algorithm

* Faster learning
** The various constants in the algorithm equations can be tweaked for faster learning
** Currently, it takes about 10-20 iterations to hit the desired waveform
** More rapid learning would be a huge benefit in real-world applications

== References ==
* [http://electronics.howstuffworks.com/speaker5.htm How speakers work]
* [[Iterative Learning Control]]
* [http://lims.mech.northwestern.edu/~lynch/ Professor Kevin Lynch]
* [http://lims.mech.northwestern.edu/students/vose/ Tom Vose], author of the learning algorithm used in this project

File:LearningOscAM

2008-03-20T14:24:26Z

SandeepPrabhu:

File:LearningOscAM.jpg

2008-03-20T14:23:51Z

SandeepPrabhu:

Intelligent Oscillation Controller

2008-03-20T14:23:31Z

SandeepPrabhu: /* Circuitry */

== Team Members ==
'''Scott Mcleod:''' ''Electrical Engineering Class of 2009''

'''Brett Pihl:''' ''Mechanical Engineering Class of 2008''

'''Sandeep Prabhu:''' ''Mechanical Engineering Class of 2008
''

== Overview ==

The overall goal of this project is to create a system that induces a forcing function upon a basic, spring, mass, wall system to achieve an arbitrary periodic acceleration profile (a combination of a 10 and 20 Hz sine wave for our system) on the mass. An accelerometer is mounted upon the mass in the system. A PIC microprocessor records this acceleration data as well as controls a speaker (with the help of a DAC) that provides the external force to the system. This PIC communicates with MATLAB via Serial RS-232 communication. MATLAB processes this data and sends back a control signal for the speaker. After several iterations the actual mass acceleration profile begins to match the chosen profile it is told to "learn."

== Mechanics ==

The basic mechanical system for this device is a simple one, but must be assembled with precision. The major components are the speaker, linear ball bearings on a precision rod, and a spring. First, the speaker is mounted perpendicular to the ground. This must then be attached via a rod to the mass. We tried several approaches, but what seemed to be the best solution was to epoxy about a one inch section of PVC pipe to the center of the speaker. The diameter of the pipe we used matched the diameter of the junction in the speaker where the cone turns from concave to convex. This pipe also had two tapped holes running along the length of the section for a plate to attach to. The plate attached to this PVC also had a threaded hole in the center for the rod that attaches to the mass. The forces exerted by the speaker are small enough (our measurements show only about 3 Newtons) that only about an 8 ounce mass is needed. The bearing we used didn't require any additional mass to satisfy this constraint. The other end of the rod simply attached to the block which we machined and mounted atop the bearing. A piece of sheet metal was screwed into the other side of the block with spacers. This piece of metal is used to anchor spring to the mass, and allows the spring to easily be removed. A similar piece of sheet metal is attached to the wall on the opposite side of the spring. However, this sheet has a vertical slot about an eighth of an inch wide cut from the bottom. This allows the coil of the spring to slide up further on the plate, thereby creating a more solid connection.

It is important to design each component with all other components in mind at the same time. Mainly, making sure that the linear slide is level, and the rod attached to the speaker is centered, level, and in line with the mount on the mass and spring on the opposite side of the mass. This will help to ensure that all motion in the system is one dimensional.

The above was not the first iteration of our mechanical design. We originally had a homemade linear slide. However, we found the lack of precision resulted in unreliable bode plots of the system due to loose tolerances of the design creating side-to-side motion. The first iteration also had the rod epoxied directly to the mass and speaker. During initial testing the connection between the speaker and rod actually severed.

This current design is advantageous because it is modular. The threaded rod allows for minor distance changes to ensure the spring attached to the wall is at its natural rest length. To attach it the plate is detached from the PVC on the speaker and screwed onto the rod. With the spring detached, the other end of the rod is screwed into the threaded hole on the mass. Finally, the plate is then screwed into the PVC through the threaded holes. The non-permanent spring attachment also allows for springs with different k-values to be added to the system. If the spring is longer or shorter then desired, a simple change in rod length is all that is needed to incorporate the new spring into the system.

== Circuitry ==

[[Image:LearningOscMC |thumb|300px|right| Main Circuit]]

[[Image:LearningOscAM |thumb|300px|right| Accelerometer on mass]]

The main elements of the circuit were a PIC, DAC ([[http://hades.mech.northwestern.edu/wiki/index.php/PIC18F4520:_Serial_Digital-to-Analog_Conversion Digital-to-Analog converter]]) and accelerometer. The PIC would store a discretized sine waveform with integer values from 0-255. It would then output a function of this sine wave (our control signal) to the DAC. The analog signal output from the DAC would be sent to the amplifier, which would then power the speaker. The accelerometer on the mass would feedback the actual acceleration profile of the mass back to Matlab. Matlab would then recompute the next control signal and repeat the cycle until the mass was moving with the desired acceleration profile.

== Programming ==
=== PIC Code ===
In our project, a PIC was used to drive the speaker via its I2C digital-to-analog converter and record accelerometer values at fixed intervals. Since the control system’s algorithm requires too much processing for the PIC, all the computations are performed in Matlab after the accelerometer data is transported to a computer via a serial cable. This setup simplified the program for the PIC.

To generate the waveform of voltage levels sent to the speaker, a single quantized period was used. Since the waveform is periodic in nature, the wave can be repeated indefinitely in a continuous fashion. The nature of our processing algorithm constrained the number of samples for the accelerometer data to be equal to the number of samples for the control voltage.

Since our system used a waveform of fixed intervals, we used an interrupt service routine (ISR) to change the wave and record accelerations at precise intervals. We chose to sample each signal every 1ms (as this is an achievable I2C speed and ISR). To oscillate our system at 10 and 20Hz, we needed at least 100 samples per waveform (1/10Hz / 1ms = 100 samples/waveform). For this reason, we created two 100-byte long vectors for the control voltage ‘u’, and the acceleration data ‘acc’.

[[Media:ME333_Learning_Oscillator_pic_main.c|'''PIC Learning Control''']]
[[Media:ME333_Learning_Oscillator_pic_bode.c|'''PIC Bode Plot Generator''']]

=== Matlab Code ===
The Matlab code simply follows the protocol as established above. The user specifies in Matlab the parameters for the amplitude and phase of the desired acceleration waveform. *Note that the frequencies of these waves are set to 10 and 20Hz (as constrained by the transfer functions captured from the Bode and the periodic nature of 100 samples/wave).

Below are the 4 m files used in Matlab. Their names must be changed to the last part of their filenames as they are functions.

[[Media:ME333_Learning_Oscillator_main.m|'''Main Matlab Loop''']]
[[Media:ME333_Learning_Oscillator_learn.m|'''Learning Control Algorithm''']]
[[Media:ME333_Learning_Oscillator_smooth.m|'''Smoothing Algorithm''']]
[[Media:ME333_Learning_Oscillator_startplot.m|'''Plot Initialization Code''']]
[[Media:ME333_Learning_Oscillator_bode.m|'''Bode Plot Generator''']]

=== Program Flow ===

[[Image:Oscillator_Program_Flow.jpg|center|thumb|400px|Program Flow]]

=== Control System ===
To “learn” the control voltages to create a desired waveform, a simple proportional control system was used. We should note much of this code was developed, tested and debugged by Tom Vose, who was invaluable to our final project. Below is our understanding of Tom’s control algorithm.

The system first guesses a control voltage of all zeros. This ideally results in no forcing of the speaker and a flat response of acceleration. After this initial guess, the program uses proportional control to match the desired acceleration waveform. Mathematically, it multiplies the error by a proportional factor k. The error is computed by subtracting the Fast Fourier Transform (fft) of the measured acceleration from the fft of the desired acceleration. This error is multiplied by the proportional control k, and two discrete Bode plot values corresponding to the transfer function of voltage to acceleration at 10 and 20Hz. The resulting signal is the control signal u, in the frequency domain. From here, the control signal is converted back to the time domain via an inverse fft, and sent to the PIC. All of the math is computed in discrete time, for the waveforms of 100 samples long. Below is a block diagram of this control system. Note that it is in the standard unity feedback form.

[[Image:Oscillator_Control_System.jpg|center|933x200 px|Learning Control System]]

== Results ==
Below are three tests performed on various superpositions of sin waves at 10 and 20Hz. We have adjusted the phase of the waves to produce different results.

<gallery Caption="Matlab Plots Acceleration Desired vs. Experimental Acceleration">
Image:Oscillator_test1.jpg|Wave 1
Image:Oscillator_test2.jpg|Wave 2
Image:Oscillator_test3.jpg|Wave 3
</gallery>

Each diagram, shows one period of an acceleration profile. The faint blue curve in the left subplot is the desired acceleration motion. The red lines on top of the blue curve are experimental accelerations as recorded by the pic. We can see that the red lines converge on top of the desired blue motion. The right subplot (green) shows the learned voltage waveform to create the desired acceleration profile.

Each wave follows the equation below with the given parameters:

acceleration_desired = amp1*sin(2*pi*base_freq*t+phi1) + amp2*sin(2*pi*(2*base_freq)*t+phi2)

Wave 1: phi1 = 1, phi2 = 2
Wave 2: phi1 = 0, phi2 = 0
Wave 3: phi1 = 1, phi2 = 0

== Potential Applications ==

A common question regarding this project is its applications to the real world. In the Northwestern University LIMS lab, a similar type of undertaking is being researched, but on a much grander scale. This same type of oscillation control is being done for 6 dimensions (X, Y, Z, Roll, Pitch, Yaw). However, the microprocessors used in this type of control are extremely expensive, and this one dimensional test of a learning system provides a possibly cheaper solution. The six dimensional control system has possible real-world applications in product assembly.

== Reflections ==
Great results were achieved from the learning algorithm. For engineers working on it in the future, here are some topics for further investigation to get a more complete understanding about the control system:

* In this project, the control signal was manually phase-shifted by pi radians before outputting it to the speaker
** This made the algorithm work perfectly
** It is not well-understood why this step was necessary
** The algorithm would not work otherwise

* In the input for the FFT, the transfer function used in this project did not have an imaginary component
** The robust algorithm still worked perfectly, and would shift phase and 'learn' when the program was run
** In future experiments, a transfer function including an imaginary term could be used, to fully utilize the capabilities of the algorithm

* Faster learning
** The various constants in the algorithm equations can be tweaked for faster learning
** Currently, it takes about 10-20 iterations to hit the desired waveform
** More rapid learning would be a huge benefit in real-world applications

== References ==
* [http://electronics.howstuffworks.com/speaker5.htm How speakers work]
* [[Iterative Learning Control]]
* [http://lims.mech.northwestern.edu/~lynch/ Professor Kevin Lynch]
* [http://lims.mech.northwestern.edu/students/vose/ Tom Vose], author of the learning algorithm used in this project

File:LearningOscMC.jpg

2008-03-20T14:21:57Z

SandeepPrabhu:

File:LearningOscMC

2008-03-20T14:21:19Z

SandeepPrabhu:

Intelligent Oscillation Controller

2008-03-20T14:20:43Z

SandeepPrabhu: /* Circuitry */

== Team Members ==
'''Scott Mcleod:''' ''Electrical Engineering Class of 2009''

'''Brett Pihl:''' ''Mechanical Engineering Class of 2008''

'''Sandeep Prabhu:''' ''Mechanical Engineering Class of 2008
''

== Overview ==

The overall goal of this project is to create a system that induces a forcing function upon a basic, spring, mass, wall system to achieve an arbitrary periodic acceleration profile (a combination of a 10 and 20 Hz sine wave for our system) on the mass. An accelerometer is mounted upon the mass in the system. A PIC microprocessor records this acceleration data as well as controls a speaker (with the help of a DAC) that provides the external force to the system. This PIC communicates with MATLAB via Serial RS-232 communication. MATLAB processes this data and sends back a control signal for the speaker. After several iterations the actual mass acceleration profile begins to match the chosen profile it is told to "learn."

== Mechanics ==

The basic mechanical system for this device is a simple one, but must be assembled with precision. The major components are the speaker, linear ball bearings on a precision rod, and a spring. First, the speaker is mounted perpendicular to the ground. This must then be attached via a rod to the mass. We tried several approaches, but what seemed to be the best solution was to epoxy about a one inch section of PVC pipe to the center of the speaker. The diameter of the pipe we used matched the diameter of the junction in the speaker where the cone turns from concave to convex. This pipe also had two tapped holes running along the length of the section for a plate to attach to. The plate attached to this PVC also had a threaded hole in the center for the rod that attaches to the mass. The forces exerted by the speaker are small enough (our measurements show only about 3 Newtons) that only about an 8 ounce mass is needed. The bearing we used didn't require any additional mass to satisfy this constraint. The other end of the rod simply attached to the block which we machined and mounted atop the bearing. A piece of sheet metal was screwed into the other side of the block with spacers. This piece of metal is used to anchor spring to the mass, and allows the spring to easily be removed. A similar piece of sheet metal is attached to the wall on the opposite side of the spring. However, this sheet has a vertical slot about an eighth of an inch wide cut from the bottom. This allows the coil of the spring to slide up further on the plate, thereby creating a more solid connection.

It is important to design each component with all other components in mind at the same time. Mainly, making sure that the linear slide is level, and the rod attached to the speaker is centered, level, and in line with the mount on the mass and spring on the opposite side of the mass. This will help to ensure that all motion in the system is one dimensional.

The above was not the first iteration of our mechanical design. We originally had a homemade linear slide. However, we found the lack of precision resulted in unreliable bode plots of the system due to loose tolerances of the design creating side-to-side motion. The first iteration also had the rod epoxied directly to the mass and speaker. During initial testing the connection between the speaker and rod actually severed.

This current design is advantageous because it is modular. The threaded rod allows for minor distance changes to ensure the spring attached to the wall is at its natural rest length. To attach it the plate is detached from the PVC on the speaker and screwed onto the rod. With the spring detached, the other end of the rod is screwed into the threaded hole on the mass. Finally, the plate is then screwed into the PVC through the threaded holes. The non-permanent spring attachment also allows for springs with different k-values to be added to the system. If the spring is longer or shorter then desired, a simple change in rod length is all that is needed to incorporate the new spring into the system.

== Circuitry ==

[[Image:Main Circuit |thumb|300px|right| Main Circuit]]

[[Image:Main Circuit |thumb|300px|right| Accelerometer on mass]]

The main elements of the circuit were a PIC, DAC ([[http://hades.mech.northwestern.edu/wiki/index.php/PIC18F4520:_Serial_Digital-to-Analog_Conversion Digital-to-Analog converter]]) and accelerometer. The PIC would store a discretized sine waveform with integer values from 0-255. It would then output a function of this sine wave (our control signal) to the DAC. The analog signal output from the DAC would be sent to the amplifier, which would then power the speaker. The accelerometer on the mass would feedback the actual acceleration profile of the mass back to Matlab. Matlab would then recompute the next control signal and repeat the cycle until the mass was moving with the desired acceleration profile.

== Programming ==
=== PIC Code ===
In our project, a PIC was used to drive the speaker via its I2C digital-to-analog converter and record accelerometer values at fixed intervals. Since the control system’s algorithm requires too much processing for the PIC, all the computations are performed in Matlab after the accelerometer data is transported to a computer via a serial cable. This setup simplified the program for the PIC.

To generate the waveform of voltage levels sent to the speaker, a single quantized period was used. Since the waveform is periodic in nature, the wave can be repeated indefinitely in a continuous fashion. The nature of our processing algorithm constrained the number of samples for the accelerometer data to be equal to the number of samples for the control voltage.

Since our system used a waveform of fixed intervals, we used an interrupt service routine (ISR) to change the wave and record accelerations at precise intervals. We chose to sample each signal every 1ms (as this is an achievable I2C speed and ISR). To oscillate our system at 10 and 20Hz, we needed at least 100 samples per waveform (1/10Hz / 1ms = 100 samples/waveform). For this reason, we created two 100-byte long vectors for the control voltage ‘u’, and the acceleration data ‘acc’.

[[Media:ME333_Learning_Oscillator_pic_main.c|'''PIC Learning Control''']]
[[Media:ME333_Learning_Oscillator_pic_bode.c|'''PIC Bode Plot Generator''']]

=== Matlab Code ===
The Matlab code simply follows the protocol as established above. The user specifies in Matlab the parameters for the amplitude and phase of the desired acceleration waveform. *Note that the frequencies of these waves are set to 10 and 20Hz (as constrained by the transfer functions captured from the Bode and the periodic nature of 100 samples/wave).

Below are the 4 m files used in Matlab. Their names must be changed to the last part of their filenames as they are functions.

[[Media:ME333_Learning_Oscillator_main.m|'''Main Matlab Loop''']]
[[Media:ME333_Learning_Oscillator_learn.m|'''Learning Control Algorithm''']]
[[Media:ME333_Learning_Oscillator_smooth.m|'''Smoothing Algorithm''']]
[[Media:ME333_Learning_Oscillator_startplot.m|'''Plot Initialization Code''']]
[[Media:ME333_Learning_Oscillator_bode.m|'''Bode Plot Generator''']]

=== Program Flow ===

[[Image:Oscillator_Program_Flow.jpg|center|thumb|400px|Program Flow]]

=== Control System ===
To “learn” the control voltages to create a desired waveform, a simple proportional control system was used. We should note much of this code was developed, tested and debugged by Tom Vose, who was invaluable to our final project. Below is our understanding of Tom’s control algorithm.

The system first guesses a control voltage of all zeros. This ideally results in no forcing of the speaker and a flat response of acceleration. After this initial guess, the program uses proportional control to match the desired acceleration waveform. Mathematically, it multiplies the error by a proportional factor k. The error is computed by subtracting the Fast Fourier Transform (fft) of the measured acceleration from the fft of the desired acceleration. This error is multiplied by the proportional control k, and two discrete Bode plot values corresponding to the transfer function of voltage to acceleration at 10 and 20Hz. The resulting signal is the control signal u, in the frequency domain. From here, the control signal is converted back to the time domain via an inverse fft, and sent to the PIC. All of the math is computed in discrete time, for the waveforms of 100 samples long. Below is a block diagram of this control system. Note that it is in the standard unity feedback form.

[[Image:Oscillator_Control_System.jpg|center|933x200 px|Learning Control System]]

== Results ==
Below are three tests performed on various superpositions of sin waves at 10 and 20Hz. We have adjusted the phase of the waves to produce different results.

<gallery Caption="Matlab Plots Acceleration Desired vs. Experimental Acceleration">
Image:Oscillator_test1.jpg|Wave 1
Image:Oscillator_test2.jpg|Wave 2
Image:Oscillator_test3.jpg|Wave 3
</gallery>

Each diagram, shows one period of an acceleration profile. The faint blue curve in the left subplot is the desired acceleration motion. The red lines on top of the blue curve are experimental accelerations as recorded by the pic. We can see that the red lines converge on top of the desired blue motion. The right subplot (green) shows the learned voltage waveform to create the desired acceleration profile.

Each wave follows the equation below with the given parameters:

acceleration_desired = amp1*sin(2*pi*base_freq*t+phi1) + amp2*sin(2*pi*(2*base_freq)*t+phi2)

Wave 1: phi1 = 1, phi2 = 2
Wave 2: phi1 = 0, phi2 = 0
Wave 3: phi1 = 1, phi2 = 0

== Potential Applications ==

A common question regarding this project is its applications to the real world. In the Northwestern University LIMS lab, a similar type of undertaking is being researched, but on a much grander scale. This same type of oscillation control is being done for 6 dimensions (X, Y, Z, Roll, Pitch, Yaw). However, the microprocessors used in this type of control are extremely expensive, and this one dimensional test of a learning system provides a possibly cheaper solution. The six dimensional control system has possible real-world applications in product assembly.

== Reflections ==
Great results were achieved from the learning algorithm. For engineers working on it in the future, here are some topics for further investigation to get a more complete understanding about the control system:

* In this project, the control signal was manually phase-shifted by pi radians before outputting it to the speaker
** This made the algorithm work perfectly
** It is not well-understood why this step was necessary
** The algorithm would not work otherwise

* In the input for the FFT, the transfer function used in this project did not have an imaginary component
** The robust algorithm still worked perfectly, and would shift phase and 'learn' when the program was run
** In future experiments, a transfer function including an imaginary term could be used, to fully utilize the capabilities of the algorithm

* Faster learning
** The various constants in the algorithm equations can be tweaked for faster learning
** Currently, it takes about 10-20 iterations to hit the desired waveform
** More rapid learning would be a huge benefit in real-world applications

== References ==
* [http://electronics.howstuffworks.com/speaker5.htm How speakers work]
* [[Iterative Learning Control]]
* [http://lims.mech.northwestern.edu/~lynch/ Professor Kevin Lynch]
* [http://lims.mech.northwestern.edu/students/vose/ Tom Vose], author of the learning algorithm used in this project

Intelligent Oscillation Controller

2008-03-20T14:15:44Z

SandeepPrabhu: /* Circuitry */

== Team Members ==
'''Scott Mcleod:''' ''Electrical Engineering Class of 2009''

'''Brett Pihl:''' ''Mechanical Engineering Class of 2008''

'''Sandeep Prabhu:''' ''Mechanical Engineering Class of 2008
''

== Overview ==

The overall goal of this project is to create a system that induces a forcing function upon a basic, spring, mass, wall system to achieve an arbitrary periodic acceleration profile (a combination of a 10 and 20 Hz sine wave for our system) on the mass. An accelerometer is mounted upon the mass in the system. A PIC microprocessor records this acceleration data as well as controls a speaker (with the help of a DAC) that provides the external force to the system. This PIC communicates with MATLAB via Serial RS-232 communication. MATLAB processes this data and sends back a control signal for the speaker. After several iterations the actual mass acceleration profile begins to match the chosen profile it is told to "learn."

== Mechanics ==

The basic mechanical system for this device is a simple one, but must be assembled with precision. The major components are the speaker, linear ball bearings on a precision rod, and a spring. First, the speaker is mounted perpendicular to the ground. This must then be attached via a rod to the mass. We tried several approaches, but what seemed to be the best solution was to epoxy about a one inch section of PVC pipe to the center of the speaker. The diameter of the pipe we used matched the diameter of the junction in the speaker where the cone turns from concave to convex. This pipe also had two tapped holes running along the length of the section for a plate to attach to. The plate attached to this PVC also had a threaded hole in the center for the rod that attaches to the mass. The forces exerted by the speaker are small enough (our measurements show only about 3 Newtons) that only about an 8 ounce mass is needed. The bearing we used didn't require any additional mass to satisfy this constraint. The other end of the rod simply attached to the block which we machined and mounted atop the bearing. A piece of sheet metal was screwed into the other side of the block with spacers. This piece of metal is used to anchor spring to the mass, and allows the spring to easily be removed. A similar piece of sheet metal is attached to the wall on the opposite side of the spring. However, this sheet has a vertical slot about an eighth of an inch wide cut from the bottom. This allows the coil of the spring to slide up further on the plate, thereby creating a more solid connection.

It is important to design each component with all other components in mind at the same time. Mainly, making sure that the linear slide is level, and the rod attached to the speaker is centered, level, and in line with the mount on the mass and spring on the opposite side of the mass. This will help to ensure that all motion in the system is one dimensional.

The above was not the first iteration of our mechanical design. We originally had a homemade linear slide. However, we found the lack of precision resulted in unreliable bode plots of the system due to loose tolerances of the design creating side-to-side motion. The first iteration also had the rod epoxied directly to the mass and speaker. During initial testing the connection between the speaker and rod actually severed.

This current design is advantageous because it is modular. The threaded rod allows for minor distance changes to ensure the spring attached to the wall is at its natural rest length. To attach it the plate is detached from the PVC on the speaker and screwed onto the rod. With the spring detached, the other end of the rod is screwed into the threaded hole on the mass. Finally, the plate is then screwed into the PVC through the threaded holes. The non-permanent spring attachment also allows for springs with different k-values to be added to the system. If the spring is longer or shorter then desired, a simple change in rod length is all that is needed to incorporate the new spring into the system.

== Circuitry ==
The main elements of the circuit were a PIC, DAC ([[http://hades.mech.northwestern.edu/wiki/index.php/PIC18F4520:_Serial_Digital-to-Analog_Conversion Digital-to-Analog converter]]) and accelerometer. The PIC would store a discretized sine waveform with integer values from 0-255. It would then output a function of this sine wave (our control signal) to the DAC. The analog signal output from the DAC would be sent to the amplifier, which would then power the speaker. The accelerometer on the mass would feedback the actual acceleration profile of the mass back to Matlab. Matlab would then recompute the next control signal and repeat the cycle until the mass was moving with the desired acceleration profile.

[[Image:Main Circuit |thumb|300px|left| Main Circuit]]

[[Image:Main Circuit |thumb|300px|right| Accelerometer on mass]]

== Programming ==
=== PIC Code ===
In our project, a PIC was used to drive the speaker via its I2C digital-to-analog converter and record accelerometer values at fixed intervals. Since the control system’s algorithm requires too much processing for the PIC, all the computations are performed in Matlab after the accelerometer data is transported to a computer via a serial cable. This setup simplified the program for the PIC.

To generate the waveform of voltage levels sent to the speaker, a single quantized period was used. Since the waveform is periodic in nature, the wave can be repeated indefinitely in a continuous fashion. The nature of our processing algorithm constrained the number of samples for the accelerometer data to be equal to the number of samples for the control voltage.

Since our system used a waveform of fixed intervals, we used an interrupt service routine (ISR) to change the wave and record accelerations at precise intervals. We chose to sample each signal every 1ms (as this is an achievable I2C speed and ISR). To oscillate our system at 10 and 20Hz, we needed at least 100 samples per waveform (1/10Hz / 1ms = 100 samples/waveform). For this reason, we created two 100-byte long vectors for the control voltage ‘u’, and the acceleration data ‘acc’.

[[Media:ME333_Learning_Oscillator_pic_main.c|'''PIC Learning Control''']]
[[Media:ME333_Learning_Oscillator_pic_bode.c|'''PIC Bode Plot Generator''']]

=== Matlab Code ===
The Matlab code simply follows the protocol as established above. The user specifies in Matlab the parameters for the amplitude and phase of the desired acceleration waveform. *Note that the frequencies of these waves are set to 10 and 20Hz (as constrained by the transfer functions captured from the Bode and the periodic nature of 100 samples/wave).

Below are the 4 m files used in Matlab. Their names must be changed to the last part of their filenames as they are functions.

[[Media:ME333_Learning_Oscillator_main.m|'''Main Matlab Loop''']]
[[Media:ME333_Learning_Oscillator_learn.m|'''Learning Control Algorithm''']]
[[Media:ME333_Learning_Oscillator_smooth.m|'''Smoothing Algorithm''']]
[[Media:ME333_Learning_Oscillator_startplot.m|'''Plot Initialization Code''']]
[[Media:ME333_Learning_Oscillator_bode.m|'''Bode Plot Generator''']]

=== Program Flow ===

[[Image:Oscillator_Program_Flow.jpg|center|thumb|400px|Program Flow]]

=== Control System ===
To “learn” the control voltages to create a desired waveform, a simple proportional control system was used. We should note much of this code was developed, tested and debugged by Tom Vose, who was invaluable to our final project. Below is our understanding of Tom’s control algorithm.

The system first guesses a control voltage of all zeros. This ideally results in no forcing of the speaker and a flat response of acceleration. After this initial guess, the program uses proportional control to match the desired acceleration waveform. Mathematically, it multiplies the error by a proportional factor k. The error is computed by subtracting the Fast Fourier Transform (fft) of the measured acceleration from the fft of the desired acceleration. This error is multiplied by the proportional control k, and two discrete Bode plot values corresponding to the transfer function of voltage to acceleration at 10 and 20Hz. The resulting signal is the control signal u, in the frequency domain. From here, the control signal is converted back to the time domain via an inverse fft, and sent to the PIC. All of the math is computed in discrete time, for the waveforms of 100 samples long. Below is a block diagram of this control system. Note that it is in the standard unity feedback form.

[[Image:Oscillator_Control_System.jpg|center|933x200 px|Learning Control System]]

== Results ==
Below are three tests performed on various superpositions of sin waves at 10 and 20Hz. We have adjusted the phase of the waves to produce different results.

<gallery Caption="Matlab Plots Acceleration Desired vs. Experimental Acceleration">
Image:Oscillator_test1.jpg|Wave 1
Image:Oscillator_test2.jpg|Wave 2
Image:Oscillator_test3.jpg|Wave 3
</gallery>

Each diagram, shows one period of an acceleration profile. The faint blue curve in the left subplot is the desired acceleration motion. The red lines on top of the blue curve are experimental accelerations as recorded by the pic. We can see that the red lines converge on top of the desired blue motion. The right subplot (green) shows the learned voltage waveform to create the desired acceleration profile.

Each wave follows the equation below with the given parameters:

acceleration_desired = amp1*sin(2*pi*base_freq*t+phi1) + amp2*sin(2*pi*(2*base_freq)*t+phi2)

Wave 1: phi1 = 1, phi2 = 2
Wave 2: phi1 = 0, phi2 = 0
Wave 3: phi1 = 1, phi2 = 0

== Potential Applications ==

A common question regarding this project is its applications to the real world. In the Northwestern University LIMS lab, a similar type of undertaking is being researched, but on a much grander scale. This same type of oscillation control is being done for 6 dimensions (X, Y, Z, Roll, Pitch, Yaw). However, the microprocessors used in this type of control are extremely expensive, and this one dimensional test of a learning system provides a possibly cheaper solution. The six dimensional control system has possible real-world applications in product assembly.

== Reflections ==
Great results were achieved from the learning algorithm. For engineers working on it in the future, here are some topics for further investigation to get a more complete understanding about the control system:

* In this project, the control signal was manually phase-shifted by pi radians before outputting it to the speaker
** This made the algorithm work perfectly
** It is not well-understood why this step was necessary
** The algorithm would not work otherwise

* In the input for the FFT, the transfer function used in this project did not have an imaginary component
** The robust algorithm still worked perfectly, and would shift phase and 'learn' when the program was run
** In future experiments, a transfer function including an imaginary term could be used, to fully utilize the capabilities of the algorithm

* Faster learning
** The various constants in the algorithm equations can be tweaked for faster learning
** Currently, it takes about 10-20 iterations to hit the desired waveform
** More rapid learning would be a huge benefit in real-world applications

== References ==
* [http://electronics.howstuffworks.com/speaker5.htm How speakers work]
* [[Iterative Learning Control]]
* [http://lims.mech.northwestern.edu/~lynch/ Professor Kevin Lynch]
* [http://lims.mech.northwestern.edu/students/vose/ Tom Vose], author of the learning algorithm used in this project

Intelligent Oscillation Controller

2008-03-20T14:14:16Z

SandeepPrabhu: /* Circuitry */

== Team Members ==
'''Scott Mcleod:''' ''Electrical Engineering Class of 2009''

'''Brett Pihl:''' ''Mechanical Engineering Class of 2008''

'''Sandeep Prabhu:''' ''Mechanical Engineering Class of 2008
''

== Overview ==

The overall goal of this project is to create a system that induces a forcing function upon a basic, spring, mass, wall system to achieve an arbitrary periodic acceleration profile (a combination of a 10 and 20 Hz sine wave for our system) on the mass. An accelerometer is mounted upon the mass in the system. A PIC microprocessor records this acceleration data as well as controls a speaker (with the help of a DAC) that provides the external force to the system. This PIC communicates with MATLAB via Serial RS-232 communication. MATLAB processes this data and sends back a control signal for the speaker. After several iterations the actual mass acceleration profile begins to match the chosen profile it is told to "learn."

== Mechanics ==

The basic mechanical system for this device is a simple one, but must be assembled with precision. The major components are the speaker, linear ball bearings on a precision rod, and a spring. First, the speaker is mounted perpendicular to the ground. This must then be attached via a rod to the mass. We tried several approaches, but what seemed to be the best solution was to epoxy about a one inch section of PVC pipe to the center of the speaker. The diameter of the pipe we used matched the diameter of the junction in the speaker where the cone turns from concave to convex. This pipe also had two tapped holes running along the length of the section for a plate to attach to. The plate attached to this PVC also had a threaded hole in the center for the rod that attaches to the mass. The forces exerted by the speaker are small enough (our measurements show only about 3 Newtons) that only about an 8 ounce mass is needed. The bearing we used didn't require any additional mass to satisfy this constraint. The other end of the rod simply attached to the block which we machined and mounted atop the bearing. A piece of sheet metal was screwed into the other side of the block with spacers. This piece of metal is used to anchor spring to the mass, and allows the spring to easily be removed. A similar piece of sheet metal is attached to the wall on the opposite side of the spring. However, this sheet has a vertical slot about an eighth of an inch wide cut from the bottom. This allows the coil of the spring to slide up further on the plate, thereby creating a more solid connection.

It is important to design each component with all other components in mind at the same time. Mainly, making sure that the linear slide is level, and the rod attached to the speaker is centered, level, and in line with the mount on the mass and spring on the opposite side of the mass. This will help to ensure that all motion in the system is one dimensional.

The above was not the first iteration of our mechanical design. We originally had a homemade linear slide. However, we found the lack of precision resulted in unreliable bode plots of the system due to loose tolerances of the design creating side-to-side motion. The first iteration also had the rod epoxied directly to the mass and speaker. During initial testing the connection between the speaker and rod actually severed.

This current design is advantageous because it is modular. The threaded rod allows for minor distance changes to ensure the spring attached to the wall is at its natural rest length. To attach it the plate is detached from the PVC on the speaker and screwed onto the rod. With the spring detached, the other end of the rod is screwed into the threaded hole on the mass. Finally, the plate is then screwed into the PVC through the threaded holes. The non-permanent spring attachment also allows for springs with different k-values to be added to the system. If the spring is longer or shorter then desired, a simple change in rod length is all that is needed to incorporate the new spring into the system.

== Circuitry ==
The main elements of the circuit were a PIC, DAC ([[http://hades.mech.northwestern.edu/wiki/index.php/PIC18F4520:_Serial_Digital-to-Analog_Conversion Digital-to-Analog converter]]) and accelerometer. The PIC would store a discretized sine waveform with integer values from 0-255. It would then output a function of this sine wave (our control signal) to the DAC. The analog signal output from the DAC would be sent to the amplifier, which would then power the speaker. The accelerometer on the mass would feedback the actual acceleration profile of the mass back to Matlab. Matlab would then recompute the next control signal and repeat the cycle until the mass was moving with the desired acceleration profile.

[[|thumb|300px|left| Main Circuit]]

[[|thumb|300px|right| Accelerometer on mass]]

== Programming ==
=== PIC Code ===
In our project, a PIC was used to drive the speaker via its I2C digital-to-analog converter and record accelerometer values at fixed intervals. Since the control system’s algorithm requires too much processing for the PIC, all the computations are performed in Matlab after the accelerometer data is transported to a computer via a serial cable. This setup simplified the program for the PIC.

To generate the waveform of voltage levels sent to the speaker, a single quantized period was used. Since the waveform is periodic in nature, the wave can be repeated indefinitely in a continuous fashion. The nature of our processing algorithm constrained the number of samples for the accelerometer data to be equal to the number of samples for the control voltage.

Since our system used a waveform of fixed intervals, we used an interrupt service routine (ISR) to change the wave and record accelerations at precise intervals. We chose to sample each signal every 1ms (as this is an achievable I2C speed and ISR). To oscillate our system at 10 and 20Hz, we needed at least 100 samples per waveform (1/10Hz / 1ms = 100 samples/waveform). For this reason, we created two 100-byte long vectors for the control voltage ‘u’, and the acceleration data ‘acc’.

[[Media:ME333_Learning_Oscillator_pic_main.c|'''PIC Learning Control''']]
[[Media:ME333_Learning_Oscillator_pic_bode.c|'''PIC Bode Plot Generator''']]

=== Matlab Code ===
The Matlab code simply follows the protocol as established above. The user specifies in Matlab the parameters for the amplitude and phase of the desired acceleration waveform. *Note that the frequencies of these waves are set to 10 and 20Hz (as constrained by the transfer functions captured from the Bode and the periodic nature of 100 samples/wave).

Below are the 4 m files used in Matlab. Their names must be changed to the last part of their filenames as they are functions.

[[Media:ME333_Learning_Oscillator_main.m|'''Main Matlab Loop''']]
[[Media:ME333_Learning_Oscillator_learn.m|'''Learning Control Algorithm''']]
[[Media:ME333_Learning_Oscillator_smooth.m|'''Smoothing Algorithm''']]
[[Media:ME333_Learning_Oscillator_startplot.m|'''Plot Initialization Code''']]
[[Media:ME333_Learning_Oscillator_bode.m|'''Bode Plot Generator''']]

=== Program Flow ===

[[Image:Oscillator_Program_Flow.jpg|center|thumb|400px|Program Flow]]

=== Control System ===
To “learn” the control voltages to create a desired waveform, a simple proportional control system was used. We should note much of this code was developed, tested and debugged by Tom Vose, who was invaluable to our final project. Below is our understanding of Tom’s control algorithm.

The system first guesses a control voltage of all zeros. This ideally results in no forcing of the speaker and a flat response of acceleration. After this initial guess, the program uses proportional control to match the desired acceleration waveform. Mathematically, it multiplies the error by a proportional factor k. The error is computed by subtracting the Fast Fourier Transform (fft) of the measured acceleration from the fft of the desired acceleration. This error is multiplied by the proportional control k, and two discrete Bode plot values corresponding to the transfer function of voltage to acceleration at 10 and 20Hz. The resulting signal is the control signal u, in the frequency domain. From here, the control signal is converted back to the time domain via an inverse fft, and sent to the PIC. All of the math is computed in discrete time, for the waveforms of 100 samples long. Below is a block diagram of this control system. Note that it is in the standard unity feedback form.

[[Image:Oscillator_Control_System.jpg|center|933x200 px|Learning Control System]]

== Results ==
Below are three tests performed on various superpositions of sin waves at 10 and 20Hz. We have adjusted the phase of the waves to produce different results.

<gallery Caption="Matlab Plots Acceleration Desired vs. Experimental Acceleration">
Image:Oscillator_test1.jpg|Wave 1
Image:Oscillator_test2.jpg|Wave 2
Image:Oscillator_test3.jpg|Wave 3
</gallery>

Each diagram, shows one period of an acceleration profile. The faint blue curve in the left subplot is the desired acceleration motion. The red lines on top of the blue curve are experimental accelerations as recorded by the pic. We can see that the red lines converge on top of the desired blue motion. The right subplot (green) shows the learned voltage waveform to create the desired acceleration profile.

Each wave follows the equation below with the given parameters:

acceleration_desired = amp1*sin(2*pi*base_freq*t+phi1) + amp2*sin(2*pi*(2*base_freq)*t+phi2)

Wave 1: phi1 = 1, phi2 = 2
Wave 2: phi1 = 0, phi2 = 0
Wave 3: phi1 = 1, phi2 = 0

== Potential Applications ==

A common question regarding this project is its applications to the real world. In the Northwestern University LIMS lab, a similar type of undertaking is being researched, but on a much grander scale. This same type of oscillation control is being done for 6 dimensions (X, Y, Z, Roll, Pitch, Yaw). However, the microprocessors used in this type of control are extremely expensive, and this one dimensional test of a learning system provides a possibly cheaper solution. The six dimensional control system has possible real-world applications in product assembly.

== Reflections ==
Great results were achieved from the learning algorithm. For engineers working on it in the future, here are some topics for further investigation to get a more complete understanding about the control system:

* In this project, the control signal was manually phase-shifted by pi radians before outputting it to the speaker
** This made the algorithm work perfectly
** It is not well-understood why this step was necessary
** The algorithm would not work otherwise

* In the input for the FFT, the transfer function used in this project did not have an imaginary component
** The robust algorithm still worked perfectly, and would shift phase and 'learn' when the program was run
** In future experiments, a transfer function including an imaginary term could be used, to fully utilize the capabilities of the algorithm

* Faster learning
** The various constants in the algorithm equations can be tweaked for faster learning
** Currently, it takes about 10-20 iterations to hit the desired waveform
** More rapid learning would be a huge benefit in real-world applications

== References ==
* [http://electronics.howstuffworks.com/speaker5.htm How speakers work]
* [[Iterative Learning Control]]
* [http://lims.mech.northwestern.edu/~lynch/ Professor Kevin Lynch]
* [http://lims.mech.northwestern.edu/students/vose/ Tom Vose], author of the learning algorithm used in this project

Intelligent Oscillation Controller

2008-03-20T14:01:17Z

SandeepPrabhu: /* References */

== Team Members ==
'''Scott Mcleod:''' ''Electrical Engineering Class of 2009''

'''Brett Pihl:''' ''Mechanical Engineering Class of 2008''

'''Sandeep Prabhu:''' ''Mechanical Engineering Class of 2008
''

== Overview ==

The overall goal of this project is to create a system that induces a forcing function upon a basic, spring, mass, wall system to achieve an arbitrary periodic acceleration profile (a combination of a 10 and 20 Hz sine wave for our system) on the mass. An accelerometer is mounted upon the mass in the system. A PIC microprocessor records this acceleration data as well as controls a speaker (with the help of a DAC) that provides the external force to the system. This PIC communicates with MATLAB via Serial RS-232 communication. MATLAB processes this data and sends back a control signal for the speaker. After several iterations the actual mass acceleration profile begins to match the chosen profile it is told to "learn."

== Mechanics ==

The basic mechanical system for this device is a simple one, but must be assembled with precision. The major components are the speaker, linear ball bearings on a precision rod, and a spring. First, the speaker is mounted perpendicular to the ground. This must then be attached via a rod to the mass. We tried several approaches, but what seemed to be the best solution was to epoxy about a one inch section of PVC pipe to the center of the speaker. The diameter of the pipe we used matched the diameter of the junction in the speaker where the cone turns from concave to convex. This pipe also had two tapped holes running along the length of the section for a plate to attach to. The plate attached to this PVC also had a threaded hole in the center for the rod that attaches to the mass. The forces exerted by the speaker are small enough (our measurements show only about 3 Newtons) that only about an 8 ounce mass is needed. The bearing we used didn't require any additional mass to satisfy this constraint. The other end of the rod simply attached to the block which we machined and mounted atop the bearing. A piece of sheet metal was screwed into the other side of the block with spacers. This piece of metal is used to anchor spring to the mass, and allows the spring to easily be removed. A similar piece of sheet metal is attached to the wall on the opposite side of the spring. However, this sheet has a vertical slot about an eighth of an inch wide cut from the bottom. This allows the coil of the spring to slide up further on the plate, thereby creating a more solid connection.

It is important to design each component with all other components in mind at the same time. Mainly, making sure that the linear slide is level, and the rod attached to the speaker is centered, level, and in line with the mount on the mass and spring on the opposite side of the mass. This will help to ensure that all motion in the system is one dimensional.

The above was not the first iteration of our mechanical design. We originally had a homemade linear slide. However, we found the lack of precision resulted in unreliable bode plots of the system due to loose tolerances of the design creating side-to-side motion. The first iteration also had the rod epoxied directly to the mass and speaker. During initial testing the connection between the speaker and rod actually severed.

This current design is advantageous because it is modular. The threaded rod allows for minor distance changes to ensure the spring attached to the wall is at its natural rest length. To attach it the plate is detached from the PVC on the speaker and screwed onto the rod. With the spring detached, the other end of the rod is screwed into the threaded hole on the mass. Finally, the plate is then screwed into the PVC through the threaded holes. The non-permanent spring attachment also allows for springs with different k-values to be added to the system. If the spring is longer or shorter then desired, a simple change in rod length is all that is needed to incorporate the new spring into the system.

== Circuitry ==

== Programming ==
=== PIC Code ===
In our project, a PIC was used to drive the speaker via its I2C digital-to-analog converter and record accelerometer values at fixed intervals. Since the control system’s algorithm requires too much processing for the PIC, all the computations are performed in Matlab after the accelerometer data is transported to a computer via a serial cable. This setup simplified the program for the PIC.

To generate the waveform of voltage levels sent to the speaker, a single quantized period was used. Since the waveform is periodic in nature, the wave can be repeated indefinitely in a continuous fashion. The nature of our processing algorithm constrained the number of samples for the accelerometer data to be equal to the number of samples for the control voltage.

Since our system used a waveform of fixed intervals, we used an interrupt service routine (ISR) to change the wave and record accelerations at precise intervals. We chose to sample each signal every 1ms (as this is an achievable I2C speed and ISR). To oscillate our system at 10 and 20Hz, we needed at least 100 samples per waveform (1/10Hz / 1ms = 100 samples/waveform). For this reason, we created two 100-byte long vectors for the control voltage ‘u’, and the acceleration data ‘acc’.

[[Media:ME333_Learning_Oscillator_pic_main.c|'''PIC Learning Control''']]
[[Media:ME333_Learning_Oscillator_pic_bode.c|'''PIC Bode Plot Generator''']]

=== Matlab Code ===
The Matlab code simply follows the protocol as established above. The user specifies in Matlab the parameters for the amplitude and phase of the desired acceleration waveform. *Note that the frequencies of these waves are set to 10 and 20Hz (as constrained by the transfer functions captured from the Bode and the periodic nature of 100 samples/wave).

Below are the 4 m files used in Matlab. Their names must be changed to the last part of their filenames as they are functions.

[[Media:ME333_Learning_Oscillator_main.m|'''Main Matlab Loop''']]
[[Media:ME333_Learning_Oscillator_learn.m|'''Learning Control Algorithm''']]
[[Media:ME333_Learning_Oscillator_smooth.m|'''Smoothing Algorithm''']]
[[Media:ME333_Learning_Oscillator_startplot.m|'''Plot Initialization Code''']]
[[Media:ME333_Learning_Oscillator_bode.m|'''Bode Plot Generator''']]

=== Program Flow ===

[[Image:Oscillator_Program_Flow.jpg|center|thumb|400px|Program Flow]]

=== Control System ===
To “learn” the control voltages to create a desired waveform, a simple proportional control system was used. We should note much of this code was developed, tested and debugged by Tom Vose, who was invaluable to our final project. Below is our understanding of Tom’s control algorithm.

The system first guesses a control voltage of all zeros. This ideally results in no forcing of the speaker and a flat response of acceleration. After this initial guess, the program uses proportional control to match the desired acceleration waveform. Mathematically, it multiplies the error by a proportional factor k. The error is computed by subtracting the Fast Fourier Transform (fft) of the measured acceleration from the fft of the desired acceleration. This error is multiplied by the proportional control k, and two discrete Bode plot values corresponding to the transfer function of voltage to acceleration at 10 and 20Hz. The resulting signal is the control signal u, in the frequency domain. From here, the control signal is converted back to the time domain via an inverse fft, and sent to the PIC. All of the math is computed in discrete time, for the waveforms of 100 samples long. Below is a block diagram of this control system. Note that it is in the standard unity feedback form.

[[Image:Oscillator_Control_System.jpg|center|933x200 px|Learning Control System]]

== Results ==
Below are three tests performed on various superpositions of sin waves at 10 and 20Hz. We have adjusted the phase of the waves to produce different results.

<gallery Caption="Matlab Plots Acceleration Desired vs. Experimental Acceleration">
Image:Oscillator_test1.jpg|Wave 1
Image:Oscillator_test2.jpg|Wave 2
Image:Oscillator_test3.jpg|Wave 3
</gallery>

Each diagram, shows one period of an acceleration profile. The faint blue curve in the left subplot is the desired acceleration motion. The red lines on top of the blue curve are experimental accelerations as recorded by the pic. We can see that the red lines converge on top of the desired blue motion. The right subplot (green) shows the learned voltage waveform to create the desired acceleration profile.

Each wave follows the equation below with the given parameters:

acceleration_desired = amp1*sin(2*pi*base_freq*t+phi1) + amp2*sin(2*pi*(2*base_freq)*t+phi2)

Wave 1: phi1 = 1, phi2 = 2
Wave 2: phi1 = 0, phi2 = 0
Wave 3: phi1 = 1, phi2 = 0

== Potential Applications ==

A common question regarding this project is its applications to the real world. In the Northwestern University LIMS lab, a similar type of undertaking is being researched, but on a much grander scale. This same type of oscillation control is being done for 6 dimensions (X, Y, Z, Roll, Pitch, Yaw). However, the microprocessors used in this type of control are extremely expensive, and this one dimensional test of a learning system provides a possibly cheaper solution. The six dimensional control system has possible real-world applications in product assembly.

== Reflections ==
Great results were achieved from the learning algorithm. For engineers working on it in the future, here are some topics for further investigation to get a more complete understanding about the control system:

* In this project, the control signal was manually phase-shifted by pi radians before outputting it to the speaker
** This made the algorithm work perfectly
** It is not well-understood why this step was necessary
** The algorithm would not work otherwise

* In the input for the FFT, the transfer function used in this project did not have an imaginary component
** The robust algorithm still worked perfectly, and would shift phase and 'learn' when the program was run
** In future experiments, a transfer function including an imaginary term could be used, to fully utilize the capabilities of the algorithm

* Faster learning
** The various constants in the algorithm equations can be tweaked for faster learning
** Currently, it takes about 10-20 iterations to hit the desired waveform
** More rapid learning would be a huge benefit in real-world applications

== References ==
* [http://electronics.howstuffworks.com/speaker5.htm How speakers work]
* [[Iterative Learning Control]]
* [http://lims.mech.northwestern.edu/~lynch/ Professor Kevin Lynch]
* [http://lims.mech.northwestern.edu/students/vose/ Tom Vose], author of the learning algorithm used in this project

Intelligent Oscillation Controller

2008-03-20T13:59:55Z

SandeepPrabhu: /* Reflections */

== Team Members ==
'''Scott Mcleod:''' ''Electrical Engineering Class of 2009''

'''Brett Pihl:''' ''Mechanical Engineering Class of 2008''

'''Sandeep Prabhu:''' ''Mechanical Engineering Class of 2008
''

== Overview ==

The overall goal of this project is to create a system that induces a forcing function upon a basic, spring, mass, wall system to achieve an arbitrary periodic acceleration profile (a combination of a 10 and 20 Hz sine wave for our system) on the mass. An accelerometer is mounted upon the mass in the system. A PIC microprocessor records this acceleration data as well as controls a speaker (with the help of a DAC) that provides the external force to the system. This PIC communicates with MATLAB via Serial RS-232 communication. MATLAB processes this data and sends back a control signal for the speaker. After several iterations the actual mass acceleration profile begins to match the chosen profile it is told to "learn."

== Mechanics ==

The basic mechanical system for this device is a simple one, but must be assembled with precision. The major components are the speaker, linear ball bearings on a precision rod, and a spring. First, the speaker is mounted perpendicular to the ground. This must then be attached via a rod to the mass. We tried several approaches, but what seemed to be the best solution was to epoxy about a one inch section of PVC pipe to the center of the speaker. The diameter of the pipe we used matched the diameter of the junction in the speaker where the cone turns from concave to convex. This pipe also had two tapped holes running along the length of the section for a plate to attach to. The plate attached to this PVC also had a threaded hole in the center for the rod that attaches to the mass. The forces exerted by the speaker are small enough (our measurements show only about 3 Newtons) that only about an 8 ounce mass is needed. The bearing we used didn't require any additional mass to satisfy this constraint. The other end of the rod simply attached to the block which we machined and mounted atop the bearing. A piece of sheet metal was screwed into the other side of the block with spacers. This piece of metal is used to anchor spring to the mass, and allows the spring to easily be removed. A similar piece of sheet metal is attached to the wall on the opposite side of the spring. However, this sheet has a vertical slot about an eighth of an inch wide cut from the bottom. This allows the coil of the spring to slide up further on the plate, thereby creating a more solid connection.

It is important to design each component with all other components in mind at the same time. Mainly, making sure that the linear slide is level, and the rod attached to the speaker is centered, level, and in line with the mount on the mass and spring on the opposite side of the mass. This will help to ensure that all motion in the system is one dimensional.

The above was not the first iteration of our mechanical design. We originally had a homemade linear slide. However, we found the lack of precision resulted in unreliable bode plots of the system due to loose tolerances of the design creating side-to-side motion. The first iteration also had the rod epoxied directly to the mass and speaker. During initial testing the connection between the speaker and rod actually severed.

This current design is advantageous because it is modular. The threaded rod allows for minor distance changes to ensure the spring attached to the wall is at its natural rest length. To attach it the plate is detached from the PVC on the speaker and screwed onto the rod. With the spring detached, the other end of the rod is screwed into the threaded hole on the mass. Finally, the plate is then screwed into the PVC through the threaded holes. The non-permanent spring attachment also allows for springs with different k-values to be added to the system. If the spring is longer or shorter then desired, a simple change in rod length is all that is needed to incorporate the new spring into the system.

== Circuitry ==

== Programming ==
=== PIC Code ===
In our project, a PIC was used to drive the speaker via its I2C digital-to-analog converter and record accelerometer values at fixed intervals. Since the control system’s algorithm requires too much processing for the PIC, all the computations are performed in Matlab after the accelerometer data is transported to a computer via a serial cable. This setup simplified the program for the PIC.

To generate the waveform of voltage levels sent to the speaker, a single quantized period was used. Since the waveform is periodic in nature, the wave can be repeated indefinitely in a continuous fashion. The nature of our processing algorithm constrained the number of samples for the accelerometer data to be equal to the number of samples for the control voltage.

Since our system used a waveform of fixed intervals, we used an interrupt service routine (ISR) to change the wave and record accelerations at precise intervals. We chose to sample each signal every 1ms (as this is an achievable I2C speed and ISR). To oscillate our system at 10 and 20Hz, we needed at least 100 samples per waveform (1/10Hz / 1ms = 100 samples/waveform). For this reason, we created two 100-byte long vectors for the control voltage ‘u’, and the acceleration data ‘acc’.

[[Media:ME333_Learning_Oscillator_pic_main.c|'''PIC Learning Control''']]
[[Media:ME333_Learning_Oscillator_pic_bode.c|'''PIC Bode Plot Generator''']]

=== Matlab Code ===
The Matlab code simply follows the protocol as established above. The user specifies in Matlab the parameters for the amplitude and phase of the desired acceleration waveform. *Note that the frequencies of these waves are set to 10 and 20Hz (as constrained by the transfer functions captured from the Bode and the periodic nature of 100 samples/wave).

Below are the 4 m files used in Matlab. Their names must be changed to the last part of their filenames as they are functions.

[[Media:ME333_Learning_Oscillator_main.m|'''Main Matlab Loop''']]
[[Media:ME333_Learning_Oscillator_learn.m|'''Learning Control Algorithm''']]
[[Media:ME333_Learning_Oscillator_smooth.m|'''Smoothing Algorithm''']]
[[Media:ME333_Learning_Oscillator_startplot.m|'''Plot Initialization Code''']]
[[Media:ME333_Learning_Oscillator_bode.m|'''Bode Plot Generator''']]

=== Program Flow ===

[[Image:Oscillator_Program_Flow.jpg|center|thumb|400px|Program Flow]]

=== Control System ===
To “learn” the control voltages to create a desired waveform, a simple proportional control system was used. We should note much of this code was developed, tested and debugged by Tom Vose, who was invaluable to our final project. Below is our understanding of Tom’s control algorithm.

The system first guesses a control voltage of all zeros. This ideally results in no forcing of the speaker and a flat response of acceleration. After this initial guess, the program uses proportional control to match the desired acceleration waveform. Mathematically, it multiplies the error by a proportional factor k. The error is computed by subtracting the Fast Fourier Transform (fft) of the measured acceleration from the fft of the desired acceleration. This error is multiplied by the proportional control k, and two discrete Bode plot values corresponding to the transfer function of voltage to acceleration at 10 and 20Hz. The resulting signal is the control signal u, in the frequency domain. From here, the control signal is converted back to the time domain via an inverse fft, and sent to the PIC. All of the math is computed in discrete time, for the waveforms of 100 samples long. Below is a block diagram of this control system. Note that it is in the standard unity feedback form.

[[Image:Oscillator_Control_System.jpg|center|933x200 px|Learning Control System]]

== Results ==
Below are three tests performed on various superpositions of sin waves at 10 and 20Hz. We have adjusted the phase of the waves to produce different results.

<gallery Caption="Matlab Plots Acceleration Desired vs. Experimental Acceleration">
Image:Oscillator_test1.jpg|Wave 1
Image:Oscillator_test2.jpg|Wave 2
Image:Oscillator_test3.jpg|Wave 3
</gallery>

Each diagram, shows one period of an acceleration profile. The faint blue curve in the left subplot is the desired acceleration motion. The red lines on top of the blue curve are experimental accelerations as recorded by the pic. We can see that the red lines converge on top of the desired blue motion. The right subplot (green) shows the learned voltage waveform to create the desired acceleration profile.

Each wave follows the equation below with the given parameters:

acceleration_desired = amp1*sin(2*pi*base_freq*t+phi1) + amp2*sin(2*pi*(2*base_freq)*t+phi2)

Wave 1: phi1 = 1, phi2 = 2
Wave 2: phi1 = 0, phi2 = 0
Wave 3: phi1 = 1, phi2 = 0

== Potential Applications ==

A common question regarding this project is its applications to the real world. In the Northwestern University LIMS lab, a similar type of undertaking is being researched, but on a much grander scale. This same type of oscillation control is being done for 6 dimensions (X, Y, Z, Roll, Pitch, Yaw). However, the microprocessors used in this type of control are extremely expensive, and this one dimensional test of a learning system provides a possibly cheaper solution. The six dimensional control system has possible real-world applications in product assembly.

== Reflections ==
Great results were achieved from the learning algorithm. For engineers working on it in the future, here are some topics for further investigation to get a more complete understanding about the control system:

* In this project, the control signal was manually phase-shifted by pi radians before outputting it to the speaker
** This made the algorithm work perfectly
** It is not well-understood why this step was necessary
** The algorithm would not work otherwise

* In the input for the FFT, the transfer function used in this project did not have an imaginary component
** The robust algorithm still worked perfectly, and would shift phase and 'learn' when the program was run
** In future experiments, a transfer function including an imaginary term could be used, to fully utilize the capabilities of the algorithm

* Faster learning
** The various constants in the algorithm equations can be tweaked for faster learning
** Currently, it takes about 10-20 iterations to hit the desired waveform
** More rapid learning would be a huge benefit in real-world applications

== References ==
* [http://electronics.howstuffworks.com/speaker5.htm How speakers work]
* [[Iterative Learning Control]]
* Professor Kevin Lynch
* Tom Vose, author of the learning algorithm used in this project

Intelligent Oscillation Controller

2008-03-20T13:45:28Z

SandeepPrabhu: /* References */

== Team Members ==
'''Scott Mcleod:''' ''Electrical Engineering Class of 2009''

'''Brett Pihl:''' ''Mechanical Engineering Class of 2008''

'''Sandeep Prabhu:''' ''Mechanical Engineering Class of 2008
''

== Overview ==

The overall goal of this project is to create a system that induces a forcing function upon a basic, spring, mass, wall system to achieve an arbitrary periodic acceleration profile (a combination of a 10 and 20 Hz sine wave for our system) on the mass. An accelerometer is mounted upon the mass in the system. A PIC microprocessor records this acceleration data as well as controls a speaker (with the help of a DAC) that provides the external force to the system. This PIC communicates with MATLAB via Serial RS-232 communication. MATLAB processes this data and sends back a control signal for the speaker. After several iterations the actual mass acceleration profile begins to match the chosen profile it is told to "learn."

== Mechanics ==

The basic mechanical system for this device is a simple one, but must be assembled with precision. The major components are the speaker, linear ball bearings on a precision rod, and a spring. First, the speaker is mounted perpendicular to the ground. This must then be attached via a rod to the mass. We tried several approaches, but what seemed to be the best solution was to epoxy about a one inch section of PVC pipe to the center of the speaker. The diameter of the pipe we used matched the diameter of the junction in the speaker where the cone turns from concave to convex. This pipe also had two tapped holes running along the length of the section for a plate to attach to. The plate attached to this PVC also had a threaded hole in the center for the rod that attaches to the mass. The forces exerted by the speaker are small enough (our measurements show only about 3 Newtons) that only about an 8 ounce mass is needed. The bearing we used didn't require any additional mass to satisfy this constraint. The other end of the rod simply attached to the block which we machined and mounted atop the bearing. A piece of sheet metal was screwed into the other side of the block with spacers. This piece of metal is used to anchor spring to the mass, and allows the spring to easily be removed. A similar piece of sheet metal is attached to the wall on the opposite side of the spring. However, this sheet has a vertical slot about an eighth of an inch wide cut from the bottom. This allows the coil of the spring to slide up further on the plate, thereby creating a more solid connection.

It is important to design each component with all other components in mind at the same time. Mainly, making sure that the linear slide is level, and the rod attached to the speaker is centered, level, and in line with the mount on the mass and spring on the opposite side of the mass. This will help to ensure that all motion in the system is one dimensional.

The above was not the first iteration of our mechanical design. We originally had a homemade linear slide. However, we found the lack of precision resulted in unreliable bode plots of the system due to loose tolerances of the design creating side-to-side motion. The first iteration also had the rod epoxied directly to the mass and speaker. During initial testing the connection between the speaker and rod actually severed.

This current design is advantageous because it is modular. The threaded rod allows for minor distance changes to ensure the spring attached to the wall is at its natural rest length. To attach it the plate is detached from the PVC on the speaker and screwed onto the rod. With the spring detached, the other end of the rod is screwed into the threaded hole on the mass. Finally, the plate is then screwed into the PVC through the threaded holes. The non-permanent spring attachment also allows for springs with different k-values to be added to the system. If the spring is longer or shorter then desired, a simple change in rod length is all that is needed to incorporate the new spring into the system.

== Circuitry ==

== Programming ==
=== PIC Code ===
In our project, a PIC was used to drive the speaker via its I2C digital-to-analog converter and record accelerometer values at fixed intervals. Since the control system’s algorithm requires too much processing for the PIC, all the computations are performed in Matlab after the accelerometer data is transported to a computer via a serial cable. This setup simplified the program for the PIC.

To generate the waveform of voltage levels sent to the speaker, a single quantized period was used. Since the waveform is periodic in nature, the wave can be repeated indefinitely in a continuous fashion. The nature of our processing algorithm constrained the number of samples for the accelerometer data to be equal to the number of samples for the control voltage.

Since our system used a waveform of fixed intervals, we used an interrupt service routine (ISR) to change the wave and record accelerations at precise intervals. We chose to sample each signal every 1ms (as this is an achievable I2C speed and ISR). To oscillate our system at 10 and 20Hz, we needed at least 100 samples per waveform (1/10Hz / 1ms = 100 samples/waveform). For this reason, we created two 100-byte long vectors for the control voltage ‘u’, and the acceleration data ‘acc’.

[[Media:ME333_Learning_Oscillator_pic_main.c|'''PIC Learning Control''']]
[[Media:ME333_Learning_Oscillator_pic_bode.c|'''PIC Bode Plot Generator''']]

=== Matlab Code ===
The Matlab code simply follows the protocol as established above. The user specifies in Matlab the parameters for the amplitude and phase of the desired acceleration waveform. *Note that the frequencies of these waves are set to 10 and 20Hz (as constrained by the transfer functions captured from the Bode and the periodic nature of 100 samples/wave).

Below are the 4 m files used in Matlab. Their names must be changed to the last part of their filenames as they are functions.

[[Media:ME333_Learning_Oscillator_main.m|'''Main Matlab Loop''']]
[[Media:ME333_Learning_Oscillator_learn.m|'''Learning Control Algorithm''']]
[[Media:ME333_Learning_Oscillator_smooth.m|'''Smoothing Algorithm''']]
[[Media:ME333_Learning_Oscillator_startplot.m|'''Plot Initialization Code''']]
[[Media:ME333_Learning_Oscillator_bode.m|'''Bode Plot Generator''']]

=== Program Flow ===

[[Image:Oscillator_Program_Flow.jpg|center|thumb|400px|Program Flow]]

=== Control System ===
To “learn” the control voltages to create a desired waveform, a simple proportional control system was used. We should note much of this code was developed, tested and debugged by Tom Vose, who was invaluable to our final project. Below is our understanding of Tom’s control algorithm.

The system first guesses a control voltage of all zeros. This ideally results in no forcing of the speaker and a flat response of acceleration. After this initial guess, the program uses proportional control to match the desired acceleration waveform. Mathematically, it multiplies the error by a proportional factor k. The error is computed by subtracting the Fast Fourier Transform (fft) of the measured acceleration from the fft of the desired acceleration. This error is multiplied by the proportional control k, and two discrete Bode plot values corresponding to the transfer function of voltage to acceleration at 10 and 20Hz. The resulting signal is the control signal u, in the frequency domain. From here, the control signal is converted back to the time domain via an inverse fft, and sent to the PIC. All of the math is computed in discrete time, for the waveforms of 100 samples long. Below is a block diagram of this control system. Note that it is in the standard unity feedback form.

[[Image:Oscillator_Control_System.jpg|center|933x200 px|Learning Control System]]

== Results ==
Below are three tests performed on various superpositions of sin waves at 10 and 20Hz. We have adjusted the phase of the waves to produce different results.

<gallery Caption="Matlab Plots Acceleration Desired vs. Experimental Acceleration">
Image:Oscillator_test1.jpg|Wave 1
Image:Oscillator_test2.jpg|Wave 2
Image:Oscillator_test3.jpg|Wave 3
</gallery>

Each diagram, shows one period of an acceleration profile. The faint blue curve in the left subplot is the desired acceleration motion. The red lines on top of the blue curve are experimental accelerations as recorded by the pic. We can see that the red lines converge on top of the desired blue motion. The right subplot (green) shows the learned voltage waveform to create the desired acceleration profile.

Each wave follows the equation below with the given parameters:

acceleration_desired = amp1*sin(2*pi*base_freq*t+phi1) + amp2*sin(2*pi*(2*base_freq)*t+phi2)

Wave 1: phi1 = 1, phi2 = 2
Wave 2: phi1 = 0, phi2 = 0
Wave 3: phi1 = 1, phi2 = 0

== Potential Applications ==

A common question regarding this project is its applications to the real world. In the Northwestern University LIMS lab, a similar type of undertaking is being researched, but on a much grander scale. This same type of oscillation control is being done for 6 dimensions (X, Y, Z, Roll, Pitch, Yaw). However, the microprocessors used in this type of control are extremely expensive, and this one dimensional test of a learning system provides a possibly cheaper solution. The six dimensional control system has possible real-world applications in product assembly.

== Reflections ==

== References ==
* [http://electronics.howstuffworks.com/speaker5.htm How speakers work]
* [[Iterative Learning Control]]
* Professor Kevin Lynch
* Tom Vose, author of the learning algorithm used in this project

Intelligent Oscillation Controller

2008-03-20T13:43:31Z

SandeepPrabhu: /* References */

== Team Members ==
'''Scott Mcleod:''' ''Electrical Engineering Class of 2009''

'''Brett Pihl:''' ''Mechanical Engineering Class of 2008''

'''Sandeep Prabhu:''' ''Mechanical Engineering Class of 2008
''

== Overview ==

The overall goal of this project is to create a system that induces a forcing function upon a basic, spring, mass, wall system to achieve an arbitrary periodic acceleration profile (a combination of a 10 and 20 Hz sine wave for our system) on the mass. An accelerometer is mounted upon the mass in the system. A PIC microprocessor records this acceleration data as well as controls a speaker (with the help of a DAC) that provides the external force to the system. This PIC communicates with MATLAB via Serial RS-232 communication. MATLAB processes this data and sends back a control signal for the speaker. After several iterations the actual mass acceleration profile begins to match the chosen profile it is told to "learn."

== Mechanics ==

The basic mechanical system for this device is a simple one, but must be assembled with precision. The major components are the speaker, linear ball bearings on a precision rod, and a spring. First, the speaker is mounted perpendicular to the ground. This must then be attached via a rod to the mass. We tried several approaches, but what seemed to be the best solution was to epoxy about a one inch section of PVC pipe to the center of the speaker. The diameter of the pipe we used matched the diameter of the junction in the speaker where the cone turns from concave to convex. This pipe also had two tapped holes running along the length of the section for a plate to attach to. The plate attached to this PVC also had a threaded hole in the center for the rod that attaches to the mass. The forces exerted by the speaker are small enough (our measurements show only about 3 Newtons) that only about an 8 ounce mass is needed. The bearing we used didn't require any additional mass to satisfy this constraint. The other end of the rod simply attached to the block which we machined and mounted atop the bearing. A piece of sheet metal was screwed into the other side of the block with spacers. This piece of metal is used to anchor spring to the mass, and allows the spring to easily be removed. A similar piece of sheet metal is attached to the wall on the opposite side of the spring. However, this sheet has a vertical slot about an eighth of an inch wide cut from the bottom. This allows the coil of the spring to slide up further on the plate, thereby creating a more solid connection.

It is important to design each component with all other components in mind at the same time. Mainly, making sure that the linear slide is level, and the rod attached to the speaker is centered, level, and in line with the mount on the mass and spring on the opposite side of the mass. This will help to ensure that all motion in the system is one dimensional.

The above was not the first iteration of our mechanical design. We originally had a homemade linear slide. However, we found the lack of precision resulted in unreliable bode plots of the system due to loose tolerances of the design creating side-to-side motion. The first iteration also had the rod epoxied directly to the mass and speaker. During initial testing the connection between the speaker and rod actually severed.

This current design is advantageous because it is modular. The threaded rod allows for minor distance changes to ensure the spring attached to the wall is at its natural rest length. To attach it the plate is detached from the PVC on the speaker and screwed onto the rod. With the spring detached, the other end of the rod is screwed into the threaded hole on the mass. Finally, the plate is then screwed into the PVC through the threaded holes. The non-permanent spring attachment also allows for springs with different k-values to be added to the system. If the spring is longer or shorter then desired, a simple change in rod length is all that is needed to incorporate the new spring into the system.

== Circuitry ==

== Programming ==
=== PIC Code ===
In our project, a PIC was used to drive the speaker via its I2C digital-to-analog converter and record accelerometer values at fixed intervals. Since the control system’s algorithm requires too much processing for the PIC, all the computations are performed in Matlab after the accelerometer data is transported to a computer via a serial cable. This setup simplified the program for the PIC.

To generate the waveform of voltage levels sent to the speaker, a single quantized period was used. Since the waveform is periodic in nature, the wave can be repeated indefinitely in a continuous fashion. The nature of our processing algorithm constrained the number of samples for the accelerometer data to be equal to the number of samples for the control voltage.

Since our system used a waveform of fixed intervals, we used an interrupt service routine (ISR) to change the wave and record accelerations at precise intervals. We chose to sample each signal every 1ms (as this is an achievable I2C speed and ISR). To oscillate our system at 10 and 20Hz, we needed at least 100 samples per waveform (1/10Hz / 1ms = 100 samples/waveform). For this reason, we created two 100-byte long vectors for the control voltage ‘u’, and the acceleration data ‘acc’.

[[Media:ME333_Learning_Oscillator_pic_main.c|'''PIC Learning Control''']]
[[Media:ME333_Learning_Oscillator_pic_bode.c|'''PIC Bode Plot Generator''']]

=== Matlab Code ===
The Matlab code simply follows the protocol as established above. The user specifies in Matlab the parameters for the amplitude and phase of the desired acceleration waveform. *Note that the frequencies of these waves are set to 10 and 20Hz (as constrained by the transfer functions captured from the Bode and the periodic nature of 100 samples/wave).

Below are the 4 m files used in Matlab. Their names must be changed to the last part of their filenames as they are functions.

[[Media:ME333_Learning_Oscillator_main.m|'''Main Matlab Loop''']]
[[Media:ME333_Learning_Oscillator_learn.m|'''Learning Control Algorithm''']]
[[Media:ME333_Learning_Oscillator_smooth.m|'''Smoothing Algorithm''']]
[[Media:ME333_Learning_Oscillator_startplot.m|'''Plot Initialization Code''']]
[[Media:ME333_Learning_Oscillator_bode.m|'''Bode Plot Generator''']]

=== Program Flow ===

[[Image:Oscillator_Program_Flow.jpg|center|thumb|400px|Program Flow]]

=== Control System ===
To “learn” the control voltages to create a desired waveform, a simple proportional control system was used. We should note much of this code was developed, tested and debugged by Tom Vose, who was invaluable to our final project. Below is our understanding of Tom’s control algorithm.

The system first guesses a control voltage of all zeros. This ideally results in no forcing of the speaker and a flat response of acceleration. After this initial guess, the program uses proportional control to match the desired acceleration waveform. Mathematically, it multiplies the error by a proportional factor k. The error is computed by subtracting the Fast Fourier Transform (fft) of the measured acceleration from the fft of the desired acceleration. This error is multiplied by the proportional control k, and two discrete Bode plot values corresponding to the transfer function of voltage to acceleration at 10 and 20Hz. The resulting signal is the control signal u, in the frequency domain. From here, the control signal is converted back to the time domain via an inverse fft, and sent to the PIC. All of the math is computed in discrete time, for the waveforms of 100 samples long. Below is a block diagram of this control system. Note that it is in the standard unity feedback form.

[[Image:Oscillator_Control_System.jpg|center|933x200 px|Learning Control System]]

== Results ==
Below are three tests performed on various superpositions of sin waves at 10 and 20Hz. We have adjusted the phase of the waves to produce different results.

<gallery Caption="Matlab Plots Acceleration Desired vs. Experimental Acceleration">
Image:Oscillator_test1.jpg|Wave 1
Image:Oscillator_test2.jpg|Wave 2
Image:Oscillator_test3.jpg|Wave 3
</gallery>

Each diagram, shows one period of an acceleration profile. The faint blue curve in the left subplot is the desired acceleration motion. The red lines on top of the blue curve are experimental accelerations as recorded by the pic. We can see that the red lines converge on top of the desired blue motion. The right subplot (green) shows the learned voltage waveform to create the desired acceleration profile.

Each wave follows the equation below with the given parameters:

acceleration_desired = amp1*sin(2*pi*base_freq*t+phi1) + amp2*sin(2*pi*(2*base_freq)*t+phi2)

Wave 1: phi1 = 1, phi2 = 2
Wave 2: phi1 = 0, phi2 = 0
Wave 3: phi1 = 1, phi2 = 0

== Potential Applications ==

A common question regarding this project is its applications to the real world. In the Northwestern University LIMS lab, a similar type of undertaking is being researched, but on a much grander scale. This same type of oscillation control is being done for 6 dimensions (X, Y, Z, Roll, Pitch, Yaw). However, the microprocessors used in this type of control are extremely expensive, and this one dimensional test of a learning system provides a possibly cheaper solution. The six dimensional control system has possible real-world applications in product assembly.

== Reflections ==

== References ==
* [How speakers work]
* [[Iterative Learning Control]]
* Professor Kevin Lynch
* Tom Vose, author of the learning algorithm used in this project

Intelligent Oscillation Controller

2008-03-20T13:42:30Z

SandeepPrabhu: /* References */

== Team Members ==
'''Scott Mcleod:''' ''Electrical Engineering Class of 2009''

'''Brett Pihl:''' ''Mechanical Engineering Class of 2008''

'''Sandeep Prabhu:''' ''Mechanical Engineering Class of 2008
''

== Overview ==

The overall goal of this project is to create a system that induces a forcing function upon a basic, spring, mass, wall system to achieve an arbitrary periodic acceleration profile (a combination of a 10 and 20 Hz sine wave for our system) on the mass. An accelerometer is mounted upon the mass in the system. A PIC microprocessor records this acceleration data as well as controls a speaker (with the help of a DAC) that provides the external force to the system. This PIC communicates with MATLAB via Serial RS-232 communication. MATLAB processes this data and sends back a control signal for the speaker. After several iterations the actual mass acceleration profile begins to match the chosen profile it is told to "learn."

== Mechanics ==

The basic mechanical system for this device is a simple one, but must be assembled with precision. The major components are the speaker, linear ball bearings on a precision rod, and a spring. First, the speaker is mounted perpendicular to the ground. This must then be attached via a rod to the mass. We tried several approaches, but what seemed to be the best solution was to epoxy about a one inch section of PVC pipe to the center of the speaker. The diameter of the pipe we used matched the diameter of the junction in the speaker where the cone turns from concave to convex. This pipe also had two tapped holes running along the length of the section for a plate to attach to. The plate attached to this PVC also had a threaded hole in the center for the rod that attaches to the mass. The forces exerted by the speaker are small enough (our measurements show only about 3 Newtons) that only about an 8 ounce mass is needed. The bearing we used didn't require any additional mass to satisfy this constraint. The other end of the rod simply attached to the block which we machined and mounted atop the bearing. A piece of sheet metal was screwed into the other side of the block with spacers. This piece of metal is used to anchor spring to the mass, and allows the spring to easily be removed. A similar piece of sheet metal is attached to the wall on the opposite side of the spring. However, this sheet has a vertical slot about an eighth of an inch wide cut from the bottom. This allows the coil of the spring to slide up further on the plate, thereby creating a more solid connection.

It is important to design each component with all other components in mind at the same time. Mainly, making sure that the linear slide is level, and the rod attached to the speaker is centered, level, and in line with the mount on the mass and spring on the opposite side of the mass. This will help to ensure that all motion in the system is one dimensional.

The above was not the first iteration of our mechanical design. We originally had a homemade linear slide. However, we found the lack of precision resulted in unreliable bode plots of the system due to loose tolerances of the design creating side-to-side motion. The first iteration also had the rod epoxied directly to the mass and speaker. During initial testing the connection between the speaker and rod actually severed.

This current design is advantageous because it is modular. The threaded rod allows for minor distance changes to ensure the spring attached to the wall is at its natural rest length. To attach it the plate is detached from the PVC on the speaker and screwed onto the rod. With the spring detached, the other end of the rod is screwed into the threaded hole on the mass. Finally, the plate is then screwed into the PVC through the threaded holes. The non-permanent spring attachment also allows for springs with different k-values to be added to the system. If the spring is longer or shorter then desired, a simple change in rod length is all that is needed to incorporate the new spring into the system.

== Circuitry ==

== Programming ==
=== PIC Code ===
In our project, a PIC was used to drive the speaker via its I2C digital-to-analog converter and record accelerometer values at fixed intervals. Since the control system’s algorithm requires too much processing for the PIC, all the computations are performed in Matlab after the accelerometer data is transported to a computer via a serial cable. This setup simplified the program for the PIC.

To generate the waveform of voltage levels sent to the speaker, a single quantized period was used. Since the waveform is periodic in nature, the wave can be repeated indefinitely in a continuous fashion. The nature of our processing algorithm constrained the number of samples for the accelerometer data to be equal to the number of samples for the control voltage.

Since our system used a waveform of fixed intervals, we used an interrupt service routine (ISR) to change the wave and record accelerations at precise intervals. We chose to sample each signal every 1ms (as this is an achievable I2C speed and ISR). To oscillate our system at 10 and 20Hz, we needed at least 100 samples per waveform (1/10Hz / 1ms = 100 samples/waveform). For this reason, we created two 100-byte long vectors for the control voltage ‘u’, and the acceleration data ‘acc’.

[[Media:ME333_Learning_Oscillator_pic_main.c|'''PIC Learning Control''']]
[[Media:ME333_Learning_Oscillator_pic_bode.c|'''PIC Bode Plot Generator''']]

=== Matlab Code ===
The Matlab code simply follows the protocol as established above. The user specifies in Matlab the parameters for the amplitude and phase of the desired acceleration waveform. *Note that the frequencies of these waves are set to 10 and 20Hz (as constrained by the transfer functions captured from the Bode and the periodic nature of 100 samples/wave).

Below are the 4 m files used in Matlab. Their names must be changed to the last part of their filenames as they are functions.

[[Media:ME333_Learning_Oscillator_main.m|'''Main Matlab Loop''']]
[[Media:ME333_Learning_Oscillator_learn.m|'''Learning Control Algorithm''']]
[[Media:ME333_Learning_Oscillator_smooth.m|'''Smoothing Algorithm''']]
[[Media:ME333_Learning_Oscillator_startplot.m|'''Plot Initialization Code''']]
[[Media:ME333_Learning_Oscillator_bode.m|'''Bode Plot Generator''']]

=== Program Flow ===

[[Image:Oscillator_Program_Flow.jpg|center|thumb|400px|Program Flow]]

=== Control System ===
To “learn” the control voltages to create a desired waveform, a simple proportional control system was used. We should note much of this code was developed, tested and debugged by Tom Vose, who was invaluable to our final project. Below is our understanding of Tom’s control algorithm.

The system first guesses a control voltage of all zeros. This ideally results in no forcing of the speaker and a flat response of acceleration. After this initial guess, the program uses proportional control to match the desired acceleration waveform. Mathematically, it multiplies the error by a proportional factor k. The error is computed by subtracting the Fast Fourier Transform (fft) of the measured acceleration from the fft of the desired acceleration. This error is multiplied by the proportional control k, and two discrete Bode plot values corresponding to the transfer function of voltage to acceleration at 10 and 20Hz. The resulting signal is the control signal u, in the frequency domain. From here, the control signal is converted back to the time domain via an inverse fft, and sent to the PIC. All of the math is computed in discrete time, for the waveforms of 100 samples long. Below is a block diagram of this control system. Note that it is in the standard unity feedback form.

[[Image:Oscillator_Control_System.jpg|center|933x200 px|Learning Control System]]

== Results ==
Below are three tests performed on various superpositions of sin waves at 10 and 20Hz. We have adjusted the phase of the waves to produce different results.

<gallery Caption="Matlab Plots Acceleration Desired vs. Experimental Acceleration">
Image:Oscillator_test1.jpg|Wave 1
Image:Oscillator_test2.jpg|Wave 2
Image:Oscillator_test3.jpg|Wave 3
</gallery>

Each diagram, shows one period of an acceleration profile. The faint blue curve in the left subplot is the desired acceleration motion. The red lines on top of the blue curve are experimental accelerations as recorded by the pic. We can see that the red lines converge on top of the desired blue motion. The right subplot (green) shows the learned voltage waveform to create the desired acceleration profile.

Each wave follows the equation below with the given parameters:

acceleration_desired = amp1*sin(2*pi*base_freq*t+phi1) + amp2*sin(2*pi*(2*base_freq)*t+phi2)

Wave 1: phi1 = 1, phi2 = 2
Wave 2: phi1 = 0, phi2 = 0
Wave 3: phi1 = 1, phi2 = 0

== Potential Applications ==

A common question regarding this project is its applications to the real world. In the Northwestern University LIMS lab, a similar type of undertaking is being researched, but on a much grander scale. This same type of oscillation control is being done for 6 dimensions (X, Y, Z, Roll, Pitch, Yaw). However, the microprocessors used in this type of control are extremely expensive, and this one dimensional test of a learning system provides a possibly cheaper solution. The six dimensional control system has possible real-world applications in product assembly.

== Reflections ==

== References ==
* [[How speakers work]]
* [[Iterative Learning Control]]
* Professor Kevin Lynch
* Tom Vose, author of the learning algorithm used in this project

File:Iterative Learning Control

2008-03-20T13:38:38Z

SandeepPrabhu:

Intelligent Oscillation Controller

2008-03-20T13:37:57Z

SandeepPrabhu: /* References */

== Team Members ==
'''Scott Mcleod:''' ''Electrical Engineering Class of 2009''

'''Brett Pihl:''' ''Mechanical Engineering Class of 2008''

'''Sandeep Prabhu:''' ''Mechanical Engineering Class of 2008
''

== Overview ==

The overall goal of this project is to create a system that induces a forcing function upon a basic, spring, mass, wall system to achieve an arbitrary periodic acceleration profile (a combination of a 10 and 20 Hz sine wave for our system) on the mass. An accelerometer is mounted upon the mass in the system. A PIC microprocessor records this acceleration data as well as controls a speaker (with the help of a DAC) that provides the external force to the system. This PIC communicates with MATLAB via Serial RS-232 communication. MATLAB processes this data and sends back a control signal for the speaker. After several iterations the actual mass acceleration profile begins to match the chosen profile it is told to "learn."

== Mechanics ==

The basic mechanical system for this device is a simple one, but must be assembled with precision. The major components are the speaker, linear ball bearings on a precision rod, and a spring. First, the speaker is mounted perpendicular to the ground. This must then be attached via a rod to the mass. We tried several approaches, but what seemed to be the best solution was to epoxy about a one inch section of PVC pipe to the center of the speaker. The diameter of the pipe we used matched the diameter of the junction in the speaker where the cone turns from concave to convex. This pipe also had two tapped holes running along the length of the section for a plate to attach to. The plate attached to this PVC also had a threaded hole in the center for the rod that attaches to the mass. The forces exerted by the speaker are small enough (our measurements show only about 3 Newtons) that only about an 8 ounce mass is needed. The bearing we used didn't require any additional mass to satisfy this constraint. The other end of the rod simply attached to the block which we machined and mounted atop the bearing. A piece of sheet metal was screwed into the other side of the block with spacers. This piece of metal is used to anchor spring to the mass, and allows the spring to easily be removed. A similar piece of sheet metal is attached to the wall on the opposite side of the spring. However, this sheet has a vertical slot about an eighth of an inch wide cut from the bottom. This allows the coil of the spring to slide up further on the plate, thereby creating a more solid connection.

It is important to design each component with all other components in mind at the same time. Mainly, making sure that the linear slide is level, and the rod attached to the speaker is centered, level, and in line with the mount on the mass and spring on the opposite side of the mass. This will help to ensure that all motion in the system is one dimensional.

The above was not the first iteration of our mechanical design. We originally had a homemade linear slide. However, we found the lack of precision resulted in unreliable bode plots of the system due to loose tolerances of the design creating side-to-side motion. The first iteration also had the rod epoxied directly to the mass and speaker. During initial testing the connection between the speaker and rod actually severed.

This current design is advantageous because it is modular. The threaded rod allows for minor distance changes to ensure the spring attached to the wall is at its natural rest length. To attach it the plate is detached from the PVC on the speaker and screwed onto the rod. With the spring detached, the other end of the rod is screwed into the threaded hole on the mass. Finally, the plate is then screwed into the PVC through the threaded holes. The non-permanent spring attachment also allows for springs with different k-values to be added to the system. If the spring is longer or shorter then desired, a simple change in rod length is all that is needed to incorporate the new spring into the system.

== Circuitry ==

== Programming ==
=== PIC Code ===
In our project, a PIC was used to drive the speaker via its I2C digital-to-analog converter and record accelerometer values at fixed intervals. Since the control system’s algorithm requires too much processing for the PIC, all the computations are performed in Matlab after the accelerometer data is transported to a computer via a serial cable. This setup simplified the program for the PIC.

To generate the waveform of voltage levels sent to the speaker, a single quantized period was used. Since the waveform is periodic in nature, the wave can be repeated indefinitely in a continuous fashion. The nature of our processing algorithm constrained the number of samples for the accelerometer data to be equal to the number of samples for the control voltage.

Since our system used a waveform of fixed intervals, we used an interrupt service routine (ISR) to change the wave and record accelerations at precise intervals. We chose to sample each signal every 1ms (as this is an achievable I2C speed and ISR). To oscillate our system at 10 and 20Hz, we needed at least 100 samples per waveform (1/10Hz / 1ms = 100 samples/waveform). For this reason, we created two 100-byte long vectors for the control voltage ‘u’, and the acceleration data ‘acc’.

[[Media:ME333_Learning_Oscillator_pic_main.c|'''PIC Learning Control''']]
[[Media:ME333_Learning_Oscillator_pic_bode.c|'''PIC Bode Plot Generator''']]

=== Matlab Code ===
The Matlab code simply follows the protocol as established above. The user specifies in Matlab the parameters for the amplitude and phase of the desired acceleration waveform. *Note that the frequencies of these waves are set to 10 and 20Hz (as constrained by the transfer functions captured from the Bode and the periodic nature of 100 samples/wave).

Below are the 4 m files used in Matlab. Their names must be changed to the last part of their filenames as they are functions.

[[Media:ME333_Learning_Oscillator_main.m|'''Main Matlab Loop''']]
[[Media:ME333_Learning_Oscillator_learn.m|'''Learning Control Algorithm''']]
[[Media:ME333_Learning_Oscillator_smooth.m|'''Smoothing Algorithm''']]
[[Media:ME333_Learning_Oscillator_startplot.m|'''Plot Initialization Code''']]
[[Media:ME333_Learning_Oscillator_bode.m|'''Bode Plot Generator''']]

=== Program Flow ===

[[Image:Oscillator_Program_Flow.jpg|center|thumb|400px|Program Flow]]

=== Control System ===
To “learn” the control voltages to create a desired waveform, a simple proportional control system was used. We should note much of this code was developed, tested and debugged by Tom Vose, who was invaluable to our final project. Below is our understanding of Tom’s control algorithm.

The system first guesses a control voltage of all zeros. This ideally results in no forcing of the speaker and a flat response of acceleration. After this initial guess, the program uses proportional control to match the desired acceleration waveform. Mathematically, it multiplies the error by a proportional factor k. The error is computed by subtracting the Fast Fourier Transform (fft) of the measured acceleration from the fft of the desired acceleration. This error is multiplied by the proportional control k, and two discrete Bode plot values corresponding to the transfer function of voltage to acceleration at 10 and 20Hz. The resulting signal is the control signal u, in the frequency domain. From here, the control signal is converted back to the time domain via an inverse fft, and sent to the PIC. All of the math is computed in discrete time, for the waveforms of 100 samples long. Below is a block diagram of this control system. Note that it is in the standard unity feedback form.

[[Image:Oscillator_Control_System.jpg|center|933x200 px|Learning Control System]]

== Results ==
Below are three tests performed on various superpositions of sin waves at 10 and 20Hz. We have adjusted the phase of the waves to produce different results.

<gallery Caption="Matlab Plots Acceleration Desired vs. Experimental Acceleration">
Image:Oscillator_test1.jpg|Wave 1
Image:Oscillator_test2.jpg|Wave 2
Image:Oscillator_test3.jpg|Wave 3
</gallery>

Each diagram, shows one period of an acceleration profile. The faint blue curve in the left subplot is the desired acceleration motion. The red lines on top of the blue curve are experimental accelerations as recorded by the pic. We can see that the red lines converge on top of the desired blue motion. The right subplot (green) shows the learned voltage waveform to create the desired acceleration profile.

Each wave follows the equation below with the given parameters:

acceleration_desired = amp1*sin(2*pi*base_freq*t+phi1) + amp2*sin(2*pi*(2*base_freq)*t+phi2)

Wave 1: phi1 = 1, phi2 = 2
Wave 2: phi1 = 0, phi2 = 0
Wave 3: phi1 = 1, phi2 = 0

== Potential Applications ==

A common question regarding this project is its applications to the real world. In the Northwestern University LIMS lab, a similar type of undertaking is being researched, but on a much grander scale. This same type of oscillation control is being done for 6 dimensions (X, Y, Z, Roll, Pitch, Yaw). However, the microprocessors used in this type of control are extremely expensive, and this one dimensional test of a learning system provides a possibly cheaper solution. The six dimensional control system has possible real-world applications in product assembly.

== Reflections ==

== References ==
1. [How speakers work]
2. [[Media:Iterative Learning Control]]
3. Professor Kevin Lynch
4. Tom Vose, author of the learning algorithm used in this project

ME 333 final projects

2008-03-08T20:02:25Z

SandeepPrabhu: /* Frequency Learner */

[[ME 333 end of course schedule]]

__TOC__

== ME 333 Final Projects 2008 ==

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

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

The IR Tracker detects the position of an infrared emitter in two axises, and orients itself to line up with the emitter.

 

=== [[Project Title 2]] ===

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

Here are a few words describing your project, just a teaser to go with the picture at the side.

 

=== [[Learning Oscillator]] ===

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

The Learning Oscillator is given a desired acceleration profile for a linear oscillating mass. It then 'learns' and adjusts the frequency of its force source so the oscillating mass eventually matches the desired acceleration profile.

ME 333 final projects

2008-03-08T19:55:52Z

SandeepPrabhu: /* ME 333 Final Projects 2008 */

[[ME 333 end of course schedule]]

__TOC__

== ME 333 Final Projects 2008 ==

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

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

The IR Tracker detects the position of an infrared emitter in two axises, and orients itself to line up with the emitter.

 

=== [[Project Title 2]] ===

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

Here are a few words describing your project, just a teaser to go with the picture at the side.

 

=== [[Frequency Learner]] ===

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

The Frequency Learner controls the force source of a linear oscillator so the actual frequency of the oscillating mass matches a desired frequency profile.

Serial communication with Matlab

2008-02-06T02:18:20Z

SandeepPrabhu: /* Overview */

== Original Assignment ==

Matlab has a "serial" function that allows it to communicate through a serial port. This project is to establish serial port connection with the PIC and demonstrate bidirectional communication between the PIC and a Matlab program, using, for example, a USB to RS232 adapter and level shifter chip. The Matlab program could simply log data from the PIC (e.g., the angle of a potentiometer knob), or plot it on a user interface in real time. Keystrokes from the user of the Matlab program should be obviously received by the PIC, perhaps by lighting the LEDs on the PIC board.

== Overview ==
Matlab has a "serial" function that allows it to communicate through a serial port. This project is to establish serial port connection with the PIC and demonstrate bidirectional communication between the PIC and a Matlab program. To demonstrate this, the PIC will send potentiometer readings to Matlab as well as receive keystrokes from the Matlab user to light up LEDs on its circuit board.

A USB to RS232 adapter and level shifter chip were used to hook up the computer to the PIC. A level shifter is necessary because the power/ground voltages are different for the desktop computer and the PIC. An RS232 plug looks like this: http://www.aggsoft.com/rs232-pinout-cable/serial-cable-connections.htm

The RS232 was wired to our level shifter to convert the voltages, and then the level shifter was wired to our PIC. Refer to the Circuit section for details.

First, the PIC was stamped with our C code (Refer to PIC Code below). It was programmed to read the potentiometer readings from its ADC (Analog to Digital Convertor) port and transmit the digitized readings through the RS232 cables to Matlab. If the Matlab user typed a character, the PIC was also programmed to display the character on its LED array. (8 on/off LEDs represent the 1 byte binary equivalent of any character). In real-time, Matlab would display the potentiometer reading from the PIC and the PIC LEDs would display the keystroke from the user.

== Circuit ==

== PIC Code ==

/*
SerialComm.c Scott McLeod, Sandeep Prabhu, Brett Pihl 2/4/2008
This program is designed to communicate to a computer using RS232 (Serial) Communication.

The main loop of this program waits for a data transmission over the Serial port, and
responds with a current reading of an analog input (potentiometer) and the last received data.

Note the analog input is only for testing purposes, and is not necessary for serial communication.
Lines unnecessary for RS232 communication are commented with enclosing asterisks ('*..*').
*/

#include <18f4520.h>

#fuses HS,NOLVP,NOWDT,NOPROTECT
#DEVICE ADC=8 // *set ADC to 8 bit accuracy*
#use delay(clock=20000000) // 20 MHz clock
#use rs232(baud=19200, UART1) // Set up PIC UART on RC6 (tx) and RC7 (rx)

int8 data_tx, data_rx = 0; // Set up data_tx (transmit value), data_rx (recieve value)

void main()
{
setup_adc_ports(AN0); // *Enable AN0 as analog potentiometer input*
setup_adc(ADC_CLOCK_INTERNAL); // *the range selected has to start with AN0*
set_adc_channel(0); // *Enable AN0 as analog input*
delay_us(10); // *Pause 10us to set up ADC*

while (TRUE)
{
data_tx = read_adc(); // *Read POT on analog port (0-255)*
output_d(data_rx); // Output last recieved value from computer
delay_ms(10);

if (kbhit()) // If PIC senses data pushed to serial buffer
{
data_rx = fgetc(); // Read in recieved value from buffer
printf("Pot: %u Char: %u\n", data_tx, data_rx); // Once data sent and read, PIC sends data back
delay_ms(100);
}
}
}

== Matlab Code ==
% SerialComm.m Scott McLeod, Sandeep Prabhu, Brett Pihl 2/4/2008
% This program is designed to communicate to a PIC 18F4520 via RS232 (Serial) Communication.
%
% The main loop of this program waits for a character input from the user,
% upon which it transmits the ascii value and waits for data to be written.

s = serial('COM14','BAUD',19200); % Create serial object (PORT Dependent)
fopen(s) % Open the serial port for r/w

myChar = 'a';
prompt = 'Enter a character (q to exit): ';

while (myChar ~= 'q') % While user hasn't typed 'q'
myChar = input(prompt, 's'); % Get user input
fprintf(s, '%s', myChar(1)) % Write first char of user input to serial port
fprintf(fscanf(s)) % Read Data back from PIC
end

fclose(s); % Close the serial port
delete(s); % Delete the serial object

'''If your program doesn't close and delete the serial port object correctly, you can use the command shown below to delete all of the serial port objects.'''

delete(instrfind)

Serial communication with Matlab

2008-02-06T02:14:34Z

SandeepPrabhu: /* Overview */

== Original Assignment ==

Matlab has a "serial" function that allows it to communicate through a serial port. This project is to establish serial port connection with the PIC and demonstrate bidirectional communication between the PIC and a Matlab program, using, for example, a USB to RS232 adapter and level shifter chip. The Matlab program could simply log data from the PIC (e.g., the angle of a potentiometer knob), or plot it on a user interface in real time. Keystrokes from the user of the Matlab program should be obviously received by the PIC, perhaps by lighting the LEDs on the PIC board.

== Overview ==
Matlab has a "serial" function that allows it to communicate through a serial port. This project is to establish serial port connection with the PIC and demonstrate bidirectional communication between the PIC and a Matlab program. To demonstrate this, the PIC will send potentiometer readings to Matlab as well as receive keystrokes from the Matlab user to light up LEDs on its circuit board.

A USB to RS232 adapter and level shifter chip were used to hook up the computer to the PIC. A level shifter is necessary because the power/ground voltages are different for the desktop computer and the PIC. An RS232 plug looks like this: http://www.aggsoft.com/rs232-pinout-cable/serial-cable-connections.htm

The RS232 was wired to our level shifter to convert the voltages, and then the level shifter was wired to our PIC. Refer to the Circuit section for details.

First, we stamped the PIC with our C code (Refer to PIC Code below). It was programmed to read the potentiometer readings from its ADC (Analog to Digital Convertor) port and transmit the digitized readings through the RS232 cables to Matlab. If the Matlab user typed a character, the PIC was also programmed to display the character on its LED array. (8 on/off LEDs represent the 1 byte binary equivalent of any character)

In this way, Serial communication between a PIC and Matlab was demonstrated.

== Circuit ==

== PIC Code ==

/*
SerialComm.c Scott McLeod, Sandeep Prabhu, Brett Pihl 2/4/2008
This program is designed to communicate to a computer using RS232 (Serial) Communication.

The main loop of this program waits for a data transmission over the Serial port, and
responds with a current reading of an analog input (potentiometer) and the last received data.

Note the analog input is only for testing purposes, and is not necessary for serial communication.
Lines unnecessary for RS232 communication are commented with enclosing asterisks ('*..*').
*/

#include <18f4520.h>

#fuses HS,NOLVP,NOWDT,NOPROTECT
#DEVICE ADC=8 // *set ADC to 8 bit accuracy*
#use delay(clock=20000000) // 20 MHz clock
#use rs232(baud=19200, UART1) // Set up PIC UART on RC6 (tx) and RC7 (rx)

int8 data_tx, data_rx = 0; // Set up data_tx (transmit value), data_rx (recieve value)

void main()
{
setup_adc_ports(AN0); // *Enable AN0 as analog potentiometer input*
setup_adc(ADC_CLOCK_INTERNAL); // *the range selected has to start with AN0*
set_adc_channel(0); // *Enable AN0 as analog input*
delay_us(10); // *Pause 10us to set up ADC*

while (TRUE)
{
data_tx = read_adc(); // *Read POT on analog port (0-255)*
output_d(data_rx); // Output last recieved value from computer
delay_ms(10);

if (kbhit()) // If PIC senses data pushed to serial buffer
{
data_rx = fgetc(); // Read in recieved value from buffer
printf("Pot: %u Char: %u\n", data_tx, data_rx); // Once data sent and read, PIC sends data back
delay_ms(100);
}
}
}

== Matlab Code ==
% SerialComm.m Scott McLeod, Sandeep Prabhu, Brett Pihl 2/4/2008
% This program is designed to communicate to a PIC 18F4520 via RS232 (Serial) Communication.
%
% The main loop of this program waits for a character input from the user,
% upon which it transmits the ascii value and waits for data to be written.

s = serial('COM14','BAUD',19200); % Create serial object (PORT Dependent)
fopen(s) % Open the serial port for r/w

myChar = 'a';
prompt = 'Enter a character (q to exit): ';

while (myChar ~= 'q') % While user hasn't typed 'q'
myChar = input(prompt, 's'); % Get user input
fprintf(s, '%s', myChar(1)) % Write first char of user input to serial port
fprintf(fscanf(s)) % Read Data back from PIC
end

fclose(s); % Close the serial port
delete(s); % Delete the serial object

'''If your program doesn't close and delete the serial port object correctly, you can use the command shown below to delete all of the serial port objects.'''

delete(instrfind)