ECE 4760: Laboratory 4

Tachometer and motor controller

You will build a digital tachometer which displays motor speed on a LCD display and controls the motor with user-selectable parameters to maintain constant speed. You will be required to use a multitasking kernel and write your program as tasks within the kernel API.

Concurrency:
For this assignment you must write your code for a multitasking kernel called Tiny Real Time (TRT). Look through the examples on the TRT page to see how to use the API. If the kernel continually resets then: check MAXNBRTASKS and MAXNBRSEMAPHORES in the settings file. Also make sure you have big enough stack allocations. When running TRT, main becomes the default task. Don't put any initialization in main except for the uart.

I suggest the following task mayout, but you can use anything that works for you:

• TRT Task 1 interacts with the PC keyboard to take user input and set up PID parameters.
• TRT Task 2 runs the PID control loop about 50 times/sec using speed measurements from an ISR (see below).
• TRT Task 3 runs the LCD and updates it about 5/second. The (deadline) - (release time) should be greater than the LCD update time so that the kernel can meet all the deadlines. If you give a slow task a release time equal to it's deadline, then it has to execute in zero time to meet deadline, and nothing else can run until the slow task completes. Experiment with this test code by changing the difference in the spoiler task while watching A.0 on the scope. Generally speaking, the deadline-release time difference should be greater than the execution time of the thread between kernel sleep calls.
• An exetrnal interrupt ISR uses Timer 2 to measure the rotation time. Let timer 2 run continously. Every time the external interrupt signal goes to logic high, read timer 2 and zero it. To get enough range, you will probably need to set up timer 2 to simulate a 16-bit timer. Something like the following code could work, assuming that the motor sensor is attached to int0 (pin D2). The motor_period and motor_period_ovlf variables should declared as volatile int.

  // --- external interrupt ISR ------------------------
  ISR (INT0_vect) {
          motor_period = TCNT2 + motor_period_ovlf  ;
          TCNT2 = 0 ;
          motor_period_ovlf = 0 ;
  }
  // --- set up extra 8 bits on timer 2 ----------------
  ISR (TIMER2_OVF_vect) {
          motor_period_ovlf = motor_period_ovlf + 256 ;
  }

  You will, of course, need to turn on timer 2, set up the timer 2 overflow interrupt, and set up int0 in main.

  //set up INT0
  EIMSK = 1<<INT0 ; // turn on int0
  EICRA = 3 ;       // rising edge
  // turn on timer 2 to be read in int0 ISR
  TCCR2B = 7 ; // divide by 1024
  // turn on timer 2 overflow ISR for double precision time
  TIMSK2 = 1 ;

IR sensor:
We will be bouncing infrared light off the hub of the fan and detecting intensity variations in the reflected light to determine the speed. The circuit below uses a infrared emitter to shine light onto a surface. The relected light is detected by a phototransistor. You will want to run the phototransistor output through an opamp comparator to produce fast, logic-level output swings. Even if the levels at the output of the phototransistor are compatable with CMOS logic, the rise time of the light will be too slow for accuracy. The 10K potentiometer sets the comparator threshold, the 1M resistor sets the hysteresis and may need to be adjusted. Hysteresis makes the rising/falling edges of the waveform less sensitive to noise.

Note the * in the following schematic indicating the long component lead!

The left image below shows a fan with a dab of white paint on the hub. The clear IR emitter is pointed at the hub. The dark phototransistor is also pointed at the hub. The top trace on the right shows the output from the phototransistor. As the white paint rotates in front of the sensor, the transistor turns on and the voltage drops. The bottom trace shows the output of the opamp. The threshold should be adjusted so that the opamp switches at a voltage where abs(dv/dt) is high. The output of the opamp could be fed directly into the int0 external interrupt pin (MCU pin D.2), as long as the opamp power rails are +5 and ground. Keep the opamp output away from the PWM lead coming from the MCU. Capacitative coupling can corrupt the output of the opamp!

For debugging, you can see a slight glow in the IR emitter using your cell phone camera because a solid state camera is sensitive to infrared light. You may need to shield the phototransistor from the LED by slipping a small piece of black paper between them so that the transistor sees the white paint, but not the LED. The symptom will be that the transistor output is always low.

Motor Control:
You will need to drive a fan from the mcu. Fans have motors which can cause nasty inductive spikes to wipe out the transistors in the mcu port. The circuit shown below is fairly safe. An optoisolator completely isolates the MCU from the motor. The diode placed across the motor shorts out spikes when the motor is turned off. The resistor grounding the base of the phototransistor should be set for best falltime, probably around 1Mohm. The motor capacitor should start around 0.1uf. Increase it if there is too much spike noise on the analog input, but be sure to use ceramic capacitors, not electrolytic. Electrolytic capacitors are too slow. The pinout of the 4N35 optoisolator and BUZ73 are also shown. Note that the bandwidth of the 4N35 is very small, so use a low PWM frequency, perhaps about 1000 Hz.

A matlab program demonstrating the PID control algorithm includes the following nonlinear effects: The sensor is modeled as producing a new value once/revolution. The effect is to make a feedback which is dependent on the speed of the motor, with the motor becoming more stable at higher speed. The motor is modeled as a second-order system when it is powered, and a first-order system when it is coasting. The controller has saturation (maximum voltage) and rectification (no negative output).

Assignment

Write two to four tasks using the TRT kernel API and construct a circuit which will:

• Measure the rotation rate of a small fan using IR emitter/sensor.
• Format the rotation rate and display appropriate messages on an LCD.
• Take commands from the PC keyboard to:
  • Set the desired motor speed.
  • Set the PID proportional gain.
  • Set the PID differential gain.
  • Set the PID integral gain.
  • You will use a command format like: s 300, p 10, i 2, or d 5.2 to enter values.
    
• Use a PID algorithm to control the speed of the motor by producing a PWM drive to the optoisolator.
• Tune the PID algorithm so that you can change the speed of the motor quickly and accurately without oscillations in speed. The user should be able to type in a desired speed and the motor should quickly change to the new speed.
• Display a low-passed version (time constant about 0.1 second) of the PWM motor control on the scope.
• Display a low-passed version (time constant about 0.1 second) of the actual motor RPM on the scope. Use the second PWM channel on the timer you use to generate the motor PWM control.

You will demo all the features above to your TA. Your program should not need to be reset during the demo.

Your written lab report should include the sections mentioned in the policy page, and :

• A schematic of the circuit you built.
• A summary of the accuracy of your measurements. How accurately can you measure the rotation speed?
• How you selected the three PID gains.
• A heavily commented listing of your code.