dsPIC30F4011

The dsPIC Microntroller

This section contains several useful pieces of sample code for different tasks on the dsPIC. There is just one example question (at the end), which provides a reasonably detailed description of an imagined control scenario for which you are asked to write a dsPIC program in C.

Introduction

The microcontroller that we use in the Robotics module lab sessions and mini-project belongs to the PIC range, which is produced by Microchip Inc. (see http://www.microchip.com/). This range of microcontrollers contains hundred of different chips, grouped into several product families. Microcontrollers with features similar to those in the PIC range are available from many other manufacturers (e.g. Texas Instruments, Intel, Atmel, etc.), but to keep things simple in this module we always use the same microcontroller – Microchip’s dsPIC30F4011.

Like all chips in the 30F family, the dsPIC30F4011 is a 16-bit microcontroller. What that means is that each of its registers (aka memory locations) stores one 16-bit binary number. The dsPIC chips we use come in a 40-pin dual in-line package (DIP). In this context, the word ‘package’ simply refers to the actual body of the chip – the block of dark plastic in which the tiny silicon integrated circuit is permanently encased (rather than the wrapping the chip is sold in). DIP chips have a standard pin size and spacing that makes them suitable for plugging straight into a breadboard. It is possible to buy the exact same dsPIC in a much smaller surface-mount package, but it cannot then be used easily in a breadboard. The DIP package is therefore much more convenient for the ad hoc experimental work we do in the Robotics lab.

The following are some of the main reasons why the dsPIC30F4011 was chosen as the microcontroller for this module:

• It is available in a DIP form factor, which makes it convenient for prototyping work on a breadboard.
• It has a wide supply voltage range (2.5-5.5V). This means that it can be used with a variety of different power supplies or battery packs and that it can be interfaced easily to other chips which may be less accommodating about supply voltage.
• Electrically speaking, it is quite robust. Of course a dsPIC can be damaged by applying excessive voltage to the wrong pin. However, in my own experience, when something isn’t working in the Robotics lab, it very rarely turns out to be a faulty dsPIC chip that’s causing the problem.
• It provides up to 9 10-bit analog input channels.
• Because it has 40 pins, there are plenty of available pins for digital I/O (input and output).
• Because the 30F4011 is specifically targetted at motor control applications, it provides three dedicated pairs of PWM outputs. These can be used for lots of interesting things, but they provide a particularly convenient way of controlling up to three servos.
• The dsPIC is cheap and are not hard to buy at short notice. The exact price varies depending on when you buy it, who you buy it from and how many you buy, but a rough guideline is between €4 and €5 per chip in small quantities. There are other microcontrollers (including some PICs) that can be bought for a fraction of this cost, but for the broad range of applications we are interested in the dsPIC provides excellent flexibility for its price.
• Development software (MPLAB and the C30 compiler among others) is available free of charge.
• The dsPIC can be programmed using the PICkit2 USB programmer, which only costs about €30 and provides some other useful features (basic logic analyser, 5V serial input).

Please take a few minutes to read the full list of features on pages 1 and 2 of the dsPIC30F4011 datasheet. Of the dsPIC-related documents supplied by the manufacturer, those which are most useful to have at your side while programming are the following:

• The dsPIC30F4011/4012 Data Sheet
• The dsPIC30F Family Reference Manual (available to download in sections from this link)

From here on, I will mostly refer to the dsPIC30F4011 simply as the ‘dsPIC’. However, do please bear in mind that there are many many other models in this family, each with a different combination of features and/or shape and size. Nevertheless, the basic principles of operation are identical across the 30F range of microcontrollers and once you have learned to program one you should be able to transfer that knowedge to other chips in the same family without much difficulty.

Analog input

The following example program demonstrates basic analog input on the dsPIC30F4011. Only one channel is read (AN0), although the ‘read_analog_channel()’ function should work without modification for the other analog inputs on the chip. The sampling time is controlled manually and is currently set to 1µs, which should be adequate for any signal source with a source impedance below the maximum value recommended by the manufacturer of the dsPIC (5kΩ). The total time per measurement (including sampling time and conversion time) should be less than 2.5µs.

//
// This is a simple analog input example for the dsPIC30F4011
// It configures the lowest 8 PORTB pins as analog inputs, then reads
// the voltage on AN0 repeatedly. The input voltage determines
// the brightness of an LED on RD0 by varying its duty cycle
// in proportion to the analog input reading.
//
// Written by Ted Burke - last updated 5-12-2010
//

#include <libpic30.h>
#include <p30f4011.h>

_FOSC(CSW_FSCM_OFF & FRC_PLL16); // Clock speed = 7.5MHz x 16, i.e. 30 MIPS
_FWDT(WDT_OFF); // Watchdog timer off

void configure_pins();
unsigned int read_analog_channel(int n);

int main()
{
	long int n;

	// Set up which pins are which
	configure_pins();

	while(1)
	{
		// Read the analog channel. The result is an
		// integer between 0 and 1023 inclusive.
		n = read_analog_channel(0);

		// LED on
		_LATD0 = 1;
		__delay32(30*n); // m us

		// LED off
		_LATD0 = 0;
		__delay32(30*(1023 - n)); // (1023-m) us
	}

	return 0;
}

void configure_pins()
{
	// Configure digital I/O
	LATD = 0;
	TRISD = 0b11111110;

	// Configure analog inputs
	TRISB = 0x01FF;      // Port B all inputs
	ADPCFG = 0xFF00;     // Lowest 8 PORTB pins are analog inputs
	ADCON1 = 0;          // Manually clear SAMP to end sampling, start conversion
	ADCON2 = 0;          // Voltage reference from AVDD and AVSS
	ADCON3 = 0x0005;     // Manual Sample, ADCS=5 -> Tad = 3*Tcy = 0.1us
	ADCON1bits.ADON = 1; // Turn ADC ON
}

// This function reads a single sample from the specified
// analog input. It should take less than 2.5us if the chip
// is running at about 30 MIPS.
unsigned int read_analog_channel(int channel)
{
	ADCHS = channel;          // Select the requested channel
	ADCON1bits.SAMP = 1;      // start sampling
	__delay32(30);            // 1us delay @ 30 MIPS
	ADCON1bits.SAMP = 0;      // start Converting
	while (!ADCON1bits.DONE); // Should take 12 * Tad = 1.2us
	return ADCBUF0;
}

PWM – Pulse Width Modulation

One feature of the dsPIC30F4011 that is very useful in control, automation and robotics is that it provides three dedicated pairs of PWM output pins, each of which can be used to control a servo, to vary the speed of a DC motor, or for many other purposes.

The PWM signal generated on each of the outputs depends on a number of factors:

• The instruction cycle, . In the robotics lab, we almost always run the dsPIC at 30 MIPS, which gives a value of .
• The prescale value. I have set this equal to 64 in this example (see the ‘configure_pins’ function). Basically, this means that the PWM timebase (which is the PTMR register) increments just once every 64 instruction cycles.
• The PTPER register stores an unsigned 15-bit number that sets the value up to which the timebase has to count before it resets to zero (thus initiating a new PWM pulse). The value in this register determines the PWM period.
• The registers PDC1, PDC2 and PDC3 each store an unsigned 16-bit number that determines the duty cycles for the corresponding PWM channel (1, 2 or 3).

The PWM period, , is calculated as follows:

In the example below, I have set PTPER equal to 9470 so that the PWM period will be 20ms (suitable for controlling the servos).

The pulse width (aka duty cycle) on PWM channel 1 is controlled by the unsigned 16-bit integer stored in register PDC1. The formula for calculating the pulse width is as follows:

Of course, the same formula can be used with PDC2 and PDC3 to control the pulse width on PWM channels 2 and 3 respectively.

The following program is an example of PWM output from the six motor PWM pins on the dsPIC30F4011. The duty cycle of each of the three PWM channels is controlled by an analog input. The duty cycle of each channel should vary between 0-100%. All three PWM channels are configured in complementary mode – i.e. the two pins in each channel are always at opposite logic levels. The PWM period should be 20ms.

//
// This program is an example of the motor PWM facility on the
// dsPIC30F4011.
//
// Written by Ted Burke - last updated 4-12-2010
//

#include <libpic30.h>
#include <p30f4011.h>

// Configuration settings
_FOSC(CSW_FSCM_OFF & FRC_PLL16);  // Fosc=16x7.5MHz, Fcy=30MHz
_FWDT(WDT_OFF);                   // Watchdog timer off
_FBORPOR(MCLR_DIS);               // Disable reset pin

// Function prototypes
void configure_pins();
unsigned int read_analog_channel(int n);

int main()
{
	int voltage;

	// Set up which pins are which
	configure_pins();

	while(1)
	{
		// Analog input 0 controls PWM 1 duty cycle.
		voltage = read_analog_channel(0);
		PDC1 = (int)((voltage / 1023.0) * 2 * PTPER);

		// Analog input 1 controls PWM 2 duty cycle.
		voltage = read_analog_channel(1);
		PDC2 = (int)((voltage / 1023.0) * 2 * PTPER);

		// Analog input 2 controls PWM 3 duty cycle.
		voltage = read_analog_channel(2);
		PDC3 = (int)((voltage / 1023.0) * 2 * PTPER);
	}

	return 0;
}

void configure_pins()
{
	// Configure RD0 as a digital output
	LATD = 0;
	TRISD = 0b11111110;

	// Configure analog inputs
	TRISB = 0x01FF;      // Port B all inputs
	ADPCFG = 0xFF00;     // Lowest 8 PORTB pins are analog inputs
	ADCON1 = 0;          // Manually clear SAMP to end sampling, start conversion
	ADCON2 = 0;          // Voltage reference from AVDD and AVSS
	ADCON3 = 0x0005;     // Manual Sample, ADCS=5 -> Tad = 3*Tcy = 0.1us
	ADCON1bits.ADON = 1; // Turn ADC ON

	// Configure PWM for free running mode
	// PWM period = Tcy * prescale * PTPER = 0.33ns * 64 * 9470 = 20ms
	PWMCON1 = 0x00FF; // Enable all PWM pairs in complementary mode
	PTCON = 0;
	_PTCKPS = 3;      // prescale=1:64 (0=1:1, 1=1:4, 2=1:16, 3=1:64)
	PTPER = 9470;     // 20ms PWM period (15-bit period value)
	PDC1 = 0;         // 0% duty cycle on channel 1 (max is 65536)
	PDC2 = 0;         // 0% duty cycle on channel 2 (max is 65536)
	PDC3 = 0;         // 0% duty cycle on channel 3 (max is 65536)
	PTMR = 0;         // Clear 15-bit PWM timer counter
	_PTEN = 1;        // Enable PWM time base
}

// This function reads a single sample from the specified
// analog input. It should take less than 2.5us if the chip
// is running at about 30 MIPS.
unsigned int read_analog_channel(int channel)
{
	ADCHS = channel;          // Select the requested channel
	ADCON1bits.SAMP = 1;      // start sampling
	__delay32(30);            // 1us delay @ 30 MIPS
	ADCON1bits.SAMP = 0;      // start Converting
	while (!ADCON1bits.DONE); // Should take 12 * Tad = 1.2us
	return ADCBUF0;
}

Timer interrupts – repeating an action at regular intervals

Sometimes, we want to make the dsPIC perform the same action over and over again at a regular time interval. For example, we might want to flash an LED by toggling a digital output pin once every 500ms. Or we might want to read an analog input once every 10ms. The dsPIC provides a very convenient way of designating a function in our C program that it will automatically call at a regular interval that we specify. The dsPIC uses one of its timers to tell it when to call the function. When the timer reaches a particular value (which we have specified in our program) the dsPIC interrupts whatever it is doing and jumps to the designated function, which we call the interrupt service routine (ISR).

Here’s a quick example that used a timer interrupt to flash an LED.

//
// This is a Timer 1 interrupt example for the dsPIC30F4011.
// Timer 1 is a 16-bit Type A timer.
// It toggles an LED on pin RD0 8 times a second.
//
// Written by Ted Burke - last updated 5-12-2010
//

#include <p30f4011.h>

// Clock speed = 7.5MHz x 16, i.e. 30 MIPS
_FOSC(CSW_FSCM_OFF & FRC_PLL16);

// Watchdog timer off
_FWDT(WDT_OFF);

// Function prototype for Timer 1 interrupt service routine
void __attribute__((__interrupt__, __auto_psv__)) _T1Interrupt(void);

int main()
{
    // Configure RD0 (pin 23) as digital output for the LED
    LATD = 0;
    TRISD = 0b11111110;

    // Configure Timer 1
    // In this example, I'm setting PR1 and TCKPS for 8Hz
    T1CON = 0;            // Clear the Timer 1 configuration
    TMR1 = 0;             // Reset Timer 1 counter
    PR1 = 14648;          // Set the Timer 1 period (max 65535)
    T1CONbits.TCS = 0;    // Select internal clock (Fosc/4)
    T1CONbits.TCKPS = 3;  // Prescaler (0=1:1, 1=1:8, 2=1:64, 3=1:256)
    _T1IP = 1;            // Set the Timer 1 interrupt priority
    _T1IF = 0;            // Clear the Timer 1 interrupt flag
    _T1IE = 1;            // Enable Timer 1 interrupt
    T1CONbits.TON = 1;    // Turn on Timer 1

    // Lock the main function here in an empty loop and let
    // the Timer 1 interrupt service routine do all the work.
    while(1);

    return 0;
}

// Timer 1 interrupt service routine
void __attribute__((__interrupt__, __auto_psv__)) _T1Interrupt(void)
{
    // Clear Timer 1 interrupt flag
    _T1IF = 0;

    // Toggle LED
    if (_LATD0) _LATD0 = 0; else _LATD0 = 1;
}

Sending text from the dsPIC to the PC via the UART

When we write a C program to run on a PC, we often use the printf function to display text messages on the screen. In general, the dsPIC has no screen attached to it, but we can still use printf to display messages via a serial connection to a PC. The dsPIC contains a subsystem called a UART (universal asynchronous receiver and transmitter) which allows data to be transmitted and received serially (i.e. as a sequence of ones and zeros, represented by high and low voltages) via a pair of pins.

The following program is an example of serial data transmission from the dsPIC30F4011 UART. This program repeatedly reads 10-bit analog readings from AN0-AN7 and then prints the results to the serial output. The baud rate is set to 38,400. However, occasional glitches may be observed in the incoming data because I’ve used the internal RC oscillator to clock the PIC, so it’s probable that F_cy (and therefore the baud rate) is somewhat inaccurate.

//
// This program is a UART transmission example for the dsPIC30F4011.
//
// To compile this, a heap size must be specified because
// printf is used. I set my heap size to 1024 in MPLAB
// as follows:
//
//	Project->Build Options...->Project->MPLAB LINK30->Heap size = 1024
//
// Apparently, a heap size of 0 might be ok for printf, but
// for scanf a bigger number may be required (e.g. 1024).
//
// Written by Ted Burke - last updated 4-12-2010
//

#include <libpic30.h>
#include <p30f4011.h>
#include <stdio.h>

// Configuration settings
_FOSC(CSW_FSCM_OFF & FRC_PLL16); // Fosc=16x7.5MHz, Fcy=30MHz
_FWDT(WDT_OFF);                  // Watchdog timer off
_FBORPOR(MCLR_DIS);              // Disable reset pin

// Function prototypes
void configure_pins();
unsigned int read_analog_channel(int n);

int main()
{
	// Variables to store analog input voltages
	int v0, v1, v2, v3, v4, v5, v6, v7;

	// Set up which pins are which
	configure_pins();

	while(1)
	{
		// Read AN0-AN7
		v0 = read_analog_channel(0);
		v1 = read_analog_channel(1);
		v2 = read_analog_channel(2);
		v3 = read_analog_channel(3);
		v4 = read_analog_channel(4);
		v5 = read_analog_channel(5);
		v6 = read_analog_channel(6);
		v7 = read_analog_channel(7);

		// Print the measured voltages on the serial o/p
		printf("AN0=%04d, AN1=%04d, AN2=%04d, AN3=%04d, ", v0, v1, v2, v3);
		printf("AN4=%04d, AN5=%04d, AN6=%04d, AN7=%04d\r\n", v4, v5, v6, v7);
	}

	return 0;
}

void configure_pins()
{
	// Configure RD0 as a digital output
	LATD = 0;
	TRISD = 0b11111110;

	// Configure analog inputs
	TRISB = 0x01FF;      // Port B all inputs
	ADPCFG = 0xFF00;     // Lowest 8 PORTB pins are analog inputs
	ADCON1 = 0;          // Manually clear SAMP to end sampling, start conversion
	ADCON2 = 0;          // Voltage reference from AVDD and AVSS
	ADCON3 = 0x0005;     // Manual Sample, ADCS=5 -> Tad = 3*Tcy
	ADCON1bits.ADON = 1; // Turn ADC ON

	// Set up UART
	// Default is 8 data bits, 1 stop bit, no parity bit
	U1BRG = 48;            // 38400 baud @ 30 MIPS
	U1MODEbits.UARTEN = 1; // Enable UART
	U1STAbits.UTXISEL = 1; // interrupt when TX buffer is empty
	U1STAbits.UTXEN = 1;   // Enable TX
}

// This function reads a single sample from the specified
// analog input. It should take less than 2.5us if the chip
// is running at about 30 MIPS.
unsigned int read_analog_channel(int channel)
{
	ADCHS = channel;          // Select the requested channel
	ADCON1bits.SAMP = 1;      // start sampling
	__delay32(30);            // 1us delay @ 30 MIPS
	ADCON1bits.SAMP = 0;      // start Converting
	while (!ADCON1bits.DONE); // Should take 12 * Tad = 1.2us
	return ADCBUF0;
}

I recorded the serial output of this program in the PICkit2 UART tool. Here’s a few lines of what it produced:

AN0=0116, AN1=0079, AN2=0000, AN3=0666, AN4=0466, AN5=0328, AN6=0230, AN7=0162
AN0=0116, AN1=0079, AN2=0000, AN3=0666, AN4=0472, AN5=0330, AN6=0232, AN7=0164
AN0=0114, AN1=0079, AN2=0000, AN3=0666, AN4=0472, AN5=0332, AN6=0234, AN7=0165
AN0=0116, AN1=0079, AN2=0000, AN3=0666, AN4=0472, AN5=0334, AN6=0236, AN7=0168
AN0=0115, AN1=0078, AN2=0000, AN3=0661, AN4=0469, AN5=0333, AN6=0233, AN7=0165
AN0=0117, AN1=0079, AN2=0000, AN3=0661, AN4=0469, AN5=0333, AN6=0237, AN7=0167
AN0=0119, AN1=0081, AN2=0000, AN3=0661, AN4=0469, AN5=0333, AN6=0237, AN7=0167
AN0=0121, AN1=0083, AN2=0000, AN3=0661, AN4=0469, AN5=0333, AN6=0240, AN7=0169

Example Question

Question:

You are writing a C program for the dsPIC controller in a service elevator, which is used to transport one trolley at a time carrying materials from the ground floor delivery area of a factory to the production line on the first floor. The elevator should behave as follows:

• The empty elevator should wait on the ground floor for a trolley to be placed in it.
• When a trolley is detected by the weight sensor, the elevator should wait for two seconds then begins ascending to the first floor.
• When the elevator reaches the first floor, it should stop and wait for the trolley to be removed.
• When the trolley is removed, the elevator should wait for two seconds then begin descending to the ground floor.
• When the elevator reaches the ground floor, it should stop and wait for the next trolley to arrive.

The elevator is driven up and down by a DC motor, which is controlled by two of the dsPIC’s digital output pins (RD0 and Rd1) as follows:

• When both pins are low (or both pins are high) the elevator is stationary.
• When RD0 = 0 and RD1 = 1 the elevator is ascending.
• When RD0 = 1 and RD1 = 0 the elevator is descending.

The position of the elevator is sensed using a pair of contact switches that are connected to two of the dsPIC digital input pins (RD2 and RD3) as follows:

• RD2 = 1 when the elevator is at the ground floor; RD2 = 0 otherwise.
• RD3 = 1 when the elevator is at the first floor; RD3 = 0 otherwise.

The elevator is fitted with an analog weight sensor that outputs a voltage between 0V and 5V. The weight sensor output is connected to pin AN0 on the dsPIC.

• When a full trolley is in the elevator, the output voltage of the weight sensor is guaranteed to be greater than 3V.
• When no trolley is in the elevator, the output voltage of the weight sensor is guaranteed to be less than 2V.

Write a C program to control the elevator. You can assume that the appropriate pins have already been designated as digital inputs, digital outputs, analog inputs, etc. Assume also that a function “read_analog_channel (int x)” has been provided, which returns a 10-bit unsigned integer representing the analog voltage on analog input channel x (i.e. pin ANx). Assume also that a function “delay_ms(int n)” has been provided which delays for the specified number of milliseconds.

Before writing the program, we just need to know what values the ADC will read at the two critical threshold voltages (2V and 3V). The full input voltage range of the ADC is 0V-5V and because it is a 10-bit device, there are voltage levels over that range (i.e. from 0 to 1023). The ADC output at the lower threshold (2V) is calculated as follows:

Similarly, the ADC output at the upper threshold voltage (3V) is calculated as follows:

So, when the ADC reads the voltage on pin AN0 and the result is less than 410, there is definitely no trolley in the elevator. Conversely, when the ADC reads AN0 and the result is greater than 614, there is definitely a full trolley in the elevator.

int main()
{
	int weight;

	configure_pins();

	// Keep going up and down as described in
	// the question.
	while(1)
	{
		// Elevator is at ground floor.
		// Wait for trolley to arrive.
		weight = read_analog_channel(0); // read the weight sensor
		while(weight <= 614)
		{
			weight = read_analog_channel(0); // read the weight sensor
		}

		// A full trolley has arrived
		// Wait 2 seconds
		delay_ms(2000);

		// Send elevator upwards
		_LATD0 = 0;
		_LATD1 = 1;

		// Keep going until we reach the first floor.
		// RD3 will go high only when we are at the first floor.
		// Keep busy doing nothing until then.
		while(_RD3 == 0) {}

		// Stop the elevator
		_LATD0 = 0;
		_LATD1 = 0;

		// Elevator is at first floor.
		// Wait for trolley to leave.
		weight = read_analog_channel(0); // read the weight sensor
		while(weight >= 410)
		{
			weight = read_analog_channel(0); // read the weight sensor
		}

		// The trolley is gone
		// Wait 2 seconds
		delay_ms(2000);

		// Send elevator downwards
		_LATD0 = 1;
		_LATD1 = 0;

		// Keep going until we reach the first floor
		while(_RD2 == 0) {}

		// Stop the elevator
		_LATD0 = 0;
		_LATD1 = 0;
	}

	return 0;
}