Mech - User contributions [en]

File:NU32v2 Encoder.c

2011-02-09T17:33:35Z

Andrew Long:

NU32v2: Using the LS7183 Quadrature Clock Converter

2011-02-09T17:32:41Z

Andrew Long: /* Sample Code */

The LS7183 quadrature clock converter is a chip used to convert quadrature signals from encoders into up and down counts that can be sent to a microchip.

== Overview ==

[[Rotary Encoder|Rotary encoders]] create quadrature signals on two channels (A and B) corresponding to the speed and direction of a motor. Some encoders produce up to a million counts per revolution. For very fast quadrature signals there is no way that a software quadrature decoder can avoid overrun errors. Instead we may use the LS7183 chip to translate the A and B quadrature signals into brief pulses indicating up-count or down-count. The up and down counts can be configured as external input signals to increment counters on the PIC32. By reading the counters on the PIC, we can determine the angle of the motor.

== Details ==

[[Image:LS7183.png|center|thumb|400 px]]

The resistor bias is used to control the pulse width of the up and down counts. The mode (1X, 2X, 4X) is used to multiply the quadrature clock rate by 1, 2 or 4. The mode is selected by connecting MODE to
* VSS (GND) -> 1X
* VDD (3.3V) -> 2X
* Float (don't connect to anything) -> 4X

The UP and DOWN count pins should be connected to external counters on the PIC32.

== Sample Code ==

The full code can be downloaded [[Media:NU32v2_Encoder.c | here]]. The code configures 2 external counters (see [[NU32v2: Counters and Timers#External Counter|Counters and Timers]]) that will increment with each pulse received from the LS7183. The example sends the encoder position via RS232 to your PC.

The main piece of code shown below reads the UP and DOWN counters. With a variable called bigcount, it adds the the recent UP counts, subtracts the down counts and adjusts for roll-over of the counters. The full code placed this code in the main while loop, but this code can be placed in an ISR if you want to read the encoder at a given rate.

<pre>
count0 = ReadTimer4(); // in your routine this must be done at least every 32000
// encoder counts to avoid rollover ambiguity
count1 = ReadTimer5();

bigcount += count0 - last0; // add on the recent up-counts, since the last time

if (count0 < last0){
bigcount += 65536; // count0 only increments, so if it got lower
//it must have rolled over
}

last0 = count0;

bigcount -= count1 - last1; // we're not worrying about rollover of the 32 bit bigcount total

if (count1 < last1){
bigcount -= 65536;
}

last1 = count1;

</pre>

NU32v2: Using the LS7183 Quadrature Clock Converter

NU32v2: Using the LS7183 Quadrature Clock Converter

2011-02-09T16:50:13Z

Andrew Long: New page: == Overview == == Details == == Library Functions == == Sample Code ==

== Overview ==

== Details ==

== Library Functions ==

== Sample Code ==

Microchip PICs

2011-02-09T16:49:12Z

Andrew Long: /* Using the NU32v2 */

'''Note: Much of the code on this page was written using the CCS compiler. All new code is being written using Microchip's MPLAB.

[http://peshkin.mech.northwestern.edu/pic/code Link to all sample code here.]
*[[Sample code for most PIC18F4520 operations]]
*[http://www.ccsinfo.com/forum/ CCS user forum]
 
__TOC__
== Using the NU32v2 ==
*[[NUScope]]
*[[NU32v2: Introduction to the PIC32]]
**[[NU32v2: What is in the NU32v2 Kit]]
**[[NU32v2: Software to Install]]
**[[NU32v2: Starting a New Project and Putting it on the NU32v2]]
**[[NU32v2: Using the Simulator]]
**[[NU32v2: A Detailed Look at Programming the PIC32]]
* Sample Code
**[[NU32v2: Digital Input and Output]]
**[[NU32v2: Counters and Timers]]
**[[NU32v2: Interrupts]]
**[[NU32v2: Output Compare, PWM, and Analog Output]]
**[[NU32v2: Serial Communication with the PC]]
**[[NU32v2: Nokia 5110 LCD]]
**[[NU32v2: Analog Input]]
**[[NU32v2: Using the LS7183 Quadrature Clock Converter]]
**[[NU32v2: Input Capture]]
**[[NU32v2: Flash Self-Programming]]
**[[NU32v2: UART Asynchronous Serial Communication]]
**[[NU32v2: I2C Synchronous Serial Communication]]
**[[NU32v2: SPI Synchronous Serial Communication]]
**[[NU32v2: Digital Signal Processing]]
**[[NU32v2: Watchdog Timer]]
**[[NU32v2: Simple Analog Input]]

== Using the PIC18F4520 ==
*[[4520 Board intro]]
*[[4520 Board construction]]
*[[4520 Board use]]
*[[Microcontroller PIC18F4520]]
*[[PIC MCUs: Capabilities of PIC18F4520]]
**[[PIC18F4520: PWM Motor Control]]
**[[PIC18F4520: Digital Outputs]]
**[[PIC18F4520: Digital Inputs]]
**[[PIC18F4520: Serial Digital-to-Analog Conversion]]
**[[PIC18F4520: Analog Inputs]]
**[[PIC18F4520: Timers]]
**[[PIC18F4520: Comparator]]

== Example Code in C for PIC18F4520==
*[[C Example: Parallel Interfacing with LCDs]]
*[[C Example: Digital Inputs]]
*[[C Example: PWM Motor Control]]
*[[C Example: Comparators]]
*[[C Example: Digital Outputs]]
*[[C Example: Analog Inputs]]
*[[C Example: Digital Outputs (Ports)]]
*[[C Example: Bi-Directional PWM Motor Control]]
*[[C Example: Serial LCD]]

== Using the PIC32MX Series ==
*[[Introduction to the PIC32]]
*[[Getting Started with PIC32]] (includes NU32 development board)
** Download PIC32 Tutorial Files [[Media: PIC32_TutorialFiles.zip|here]].
** [[ME 333 Lab 2]] - Includes Digital IO, Analog Input, Parallel LCD and RS232 Com
** [[ME 333 Lab 4]] - Includes PWM and Encoder Motor Control
*[[Microcontroller PIC32MX460F512L]]
*[[Programming HID Bootloader on PIC32]]
*[[HelloWorld PIC32|Directions to code HelloWorld]]
*[[Directions to Load Files to PIC32 with HID Bootloader]]

*[[PIC MCUs: Capabilities of PIC32MX]]
**[[Programming HID Bootloader on PIC32 |PIC32MX: Bootloader]]
**Simple Programs
***[[PIC32MX: Digital Inputs]]
***[[PIC32MX: Digital Outputs]]
***[[PIC32MX: Analog Inputs]]
**Communication
***[[PIC32MX: Parallel LCD]]
***[[PIC32MX: RS232]]
***[[PIC32MX: USB Communication with a PC]]
***[[PIC32MX: SPI External RAM]]
***[[PIC32MX: I2C DAC]]
***[[PIC32MX: I2C EEPROM]]
***[[PIC32MX: SPI EEPROM]]
***[[PIC32MX: I2C Communication between PIC32s]]
***[[PIC32MX: SPI Communication between PIC32s]]
**Motor Control
***[[PIC32MX: PWM Motor Control|PIC32MX: PWM Motor Control]]
***[[PIC32MX: Encoder Motor Control|PIC32MX: Encoder Motor Control]]
***[[PIC32MX: Servo Control|PIC32MX: Servo Control]]
***[[PIC32MX: Driving a Stepper Motor]]
***[[Using the LS7166 Quadrature Counter]]
***[[Using the LS7366R SPI Quadrature Counter]]
**Capabilities
***[[PIC32MX: Benchmarking Mathematical Operations]]
***[[PIC32MX: FFT of Analog Input]]
***[[PIC32MX: Sinusoidal Analog Output]]
***[[PIC32MX: XBee Wireless Round-trip Latency]]
***[[PIC32MX: Interfacing with Force Sensors from a Scale]]
***[[PIC32MX: Storing Data in Flash Memory (Run-Time Self Programming)]]

==Other PIC Resources ==

*[[PIC PWM Motor Driver]]
*[[Writing Code with the C18 Compiler]]
*[[Controlling a seven segment display]]
*[[PIC Microcontrollers with C18 Compiler]]
*[[PIC Motor Control and Serial Port Example]]
*[[PIC16F684]]
*[[PIC Microcontrollers with CCS Compiler]]
*[[Stepper motor control with the PIC]]
*[[PIC/C18 Compiler Tips and Troubleshooting]]
*[[CCS C]]
*[[Analog Input]]
*[[PIC MCUs: Hardware and Connections]]
*[[Storing constant data in program memory]]
*[[PIC Analog-Digital-Converter Example]]
*[[PIC Microcontroller]]
*[[Digital inputs & outputs]]
*[[Debugging C on a PIC]]
*[[Analog Output]]
*[[PIC MCUs: Software]]
*[[Interfacing to External EEPROM]]
*[[CCS IDE]]
*[[Interrupts]]
*[[PIC16F684 Registers]]
*[[Waveform Generation with AD9833]]
*[[Waveform Generation with AD9833, and SPI]]
*[[PIC computation time benchmarks]]
*[[PICkit 1]]
*[[PIC MCUs: 4520 Board]]
*[[More debugging tips]]
*[[Example Writeup: Analog Input]]
*[[LED Drivers]]
*[[Embedded Programming Tips for CCS C]]
*[[Wireless PIC bootloading]]
*[[PIC 18f4553]]
*[[I2C Motor Controller]]
*[[Driving a piezo speaker with a PIC]]
*[[PIC Servo Controller]]
*[[Watchdog timer]]
*[[Interfacing PIC with SPI memory]]
*[[Using the LS7166 Quadrature Counter]]

==Programming the PIC with Microchip's MPLAB==

NU32v2: Counters and Timers

2011-01-29T22:24:54Z

Andrew Long: /* Sample Code */

The basic function of counters is quite simple: they count the number of pulses they have received since they were last reset (or last "rolled over"). If the pulses come from a fixed frequency clock, they can be thought of as timers, hence the words counter and timer are often used interchangeably (as in this article). I prefer to call them "counters," but Microchip's documentation mostly refers to them as timers, so we'll adopt that terminology. The pulses that are being counted may come from the internal peripheral bus clock or external sources.

== Overview ==

The PIC32 is equipped with 5 16-bit timers (Timer1, Timer2, Timer3, Timer4, and Timer5). A timer increments based on a clock signal, which may come from an internal source (the peripheral bus clock, 80 MHz for us) or an external source (such as an encoder). Each timer x has an associated pin TxCK for the external source. In addition, a ''prescaler'' determines how many clock pulses must be received before the counter increments. If the prescaler is set to 1:1, the counter increments on each clock pulse; if it is set to 1:4, it increments every fourth pulse. Both the clock source type (internal and external) and the prescaler value are set in software.

Each 16-bit timer can count from 0 to 2^16 - 1 = 65535 = 0xFFFF, at which point it "rolls over" to 0 again. The timer can also be made to roll over at any count less than 0xFFFF by setting the period of the timer roll-over in software. We can also configure the timer to generate an interrupt when this roll-over event occurs. In this way, by using the peripheral bus clock as the clock source, we can generate precisely timed events, such as the execution of a control law in feedback control.

These features are common to each of the timers. However, we can separate the timers into two types: Type A and Type B. Added features of each type of timer are indicated below

* '''Type A Timer''': Only Timer 1 is a Type A timer, and it can take prescaler values of 1:1, 1:8, 1:64, and 1:256. A Type A timer is capable of counting external pulses ''asynchronously.'' This means that the counter can be configured to run independently of the peripheral bus clock---the counter can increment even in the absence of the PB clock. (This is in contrast to ''synchronous'' counting, where even if the events being counted are external, the counter only increments on the PB clock rising edge,i.e., the external rising edge is "synchronized" to the PB clock.) One use of asynchronous counting is to count even when the CPU is in SLEEP mode and not providing a PB clock signal. Thus a Type A timer can be used in conjunction with the Real-Time Clock and Calendar (RTCC) to keep track of seconds, minutes, hours, days, and years, even when the PIC is in SLEEP mode. To do this, the secondary oscillator pins SOSCO and SOSCI should be connected to a 32.768 kHz oscillator (2^15 pulses every second). We will rarely need the asynchronous counting capability.

* '''Type B Timer''': Timers 2, 3, 4, and 5 are Type B, and can take prescaler values of 1:1, 1:2, 1:4, 1:8, 1:16, 1:32, 1:64, and 1:256. Type B timers add two useful capabilities: the ability to trigger an analog-to-digital conversion when the timer rolls over, and the ability to cascade two timers to make a single 32-bit timer (Timer 23 and Timer 45). The former capability is useful when collecting analog input signals at fixed time intervals without CPU intervention. The latter capability allows us to count up to 2^32 > 4 billion. In this case, the even numbered timer (Timer 2 or 4) is the master timer, and its roll-over signal is the input to the slave timer (Timer 3 or 5). Thus the even numbered timer contains the least significant 16 bits and the odd numbered timer contains the most significant 16 bits.

== Details ==
The functions of the timers are controlled by special function registers (SFRs). Each of these SFRs has 32 bits on the PIC32, but for many, not all of the bits are relevant. Depending on whether these bits are 0 or 1, different actions or settings are performed for Timer x:
*'''TxCON''': This SFR configures the behavior of the timer, including whether it is on or not, the prescaler value, the source of the clock (internal or external). For Type A timers, it also indicates whether it will operate in synchronous or asynchronous mode. For even-numbered Type B timers, this SFR determines whether two timers are cascaded to create a 32-bit timer.
*'''TMRx''': This register stores the 16-bit count. It resets to 0 when the timer reaches the number stored in PRx.
*'''PRx''': 16-bit "period register": the value where TMRx rolls over (resets to zero).

Counter interrupts are controlled with the following SFRs:
*'''IEC0''': Five bits of this SFR are relevant to the timers, one for each timer. If the bit is 1, the interrupt is enabled and an interrupt will be generated at timer roll-over. If the bit is 0, no interrupts will be generated. (Other bits in this SFR are reserved for other interrupt sources.)
*'''IFS0''': Five bits of this SFR are relevant to the timers, one for each timer. If the bit is 1, the timer has generated an interrupt request. If the bit is 0, it has not. Your ISR must set this bit back to zero ("clear the flag").
*'''IPCx''': Three bits of this SFR specify the priority of the interrupt associated with timer x, and two bits set the subpriority of the interrupt. The priority can take values 1..7, and higher numbers mean higher priority. Thus if a timer with priority 2 generates an interrupt and its interrupt service routine (ISR) is called, then a timer with priority 4 generates an interrupt, the CPU will jump to the higher priority ISR, finish its execution, and then return to the original ISR.

If interrupts are enabled, a timer interrupt is generated when the timer rolls over. Thus if the clock input is a fixed frequency clock (like the PB clock), then the period register PRx, together with the timer prescaler (N >=1), determines the frequency of the interrupts. The period of the interrupt is
Period = (PRx+1)*Tpb*N,
where Tpb is the period of the peripheral bus. Thus for an 80 MHz PB clock, a maximum prescaler value of N=256, and a 16-bit timer, the maximum timer period between interrupts is 65536*(1/80 M)*256 = 0.21 seconds. For a 32-bit timer, it increases to nearly 4 hours.

More details can be found in Section 14 of the Reference Manual.

== Library Functions ==
The peripheral library offers a number of function calls to simplify setting up and using the timers. The declarations of these functions can be found in pic32-libs/include/peripheral/timer.h.

Each timer X (replace X with the timer number you wish to use) has the following functions:
*OpenTimerX(config, period): where config is a value selected by using bitwise OR | with the constants given in the header file. config chooses whether the time is on or off, the prescaler, the source (internal or external), and whether this timer is the master timer of a 32-bit timer pair. period is the desired PRX value which determines the roll-over period.
*CloseTimerX(): this disables the timer
*ConfigIntTimerX(config): this function configures the interrupt based on config which is a value selected by using | with the constants given in the header file.
*EnableIntTX(): enables the interrupt
*DisableIntTX(): disables the interrupt
*SetPriorityIntX(priority): sets the priority of the interrupt
*ReadTimerX(): returns the value of the timer
*WriteTimerX(value): loads a given value to the timer
*ReadPeriodX(): returns the PRX value
*WritePeriodX(value): loads a given value to the PRX register

Timers 2 and 3 as well as 4 and 5 can be combined to create 32-bit timers. If using a 32-bit timer, replace the X in the functions above with 23 or 45.

== Sample Code ==

=== Accurate Timing ===

Here's a simple example of code to time how many cycles it takes to compute a code snippet (provided it's less than 2^16 cycles; otherwise we need to cascade two timers).

<pre>
int elapsed; float time; int i;
OpenTimer2(T2_ON | T2_SOURCE_INT | T2_PS_1_8, 0xFFFF); // will overflow in 1/(80000000Hz/8/65535) = 0.0066s

WriteTimer2(0);
for (i=0;i<10000;i++) {}
elapsed = ReadTimer2();
time = (float)elapsed / 80000000.0 * 8.0;
sprintf(RS232_Out_Buffer, "counting to 10000 takes %d timer cycles \tor %f s\r\n", elapsed, time);
WriteString(UART3, RS232_Out_Buffer);
</pre>

=== Time-based Interrupts ===

For each interrupt, we need to write an interrupt service routine (ISR), which basically means when an interrupt is generated jump to and execute a given set of code before returning. The standard way to write an ISR is the following

<pre>
void __ISR(vector, iplx) yHandler(void){

// code to execute

// clear the interrupt flag
function to clear interrupt flag
}
</pre>
where vector refers to a constant defined in '''(find this location)''', iplx is the interrupt priority level where x is the level. yHandler can be anything you want, for example we can call the timer2 handler as Timer2Handler. There is a function associated with each interrupt that is used to clear the flag, which allows the program to return to where it was before the interrupt was generated. Without clearing the flag, the program will never exit the interrupt.

This example is going to toggle 2 LEDs at a given frequency using interrupts with timer 2. We are going to use the functions OpenTimer2() and ConfigIntTimer2() to initialize the timer and interrupts. You will see in the example code that there is also a function INTEnableSystemMultiVectoredInt() which is used to set up multi-vectored interrupts '''(whatever that means)'''.

<pre>
/* Timer_Simple.c
*
* This example toggles 2 LEDs on and off using a timer interrupt.
*
*/
#include <plib.h>

#define SYS_FREQ 80000000 // clock frequency set by bootloader
#define LED_0 LATGbits.LATG12 // mnemonic constants for LEDs on NU32v2
#define LED_1 LATGbits.LATG13

// Define constants for the interrupt frequency (Hz) and the prescalar
// Note that (SYS_FREQ / INT_FREQ / PRE_SCALER - 1) needs to be less than 2^16-1
#define INT_FREQ 5
#define PRE_SCALER 256

void initLEDs(void);

//int count = 0;

int main(void) {
// SYSTEMConfig() optimizes performance for our clock frequency.
// in Microchip\MPLAB C32\pic32-libs\include\peripheral\system.h
SYSTEMConfig(SYS_FREQ, SYS_CFG_ALL);

initLEDs(); // set LED pins as outputs

LED_0 = 1; // low output turns an LED on; see NU32v2 circuit
LED_1 = 0; // high output turns an LED off

// configure Timer 2 using internal clock with given prescaler
OpenTimer2(T2_ON | T2_SOURCE_INT | T2_PS_1_256, SYS_FREQ/INT_FREQ/PRE_SCALER - 1);

// set up the timer interrupt with a priority of 2
ConfigIntTimer2(T2_INT_ON | T2_INT_PRIOR_2);

// enable multi-vector interrupts
INTEnableSystemMultiVectoredInt();

while(1) { // infinite loop
}
return 0;
} // end main

/* initLEDs()
*
* initLEDs sets RG12 and RG13 to outputs to control the LEDs on the NU32v2.
*/
void initLEDs(void) {
LATG |= 0x3000; // Initializes G12 and G13 to 1 (off for NU32v2 board)
TRISG &= 0xCFFF; // set the two pins to inputs

}

/* ISR for Timer 2*/
void __ISR(_TIMER_2_VECTOR, ipl2) Timer2Handler(void){

LED_0 = !LED_0; // toggle LED_0
LED_1 = !LED_1; // toggle LED_1

// clear the interrupt flag
mT2ClearIntFlag();
}
</pre>

From this example, we can see how to set up timer 2 at a frequency of 5 Hz with an interrupt priority of 2.

Now let's modify this simple time-based ISR to toggle the leds at two fixed time periods, one at period T, other at period kT, where k is an integer, by using a counter i that increments each time the ISR is called, and when i reaches k, does the less frequent code and sets i back to zero. For this example, create a global int count and initialize it to zero.

<pre> int count = 0;
</pre>

Use this ISR instead of the previous, in order to have LED0 toggle at 5 Hz and LED1 toggle at 1 Hz.
<pre>/* ISR for Timer 2*/
void __ISR(_TIMER_2_VECTOR, ipl2) Timer2Handler(void){

LED_0 = !LED_0; // toggle LED_0

count++;

if(count == 5){
LED_1 = !LED_1; // toggle LED_1
count = 0;
}
// clear the interrupt flag
mT2ClearIntFlag();
}

</pre>

Imagine that we wanted to toggle the LEDs at 1 Hz by using a 32-bit timer. We can combine timers 2 and 3 or timers 4 and 5 to create a 32-bit timer. Let's use a prescaler of 1:1, the period register then should be PR = (1 sec) (80000000 Hz) (1) -1 = 79999999 < 2^32 - 1.

Replace the timer initialization with
<pre> // configure Timer 2 as 32-bit timer using internal clock, 1:1 prescaler
OpenTimer23(T23_ON | T23_SOURCE_INT | T23_PS_1_1, 79999999);

// set up the timer interrupt with a priority of 2
ConfigIntTimer23(T23_INT_ON | T23_INT_PRIOR_2);
</pre>

Replace the ISR with
<pre>
// ISR for Timer 23
// Note that the interrupt vector needs to be _TIMER_3_VECTOR
void __ISR(_TIMER_3_VECTOR, ipl2) Timer23Handler(void) {

LED_0 = !LED_0; // toggle LED_0
LED_1 = !LED_1; // toggle LED_1

// clear the interrupt flag
mT23ClearIntFlag();
}
</pre>

In summary, this example shows you how to set up a time based interrupt with a given frequency and prescaler. It also shows you how to create a 32-bit timer.

=== External Counter ===

[[Media:NU32v2_external_count_example.c | This code]] is going to set up an external counter to count the number of high pulses on the T5CK pin. The counts will be displayed in binary on the NU32v2 board and will reset after 4 button pushes. You need a simple circuit consisting of 3.3V connected to a switch connected to a resistor (1K) connected to ground. Connect a wire from T5CK to the junction of the resistor and the switch.

The main elements of this code are the initialization
<pre>
OpenTimer5( T5_ON | T5_PS_1_1 | T5_SOURCE_EXT, 0xFFFF);
</pre>
which sets up Timer 5 with an external clock source and a prescaler of 1:1. The PR value is the value that you want the counter to roll-over / generate an interrupt. We will not be setting up interrupts, so this number does not really matter.

We will read the counter with the function
<pre>
ReadTimer5()
</pre>

We will reset the counter to zero with
<pre>
WriteTimer5(0);
</pre>

== More Information ==

NU32v2: Counters and Timers

2011-01-26T15:54:17Z

Andrew Long: /* External Counter */

Counters are quite simple: they count the number of pulses they have received since they were last reset (or last "rolled over"). If the pulses come from a fixed frequency clock, they can be thought of as timers, hence the words counter and timer are often used interchangeably. The pulses may come from the internal peripheral bus clodk or external sources.

== Overview ==

The PIC32 is equipped with 5 16-bit timers (Timer1, Timer2, Timer3, Timer4, and Timer5). The basic idea of a timer is that it increments based on a clock signal.

In software, the user selects whether the timer increments using an internal clock or an external clock. The internal clock is based on the frequency of the peripheral bus. For the NU32v2, the peripheral bus frequency is set at 80 MHz. The external clock would be used if you wanted to count external pulses such as from an encoder. Each of the timers has a pin labeled 'TXCK' that can be used for the external clock. Additionally, the user selects a prescaler that determines how many pulses the timer must receive from the clock source before adding one to the counter value.

Each timer can be configured to generate interrupts at a given priority.

The PIC32 has two types of timers:
*'''Timer A''': (Timer1) is an asynchronous timer with a built in oscillator, can operate in sleep mode and has prescalers of 1:1, 1:8, 1:64, and 1:256
*'''Timer B''': (Timer2, Timer3, Timer4, Timer5) has the ability to form a a 32-bit timer, has prescalers of 1:1, 1:2, 1:4, 1:16, 1:32, 1:64 and 1:256 and can have event triggers.

== Details ==
The functions of the counters are controlled by special function registers (SFRs). Each of these SFRs has 32 bits on the PIC32, but for many, not all of the bits are relevant. Depending on whether these bits are 0 or 1, different actions or settings are performed for Timer (counter) x:
*'''TxCON''': This SFR sets up the counter. There are many different ways to configure the counters. The main options for TxCON are to turn on or off the counter, choose the prescaler, specify if the clock is internal or external and change mode to 32-bit timer. Other options can be seen in the PIC32 reference manual.
*'''TMRx''': This register stores the 16-bit count. It resets to 0 when it reaches the number stored in PRx.
*'''PRx''': 16-bit value where TMRx rolls over (resets to zero).

Counter interrupts are controlled with the following SFRs:
*'''TxIE''': This SFR sets up the interrupt associated with the counter. An interrupt can be generated when the counter resets.
*'''TxIF''': This SFR corresponds to the interrupt Flag Status bit which is either 0 or 1 depending on whether or not the interrupt has been generated.
*'''TxIP''': This SFR sets the priority of the interrupt associated with the counter.
*'''TxIS''': This SFR sets the subpriority of the interrupt.

Given a clock source (internal or external) and a prescaler (1:n), the counter increments by 1 every n pulses from the clock. The counter is reset to zero when the timer value equals the PRx value. If interrupts are enabled, the counter interrupt is generated when the counter resets. This means that PRx determines the frequency of the interrupts. If the clock source is internal (peripheral bus), the period of the interrupt is given by
Period = [(PRx + 1) Tpb (TMR_Prescaler_value)],
where Tpb is the period of the peripheral bus.

This means that if we want to specify the frequency of the interrupt, we need to determine PRx. Note that PRx needs to be less that 2^16 - 1 if using only 1 timer or less than 2^32 - 1 if combining two timers. See example below.

== Library Functions ==
The peripheral library offers a number of function calls to simplify setting up and using the Timers. The declarations of these functions can be found in pic32-libs/include/peripheral/timer.h.

Each Timer X (ie replace X with the timer number you wish to use) has the following functions:
*OpenTimerX(config, period): where config is a value selected by using | with the constants given in the header file. period is the desired PRx value which determines the roll-over // interrupt frequency.
*CloseTimerX(): this disables the timer
*ConfigIntTimerX(config): this function configures the interrupt based on config which is a value selected by using | with the constants given in the header file.
*EnableIntTX(): enables the interrupt
*DisableIntTX(): disables the interrupt
*SetPriorityIntX(priority): sets the priority of the interrupt
*ReadTimerX(): returns the value of the timer
*WriteTimerX(value): loads a given value to the timer
*ReadPeriodX(): returns the PRx value
*WritePeriodX(value): loads a given value to the PRx register

Timers 2 and 3 as well as 4 and 5 can be combined to create 32-bit timers. If using a 32-bit timer, replace the X in the functions above with 23 or 45.

== Sample Code ==

=== Accurate Timing ===

=== Time-based Interrupts ===

For each interrupt, we need to write an interrupt service routine (ISR), which basically means when an interrupt is generated jump to and execute a given set of code before returning. The standard way to write an ISR is the following

<pre>
void __ISR(vector, iplx) yHandler(void){

// code to execute

// clear the interrupt flag
function to clear interrupt flag
}
</pre>
where vector refers to a constant defined in '''(find this location)''', iplx is the interrupt priority level where x is the level. yHandler can be anything you want, for example we can call the timer2 handler as Timer2Handler. There is a function associated with each interrupt that is used to clear the flag, which allows the program to return to where it was before the interrupt was generated. Without clearing the flag, the program will never exit the interrupt.

This example is going to toggle 2 LEDs at a given frequency using interrupts with timer 2. We are going to use the functions OpenTimer2() and ConfigIntTimer2() to initialize the timer and interrupts. You will see in the example code that there is also a function INTEnableSystemMultiVectoredInt() which is used to set up multi-vectored interrupts '''(whatever that means)'''.

<pre>
/* Timer_Simple.c
*
* This example toggles 2 LEDs on and off using a timer interrupt.
*
*/
#include <plib.h>

#define SYS_FREQ (80000000L) // clock frequency set by bootloader
#define LED_0 LATGbits.LATG12 // mnemonic constants for LEDs on NU32v2
#define LED_1 LATGbits.LATG13

// Define constants for the interrupt frequency (Hz) and the prescalar
// Note that (SYS_FREQ / INT_FREQ / PRE_SCALAR - 1) needs to be less than 2^16-1
#define INT_FREQ 5
#define PRE_SCALAR 256

void initLEDs(void);

//int count = 0;

int main(void) {
// SYSTEMConfig() optimizes performance for our clock frequency.
// in Microchip\MPLAB C32\pic32-libs\include\peripheral\system.h
SYSTEMConfig(SYS_FREQ, SYS_CFG_WAIT_STATES | SYS_CFG_PCACHE);

initLEDs(); // set LED pins as outputs

LED_0 = 1; // low output turns an LED on; see NU32v2 circuit
LED_1 = 0; // high output turns an LED off

// configure Timer 2 using internal clock with given prescalar
OpenTimer2(T2_ON | T2_SOURCE_INT | T2_PS_1_256, SYS_FREQ/INT_FREQ/PRE_SCALAR - 1);

// set up the timer interrupt with a priority of 2
ConfigIntTimer2(T2_INT_ON | T2_INT_PRIOR_2);

// enable multi-vector interrupts
INTEnableSystemMultiVectoredInt();

while(1) { // infinite loop
}
return 0;
} // end main

/* initLEDs()
*
* initLEDs sets RG12 and RG13 to outputs to control the LEDs on the NU32v2.
*/
void initLEDs(void) {
LATG |= 0x3000; // Initializes G12 and G13 to 1 (off for NU32v2 board)
TRISG &= 0xCFFF; // set the two pins to inputs

}

/* ISR for Timer 2*/
void __ISR(_TIMER_2_VECTOR, ipl2) Timer2Handler(void){

LED_0 = !LED_0; // toggle LED_0
LED_1 = !LED_1; // toggle LED_1

// clear the interrupt flag
mT2ClearIntFlag();
}
</pre>

From this example, we can see how to set up timer 2 at a frequency of 5 Hz with an interrupt priority of 2.

Now let's modify this simple time-based ISR to toggle the leds at two fixed time periods, one at period T, other at period kT, where k is an integer, by using a counter i that increments each time the ISR is called, and when i reaches k, does the less frequent code and sets i back to zero. For this example, create a global int count and initialize it to zero.

<pre> int count = 0;
</pre>

Use this ISR instead of the previous, in order to have LED0 toggle at 5 Hz and LED1 toggle at 1 Hz.
<pre>/* ISR for Timer 2*/
void __ISR(_TIMER_2_VECTOR, ipl2) Timer2Handler(void){

LED_0 = !LED_0; // toggle LED_0

count++;

if(count == 5){
LED_1 = !LED_1; // toggle LED_1
count = 0;
}
// clear the interrupt flag
mT2ClearIntFlag();
}

</pre>

Imagine that we wanted to toggle the LEDs at 1 Hz by using a 32-bit timer. We can combine timers 2 and 3 or timers 4 and 5 to create a 32-bit timer. Let's use a prescalar of 1:1, the period register then should be PR = (1 sec) (80000000 Hz) (1) -1 = 79999999 < 2^32 - 1.

Replace the timer initialization with
<pre> // configure Timer 2 as 32-bit timer using internal clock, 1:1 prescalar
OpenTimer23(T23_ON | T23_SOURCE_INT | T23_PS_1_1, 79999999);

// set up the timer interrupt with a priority of 2
ConfigIntTimer23(T23_INT_ON | T23_INT_PRIOR_2);
</pre>

Replace the ISR with
<pre>
// ISR for Timer 23
// Note that the interrupt vector needs to be _TIMER_3_VECTOR
void __ISR(_TIMER_3_VECTOR, ipl2) Timer23Handler(void) {

LED_0 = !LED_0; // toggle LED_0
LED_1 = !LED_1; // toggle LED_1

// clear the interrupt flag
mT23ClearIntFlag();
}
</pre>

In summary, this example shows you how to set up a time based interrupt with a given frequency and prescalar. It also shows you how to create a 32-bit timer.

=== External Counter ===

[[Media:NU32v2_external_count_example.c | This code]] is going to set up an external counter to count the number of high pulses on the T5CK pin. The counts will be displayed in binary on the NU32v2 board and will reset after 4 button pushes. You need a simple circuit consisting of 3.3V connected to a switch connected to a resistor (1K) connected to ground. Connect a wire from T5CK to the junction of the resistor and the switch.

The main elements of this code are the initialization
<pre>
OpenTimer5( T5_ON | T5_PS_1_1 | T5_SOURCE_EXT, 0xFFFF);
</pre>
which sets up Timer 5 with an external clock source and a prescaler of 1:1. The PR value is the value that you want the counter to roll-over / generate an interrupt. We will not be setting up interrupts, so this number does not really matter.

We will read the counter with the function
<pre>
ReadTimer5()
</pre>

We will reset the counter to zero with
<pre>
WriteTimer5(0);
</pre>

== More Information ==

NU32v2 timers

== Overview ==

== Details ==

== Library Functions ==

== Sample Code ==

== More Information ==

NU32v2: Starting a New Project and Putting it on the NU32v2

2011-01-15T21:46:07Z

Andrew Long:

Return to [[Microchip PICs#Using the NU32v2|Using the NU32v2]]

'''**THIS PAGE IS UNDER CONSTRUCTION AND IS NOT COMPLETE**'''

'''**AWL 1/15/2011**'''

= PIC32 Programming in C =

'''Note: Code downloaded from Microchip is constantly evolving, and it is possible that the information below will be outdated for future code releases. This information is accurate for code downloaded from Microchip's website in January 2011. Also, sample code developed by us and others are generally modified from working code for different purposes, and therefore you may find unnecessary legacy code, programming inefficiency, or even incorrect code in some samples.'''

You should complete the instructions in [[NU32v2: Software to Install]] if you have not already. For this page specifically, you need to

* download and install the MPLAB IDE (Integrated Development Environment) that you use for programming, compiling, debugging, and simulating your PIC code. The MPLAB C Compiler for PIC32 is included in the "complete" installation of the IDE
* download the Serial Bootloader for NU32v2 PC application
* install drivers for FTDI

The remainder of this page describes how to create a new Project in MPLAB, compile a general "Hello World" program to blink the LEDs on the NU32v2, and use the Serial Bootloader of NU32v2 PC application to put the program on the NU32v2.

= Create a New Project in MPLAB for the NU32v2 =

For organizational reasons, it is recommended to have a folder on your computer to store your PIC projects. If you do not already have a space to save your projects. Create a new folder and call it PIC_Projects. Each project should have its own folder inside PIC_Projects.

* Create a folder in PIC_Projects and call it HelloWorld
* Download this procdefs.ld file and place it in the new HelloWorld folder.

When creating new projects to download to the PIC, you must include a linker file. If you have installed a bootloader (such as with the NU32v2), the linker file tells the bootloader to put the program after the bootloader memory to prevent erasing of the bootloader. The required linker file is called procdefs.ld. You will always need to add this procdefs file to your project folders in order to properly install your programs on the PIC. If you do not use this procdefs file, you potentially could overwrite the bootloader.

* Open MPLAB
* Choose Project -> Project Wizard to create a new project.
* Click Next.
* Select the device you are using. The NU32v2 is using the PIC32MX795F512L.
* Choose the Microchip PIC32 C-Compiler Toolsuite from the drop down menu for Active Toolsuite. This sets up the compiler that will be used for creating the hex code that will be placed on the PIC. Click Next
* Create a new project called HelloWorld in the folder called HelloWorld (click browse to navigate to that folder). Click Next.
* Highlight the PROCDEFS.ld file under the HelloWorld folder and click Add. This adds the file to your project. For future projects, if you have existing .c and .h code, this is the step to add these files to your project. For this tutorial, we will be creating our own file, so no additional files need to be added.
* On this last step, it displays a summary of the previous steps. Click finish.

You have now created a project. The project window should appear as below.
[[Image:PIC32_ProjectWindow.jpg|thumb|300 px|left]]
 

The procdefs.ld is not the only linker file.
* In the project window, drag procdefs.ld from the 'Linker Script' folder to the 'Other Files' folder.
[[Image:PIC32_ProjectWindow2.jpg|thumb|300 px|left]]
 

Now we are going to create a .c file to add to this project.
* Choose File -> New.
* Choose File -> Save As and call the new file HelloWorld.c in the HelloWorld folder. This will create a source file for your code. You need to include '.c' on the file name, otherwise MPLAB does not know that it is a source file.
* Right click on the 'Source Files' folder and choose 'Add files'. Choose the HelloWorld.c file to add it to the project.
[[Image:PIC32_AddFiles1.jpg|thumb|300 px|left]]
 

You have now created a project and added a blank source file to your project. You are now ready to code your first program.

= HelloWorld Code =

This program will toggle on and off the two LEDS on the NU32v2 board.

You are now ready to edit your new HelloWorld.c file.

* Cut and paste the code below into your HelloWorld.c file.

/* HelloWorld.c
*
* Our first PIC program, which simply flashes LEDs on the NU32v2
* board. We have already installed a "bootloader" on our PIC32,
* which specifies "configuration bits" that set the clock frequency
* to 80 MHz (assuming the 8 MHz crystal on the NU32v2 board),
*
*
* HISTORY
* 1/15/2011 Created by Nick Marchuk, Andrew Long and Kevin Lynch
*
*/

// plib.h gives access to useful constant and function definitions, found in
// Program Files\Microchip\MPLAB C32\pic32-libs\include
#include <plib.h>

#define SYS_FREQ (80000000L) // clock frequency set by bootloader
#define LED_0 LATGbits.LATG12 // mnemonic constants for LEDs on NU32v2
#define LED_1 LATGbits.LATG13
#define WAIT_LOOPS 2000000 // number less than than 2^32 - 1, or about 4 billion

void initLEDs(void);
void delay(unsigned int loops);

int main(void) {
int i=0; // loop counter

// SYSTEMConfig() optimizes performance for our clock frequency.
// in Microchip\MPLAB C32\pic32-libs\include\peripheral\system.h
SYSTEMConfig(SYS_FREQ, SYS_CFG_WAIT_STATES | SYS_CFG_PCACHE);

initLEDs(); // set LED pins as outputs

LED_0 = 1; // low output turns an LED on; see NU32v2 circuit
LED_1 = 0; // high output turns an LED off

while(1) { // infinite loop

LED_0 = !LED_0; // toggle LED_0
LED_1 = !LED_1; // toggle LED_1

delay(WAIT_LOOPS);
}
return 0;
} // end main

/* initLEDs()
*
* initLEDs sets RG12 and RG13 to outputs to control the LEDs on the NU32v2.
*/
void initLEDs(void) {
// Read about setting digital inputs / outputs on the
// Digital input-output example
LATG |= 0x3000; // Initializes G12 and G13 to 1 (off for NU32v2 board)
TRISG &= 0xCFFF; // set the two pins to inputs

}

/* delay(unsigned int loops)
*
* This function just wastes time. Note; it just uses an int number of loops,
* which should be less than 2^32 - 1, or about 4 billion. If you really want
* to waste a lot of time, you could use a long long.
*/
void delay(unsigned int loops) {
int i = loops;
while(i--) {}
}

To load this program to the PIC with the bootloader, we need a hex file. MPLAB creates a hex file in the project folder when you compile the program.
* Choose Project -> Build all OR F10 on PCs.
The output window should say 'Build Succeeded'. If it doesn't, fix the errors.

= Using the Serial Bootloader for NU32v2 PC Application =

'''Under Construction'''

= PIC32 Programming in C with the MPLAB X Beta IDE =

Open 'MPLAB X IDE beta'. You will see the following screen.

Click Create New Project.

In Categories, select the Microchip Embedded folder. In Projects, select C/ASM Standalone Project. Click Next >.

In Family, select PIC32, and in Device, select PIC32MX795F512L.

In Select Tool, select PICkit3 if you are going to program the code onto your NU32v2, or select Simulator if you are going to practice coding on your computer.

In Select Compiler, select C32.

In Select Project Name and Folder, create a name for your project, select a location to save it to, ab

File:PIC32 AddFiles1.jpg

2011-01-15T21:45:25Z

Andrew Long:

NU32v2: Starting a New Project and Putting it on the NU32v2

2011-01-15T21:45:15Z

Andrew Long: /* Create a New Project in MPLAB for the NU32v2 */

Return to [[Microchip PICs#Using the NU32v2|Using the NU32v2]]

'''**THIS PAGE IS UNDER CONSTRUCTION AND IS NOT COMPLETE**'''

'''**AWL 1/15/2011**'''

= PIC32 Programming in C =

'''Note: Code downloaded from Microchip is constantly evolving, and it is possible that the information below will be outdated for future code releases. This information is accurate for code downloaded from Microchip's website in January 2011. Also, sample code developed by us and others are generally modified from working code for different purposes, and therefore you may find unnecessary legacy code, programming inefficiency, or even incorrect code in some samples.'''

You should complete the instructions in [[NU32v2: Software to Install]] if you have not already. For this page specifically, you need to

* download and install the MPLAB IDE (Integrated Development Environment) that you use for programming, compiling, debugging, and simulating your PIC code. The MPLAB C Compiler for PIC32 is included in the "complete" installation of the IDE
* download the Serial Bootloader for NU32v2 PC application
* install drivers for FTDI

The remainder of this page describes how to create a new Project in MPLAB, compile a general "Hello World" program to blink the LEDs on the NU32v2, and use the Serial Bootloader of NU32v2 PC application to put the program on the NU32v2.

= Create a New Project in MPLAB for the NU32v2 =

For organizational reasons, it is recommended to have a folder on your computer to store your PIC projects. If you do not already have a space to save your projects. Create a new folder and call it PIC_Projects. Each project should have its own folder inside PIC_Projects.

* Create a folder in PIC_Projects and call it HelloWorld
* Download this procdefs.ld file and place it in the new HelloWorld folder.

When creating new projects to download to the PIC, you must include a linker file. If you have installed a bootloader (such as with the NU32v2), the linker file tells the bootloader to put the program after the bootloader memory to prevent erasing of the bootloader. The required linker file is called procdefs.ld. You will always need to add this procdefs file to your project folders in order to properly install your programs on the PIC. If you do not use this procdefs file, you potentially could overwrite the bootloader.

* Open MPLAB
* Choose Project -> Project Wizard to create a new project.
* Click Next.
* Select the device you are using. The NU32v2 is using the PIC32MX795F512L.
* Choose the Microchip PIC32 C-Compiler Toolsuite from the drop down menu for Active Toolsuite. This sets up the compiler that will be used for creating the hex code that will be placed on the PIC. Click Next
* Create a new project called HelloWorld in the folder called HelloWorld (click browse to navigate to that folder). Click Next.
* Highlight the PROCDEFS.ld file under the HelloWorld folder and click Add. This adds the file to your project. For future projects, if you have existing .c and .h code, this is the step to add these files to your project. For this tutorial, we will be creating our own file, so no additional files need to be added.
* On this last step, it displays a summary of the previous steps. Click finish.

You have now created a project. The project window should appear as below.
[[Image:PIC32_ProjectWindow.jpg|thumb|300 px|left]]
 

The procdefs.ld is not the only linker file.
* In the project window, drag procdefs.ld from the 'Linker Script' folder to the 'Other Files' folder.
[[Image:PIC32_ProjectWindow2.jpg|thumb|300 px|left]]
 

Now we are going to create a .c file to add to this project.
* Choose File -> New.
* Choose File -> Save As and call the new file HelloWorld.c in the HelloWorld folder. This will create a source file for your code. You need to include '.c' on the file name, otherwise MPLAB does not know that it is a source file.
* Right click on the 'Source Files' folder and choose 'Add files'. Choose the HelloWorld.c file to add it to the project.
[[Image:PIC32_AddFiles1.jpg|thumb|300 px|left]]
 

You have now created a project and added a blank source file to your project. You are now ready to code your first program.

= HelloWorld Code =

This program will toggle on and off the two LEDS on the NU32v2 board.

You are now ready to edit your new HelloWorld.c file.

* Cut and paste the code below into your HelloWorld.c file.

/* HelloWorld.c
*
* Our first PIC program, which simply flashes LEDs on the NU32v2
* board. We have already installed a "bootloader" on our PIC32,
* which specifies "configuration bits" that set the clock frequency
* to 80 MHz (assuming the 8 MHz crystal on the NU32v2 board),
*
*
* HISTORY
* 1/15/2011 Created by Nick Marchuk, Andrew Long and Kevin Lynch
*
*/

// plib.h gives access to useful constant and function definitions, found in
// Program Files\Microchip\MPLAB C32\pic32-libs\include
#include <plib.h>

#define SYS_FREQ (80000000L) // clock frequency set by bootloader
#define LED_0 LATGbits.LATG12 // mnemonic constants for LEDs on NU32v2
#define LED_1 LATGbits.LATG13
#define WAIT_LOOPS 2000000 // number less than than 2^32 - 1, or about 4 billion

void initLEDs(void);
void delay(unsigned int loops);

int main(void) {
int i=0; // loop counter

// SYSTEMConfig() optimizes performance for our clock frequency.
// in Microchip\MPLAB C32\pic32-libs\include\peripheral\system.h
SYSTEMConfig(SYS_FREQ, SYS_CFG_WAIT_STATES | SYS_CFG_PCACHE);

initLEDs(); // set LED pins as outputs

LED_0 = 1; // low output turns an LED on; see NU32v2 circuit
LED_1 = 0; // high output turns an LED off

while(1) { // infinite loop

LED_0 = !LED_0; // toggle LED_0
LED_1 = !LED_1; // toggle LED_1

delay(WAIT_LOOPS);
}
return 0;
} // end main

/* initLEDs()
*
* initLEDs sets RG12 and RG13 to outputs to control the LEDs on the NU32v2.
*/
void initLEDs(void) {
// Read about setting digital inputs / outputs on the
// Digital input-output example
LATG |= 0x3000; // Initializes G12 and G13 to 1 (off for NU32v2 board)
TRISG &= 0xCFFF; // set the two pins to inputs

}

/* delay(unsigned int loops)
*
* This function just wastes time. Note; it just uses an int number of loops,
* which should be less than 2^32 - 1, or about 4 billion. If you really want
* to waste a lot of time, you could use a long long.
*/
void delay(unsigned int loops) {
int i = loops;
while(i--) {}
}

To load this program to the PIC with the bootloader, we need a hex file. MPLAB creates a hex file in the project folder when you compile the program.
* Choose Project -> Build all OR F10 on PCs.
The output window should say 'Build Succeeded'. If it doesn't, fix the errors.

= Compiling the "Hello World" example code for NU32v2 =

= Using the Serial Bootloader for NU32v2 PC Application =

= PIC32 Programming in C with the MPLAB X Beta IDE =

Open 'MPLAB X IDE beta'. You will see the following screen.

Click Create New Project.

In Categories, select the Microchip Embedded folder. In Projects, select C/ASM Standalone Project. Click Next >.

In Family, select PIC32, and in Device, select PIC32MX795F512L.

In Select Tool, select PICkit3 if you are going to program the code onto your NU32v2, or select Simulator if you are going to practice coding on your computer.

In Select Compiler, select C32.

In Select Project Name and Folder, create a name for your project, select a location to save it to, ab

File:PIC32 AddFiles.jpg

2011-01-15T21:44:54Z

Andrew Long: uploaded a new version of "Image:PIC32 AddFiles.jpg"

File:PIC32 AddFiles.jpg

2011-01-15T21:44:36Z

Andrew Long: uploaded a new version of "Image:PIC32 AddFiles.jpg"