Analog-to-Digital Conversion

Project 9 investigated methods of using a microprocessor to generate a variable amplitude output. In Project 10, we will look at one method of using a microprocessor to measure a variable-valued input. The PIC32 processor has 16 10-bit analog inputs channels. However, we will use the DC motor tachometer to measure the analog speed value. Considering that the motor speed is controlled by the average applied voltage, the tachometer represents a voltage to frequency converter. Various silicon manufacturers offer electronic devices that are used to generate a pulse waveform whose frequency is a function of a voltage applied to the sensor input. Using the frequency of a digital pulse wave to represent an analog signal has the advantage of higher signal-to-noise ratio and reduces sensitivity to circuit impedance.

Project 9 implemented open loop speed control of a DC motor. This control approach uses the assumption that the speed of the motor is proportional to the applied voltage. Project 10 is designed to test the linearity of open loop speed control by providing a tachometer to measure the rotor shaft speed. The hardware requirements for Project 9 are the same as for Project 10. Details concerning the hardware configuration for this project are provided in the related material in the tabs to the right. The DC motor used on the Digilent chipKIT Pro MX7 processor board pictured in the green tab has two Hall effect sensors that provide a pulse each time the DC motor shaft makes a complete revolution. The two sensors are physically oriented around the motor rotor shaft that are rotated by 90 degrees that generate two digital signals that oscillate at the same frequency but are out of phase by 90 degrees. The SA and SB PmodHB5 Hall effect sensor outputs form a quadrature encoder that allows both the speed and direction of rotation to be measured. We are only concerned with measuring the motor speed in Project 10.

The speed of the geared output shaft is reduced by the ratio of 53 to 1 to provide greater mechanical torque. The speed of the motor will be measured by determining the frequency of the digital pulse wave generated by the Hall Effect sensor.

Fundamentals of Frequency Measurement

As with the measurement of any data, we are concerned with three parameters: accuracy, resolution, and precision. The accuracy of a frequency measurement is dictated, to a large extent, by the accuracy of the reference crystal, or oscillator. For this project, we depend on the accuracy of the oscillator populated on the chipKIT Pro MX7 processor board. The measurement precision is a metric applied to the repeatability of a measurement. Resolution is the degree of fineness or, conversely, the granularity of a measurement. Accuracy is inherent in the reference that the measurement is compared to. Measurement precision and resolution are determined by the processing of the measured data. The subject of frequency measurement resolution is of great interest and is addressed in greater detail in the following paragraphs.

There are two methods for measuring the frequency of the tachometer. The number of pulses can be counted per unit of time or the inverse of the period between two successive pulse transitions can be computed. Measuring frequency by counting pulses over short intervals is more accurate for signals when the frequency of the signal being measured is high relative to the observation interval. This results in many hundreds or even thousands of cycles being counted during the measurement interval, thus providing a high frequency measurement resolution.

Measuring the period is generally more accurate for relatively low frequency signals. The high resolution is provided by the number of timer counts between input signal transitions. The measurement period now depends of the frequency of the input signal and, for very low frequency signals, may result in excessively long delays between measurement updates.

There are methods to mitigate the effects of long measurement periods for low frequency signals. One method is to use frequency multiplication with a phased locked loop (PLL) circuit. Most modern microcontrollers and microprocessors use frequency multiplication so that the core speed of the processor that is many times the processor crystal frequency. The PIC32 processor family uses a phase locked loop multiplier to set the core frequency by a parameter in the config_bits.h file. Another method for handling the measurement of signals with long periods is to use clocks that run at very low count rates.

For Project 10, you will measure the speed of the motor rotor shaft by computing the period between two successive pulses of the motor tachometer by capturing a timer count at each transition, which are not necessarily equally spaced. In order to achieve the measurement with relatively good accuracy, the period must be measured with a high resolution. This requires that the timer be counting at a much higher rate than the period of the of the tachometer signal. The accuracy of the frequency is preserved by inverting the period using floating point variables or fixed point math divide algorithms.

The challenge is to select the timer input clock rate that will provide adequate period accuracy across the range of possible tachometer frequencies. Initially, assume that the capture is set up to capture each positive or negative transition. Doing so will eliminate issues associated with the tachometer not producing a perfect square wave. This will, however, reduce the period sampling rate by approximately 50%, as described above. Starting with a peripheral bus clock (PBCLK) rate of 10 MHz, a period register to divide by 65536 by setting the PR register to 0xFFFF, and a timer pre-scale value of 256 will result in a 1 Hz/timer count granularity for a tachometer frequency of 200 Hz. Since the maximum period is 65536 timer counts, the minimum measurable frequency is 0.596 Hz but will require 1.68 seconds to get a measurement update.

Granularity is a relative term that relates to the coarseness of a measurement. Higher granularity means lower resolution. From the derivation shown in the Period Measurment tab at the top of the page, for a given measurement period, the granularity of any input frequency can be determined using the equation:

Where $F_{\mathrm{SIGNAL}} = $the inverse of the period of the signal being measured$ = \frac{1}{T_{\mathrm{SIGNAL}}}$ and $T{3_{CLK\_PD}}\ = $the Timer 3 clock period$ = \frac{T3_{\mathrm{PRESCALE}}}{\mathrm{PBCLK}}$.

Eq. 1 above shows that, for a fixed timer clock frequency, the granularity of the frequency measurement, ΔF, increases as the square of the input frequency and has dimension of Hz. As Fig. 1 illustrates, a higher input frequency will result in a measurement with higher granularity for a given measurement interval. Better resolution (finer granularity) is achieved by increasing the clock frequency or reducing input frequency.

Measuring a signal frequency by computing the inverse of the signal period will generate a new measurement update at the signal frequency. Provided that the input signal has a 50% duty cycle, we can get two frequency measurements per cycle of the input signal by determining the period when the input is high and the period when it is low. Measurement noise can be reduced by averaging multiple period measurements.

The speed of the motor is proportional to the frequency of the signal generated by the motor tachometer. The motor that we are using has a reduction gear with a ratio of 53:1. Using a 10V motor supply, the maximum motor speed will be approximately 525 revolutions per second (RPS), or 594 RPM on the output of the gear head. Due to motor power limitations and gear head friction, the minimum motor speed is approximately 79.5 RPS, which is equivalent to 90 RPM as measured on the gear-head output shaft.

Timer Setup for PWM and Input Capture

For this project, we will use two PIC32 timers: one for generating the PWM output that controls the motor speed (Timer 2), and one that will be used to capture the time when the tachometer signal transitions from low to high or high to low (Timer 3). The reason for using two timers is that the period register of the two timers are set to different values in order to achieve different design objectives. The period register of the timer used for generating the PWM signal is set to give a particular PWM cycle frequency. The period register of the timer used for measuring the period of the tachometer signal is set to the maximum value to allow the period measurement of an input signal over a wider range of frequencies. The lower the frequency on the input signal, the more timer counts that will be measured. The period measurement will be incorrect if the timer resets after reaching the terminal count more than once between input signal transitions. Hence, the period register for the timer that is used for timer capture will be set to its maximum value, 65535.

Using unsigned short int (16-bit) data types for variables used to capture the timer counts and to compute the period measurement results in correct period measurements even when the two successive timer captures are made when the timer rolls over from 0xFFFF (65535 base 10) to 0. Consider the case when the first captured timer value is 0XFE3E or the decimal equivalent of 65086. Let the second captured timer value is 0x0096 or the equivalent decimal value of 150. The result of 0x96—0xFE3E is 0xFFFF0258. Since we are using 16-bit data types, the higher 4-byte word is dropped leaving only 0x0258 which is equivalent to 600 – the true period in timer counts. A more thorough discussion of time interval issues is provided in the section titled, “Handling Timer Rollover for Hardware Assisted Delays,” in Project 2.

PIC32 Software for Timer 2 Setup for PWM and Timer Interrupt

Timer 2 will serve two functions: it will be used to generate the PWM signal and it will generate an interrupt once each millisecond. The one millisecond interrupt will be used for hardware timing. Configure. Timer 2 for operations as follows:

1. Configure Timer 2 from a 1 ms period.
   1. OpenTimer2(T2config_bits, PR2_value); where (PR2_value + 1) is the period register value computed for the PWM cycle frequency.
      1. T2config_bits = (T2_ON | T2_Ps_1_1 | T2SOURCE_INT)|(T2_ON | T2_Ps_1_1 | T2SOURCE_INT)|(T2_ON | T2_Ps_1_1 | T2SOURCE_INT)
      2. PR2 = (10000-1) for PBCLK = 10MHz
2. Configure Output Compare for 1 ms PWM cycle period.
   1. OpenOCx(OC_configure_bits, nOCxRS, nOCxR); where nOCxRS is the initial value written to the OCxRS register and nOCxR is the initial value written to the OCxR register. “x” designates the specific OC register being configured in the range between 1 and 5.
      1. OC_configure_bits (b1 | b2 | b3 | b4)|OC_configure_bits (b1 | b2 | b3 | b4)|OC_configure_bits (b1 | b2 | b3 | b4)|OC_configure_bits (b1 | b2 | b3 | b4)
         1. b1 = OC_ON //Enables the Output compare processor resource
         2. b2 = OC_TIMER_MODE16 // Timer uses 16 bit mode
         3. b3 = OC_TIMER2_SRC // Selects Timer 2 as input timer
         4. b4 = OC_PWM_FAULT_PIN_DISABEL // Don’t use fault pin
      2. Output Compare Registers
         1. nOCxRS — This is a constant or a variable that specifies the initial PWM compare value
         2. nOCxR — This is a constant or a variable that specifies the next PWM compare value
   2. Example: OpenOC3(OC_configure_bits, nOC3RS, nOC3R);.
3. Timer 2 interrupt using peripheral library macro functions.
   1. mT2SetIntPriority( 2); // Set Timer 2 interrupt group priority level 1
   2. mT2SetIntSubPriority( 1); // Set Timer 2 interrupt subgroup priority 1
   3. mT2IntEnable( 1); // Enable T2 interrupts
   4. Alternate using the C32 Peripheral Library function:

      ConfigIntTimer2(T2_INT_ON | T2_INT_PRIOR_2 | T2_INT_SUB_PRIOR_1);|ConfigIntTimer2(T2_INT_ON | T2_INT_PRIOR_2 | T2_INT_SUB_PRIOR_1);|ConfigIntTimer2(T2_INT_ON | T2_INT_PRIOR_2 | T2_INT_SUB_PRIOR_1);

4. Timer 2 ISR code.

   void __ISR( _TIMER_2_VECTOR, ipl2) T2Interrupt(void);
   {
   LATBINV = LEDA;	// Toggle  LED A – instrumentation
   mT2ClearIntFlag();	// Clear Timer 2 interrupt flag
   // INTClearFlag(INT_T2);	// Alternate peripheral library function
   }
   

PIC32 Software Timer Setup for Input Capture

Timer 3 Interrupt Setup

Timer 3 will be used exclusively for a 16-bit input timer capture.

1. Configure Timer 3 to use the PBCLK and a pre-scale value of 256. Set Timer 3 PR3 register to 0xFFFF for maximum interval.
   1. OpenTimer3(T3_ON | T3_PS_1_256 | T3_SOURCE_INT, 0xFFFF);|OpenTimer3(T3_ON | T3_PS_1_256 | T3_SOURCE_INT, 0xFFFF);|OpenTimer3(T3_ON | T3_PS_1_256 | T3_SOURCE_INT, 0xFFFF);
   2. mT3SetIntPriority( 2); // Set Timer 3 interrupt group priority 2
   3. mT3SetIntSubPriority( 2); // Set Timer 3 interrupt subgroup priority 2
   4. mT3IntEnable( 1); // Enable Timer 3 interrupts
   5. Alternate to steps b through d using the C32 Peripheral Library function:

      ConfigIntTimer3(T3_INT_ON | T3_INT_PRIOR_2 | T3_INT_SUB_PRIOR_2);|ConfigIntTimer3(T3_INT_ON | T3_INT_PRIOR_2 | T3_INT_SUB_PRIOR_2);|ConfigIntTimer3(T3_INT_ON | T3_INT_PRIOR_2 | T3_INT_SUB_PRIOR_2);

2. Timer 3 ISR code.

   void __ISR( _TIMER_3_VECTOR, ipl2) T3Interrupt(void)
   {
   LATBINV = LEDC;	// Toggle  LEDC  - Timing instrumentation
   mT3ClearIntFlag();	// Clear Timer 3 interrupt flag – 
   // INTClearFlag(INT_T3);	// Alternate peripheral library function
   }
   

Timer Capture Peripheral

Input capture is a processor peripheral that is used to associate at relative time with the occurrence of an external event by capturing the value of a processor timer. Relating the difference between successive captured timer values to the rate at which the timer increments allows the determination of the period between successive events or, inversely, the rate of event occurrences. Common applications of the input capture peripheral are for tachometers and frequency meters. This project measures the speed of the DC motor rotation by measuring the period of a rectangular wave produced by the Hall effect devices installed in the DC motor. Since the Hall effect outputs do not produce a perfect square wave, the period of the signal will be determined by the time between two successive signal rising edges.

The PIC32 uses up to 5 dedicated pins (IC1 through IC5) to trigger a timer capture operation. Either Timer 2 or Timer 3 can serve as a 16-bit timer or Timer2 and Timer 3 can be used together to operate as a 32-bit timer. Section 15.5 of PIC32 user’s manual for the input capture lists the options for configuring the event capture modes. The modes that allow single events to initiate a timer capture can be set for rising, falling, or both rising and falling edges of the input signal. Timer capture operations can also be initiated after a succession of either 4 or 16 events.

Interrupts can be generated after 1, 2, 3 or 4 capture events. A four-deep first-in first-out (FIFO) buffer allows the captured times associated with the succession of events. A capture event is defined by the writing of a timer value into the FIFO. As events are recorded into the FIFO buffer, a counter records the number of entrees. The number of capture events required to set an IC interrupt flag that triggers an interrupt event is set by the OpenCapture configuration. When all of the events have been read from the FIFO buffer, the capture count is cleared. Input capture interrupts persist so long as the condition that caused them persists. In addition, the interrupt will occur again immediately if the condition is not cleared by reading all of the captured events out of the FIFO buffer. It is highly recommended that the interrupt capture flag be reset at the conclusion of the input capture ISR.

Timer Capture Initialization

The following steps will allow the input capture to be setup to use Timer 3 and generate an interrupt when the timer value is captured by a rising edge of the IC5 input pin.

1. Set motor Hall effect outputs SA (RD4) and SB (RD12—IC5) as inputs. MTR_SA is set as an input but is not used for this application because RD4 is not a designated capture input.
   1. mPORTDDirection(MTR_SA_bit | MTR_SB_bit);|mPORTDDirection(MTR_SA_bit | MTR_SB_bit);
2. Clear pending input capture interrupts.
   1. mIC5ClearIntFlag();
3. Use input capture channel 5 for the following options. An interrupt will be generated on each positive transition transition of the input signal. void OpenCapture5(c1 | c2 | c3 | c4 | c5 | c6 | c7);|void OpenCapture5(c1 | c2 | c3 | c4 | c5 | c6 | c7);|void OpenCapture5(c1 | c2 | c3 | c4 | c5 | c6 | c7);|void OpenCapture5(c1 | c2 | c3 | c4 | c5 | c6 | c7);|void OpenCapture5(c1 | c2 | c3 | c4 | c5 | c6 | c7);|void OpenCapture5(c1 | c2 | c3 | c4 | c5 | c6 | c7);|void OpenCapture5(c1 | c2 | c3 | c4 | c5 | c6 | c7);
   1. c1 = IC_ON // Enable input capture
   2. c2 = IC_CAP_16BIT // Capture a 16 bit clock
   3. c3 = IC_IDLE_STOP // Stop input capture during debug
   4. c4 = IC_FEDGE_FALL // Initial capture on negative transition
   5. c5 = IC_TIMER3_SRC //Use Timer 3 as time to capture
   6. c6 = IC_INT_1CAPTURE // Generate interrupt on each capture
   7. c7 = IC_EVERY_ RISE_EDGE // Capture time on every edge
4. c7 = IC_EVERY_ RISE_EDGE // Capture time on every edge
   1. ConfigIntCapture5(ic1 | ic2 | ic3);|ConfigIntCapture5(ic1 | ic2 | ic3);|ConfigIntCapture5(ic1 | ic2 | ic3);
      1. ic1 = IC_INT_ON // Enable input capture interrupt )
      2. ic2 = IC_INT_PRIOR_3 // Set priority for level 3
      3. ic3 = IC_INT_SUB_PRIOR_0 // Set sub priority for level 0
   2. Example:

      ConfigIntCapture5(IC_INT_ON | IC_INT_PRIOR_3 | IC_INT_SUB_PRIOR_0);|ConfigIntCapture5(IC_INT_ON | IC_INT_PRIOR_3 | IC_INT_SUB_PRIOR_0);|ConfigIntCapture5(IC_INT_ON | IC_INT_PRIOR_3 | IC_INT_SUB_PRIOR_0);

Input Capture ISR Example

   
"void __ISR( _INPUT_CAPTURE_5_VECTOR, ipl3) Capture5(void)"
{
static unsigned int con_buf[32];	// Declare an input capture buffer
// Declare three time capture variables: 
static unsigned short int time1;	// Most recent captured time
static unsigned short int time2 = 0;	// Previous time captured
static unsigned short int time_diff = 0; // Time between captures

LATVINV = LEDD	//Toggles LEDD on each input capture interrupt - instrumentation
ReadCapture5(con_buf);		// Read captures into buffer
time1 = con_buf[0];			// Save time of event
time_diff = time1-time2;		// Subtracts previous capture time to
					// determine period.
time 2 = time1;			// Save time1 as time 2
// Compute motor speed in RPS (revolutions per second). Equation to be
// worked out by reader
mIC5ClearIntFlag();			// Clears interrupt flag
// INTClearFLag(INT_IC5);		// Alternate peripheral library function

}