dsPIC30F4011 Examples

This page presents useful information on writing C programs for the dsPIC30F4011, including:

• What software to install.
• How to connect the PICkit 2 to the dsPIC30F4011.
• How to compile a C program for dsPIC30F4011 and download it onto the chip using the PICkit 2 application.
• Short examples of several dsPIC30F4011 features, including analog input, timers, serial i/o, etc.
• A “super example”, which combines various functionality into a single longer example.

What software to install

Most people use MPLAB to develop programs for the dsPIC30F4011. However, having experienced persistent problems after upgrading from version 8.x to MPLAB X, I have now completely abandoned it. Instead, I use a plain text editor to write my C programs, Microchip’s XC16 compiler to build them, and the PICkit 2 software application to download the compiled hex files onto the dsPIC. This is the approach that I use and that I recommend to others. The process described below is Windows-specific.

I have always thought that the process of creating new programs in MPLAB was insanely complicated. I just don’t see the merit of creating a “project” and “workspace” with all kinds of mysterious files and subdirectories just to compile what (in my case at least) is invariably a single C file. The approach described below does away with all this – just place your C program (a single C file) in its own directory and compile it to produce a hex file – that’s it.

What to install:

1. The Notepad++ text editor, which is free and provides many useful features. Notepad++ is a great piece of software that I use all the time. However, you could use just about any plain text editor, including Notepad which is provided in Windows.
2. The XC16 C compiler, which is available for free from microchip.com. The download is about 120 MB in size.
3. The PICkit 2 application, which can also be downloaded free of charge from microchip.com.

Connecting the PICkit 2 to the dsPIC30F4011

Here’s a simple circuit to get the dsPIC up and running with the PICkit 2 on a breadboard:

A simple example program

Here’s a simple example program to blink the LED on pin RD0 in the circuit shown above:

//
// dsPIC30F4011 example - blink an LED on RD0
// Written by Ted Burke, Last updated 6-3-2013
//

#include <xc.h>
#include <libpic30.h>

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

int main(void)
{
	// Make RD0 a digital output
	_TRISD0 = 0;
	
	// Blink LED on RD0
	while(1)
	{
		_LATD0 = 1;
		__delay32(15000000);
		_LATD0 = 0;
		__delay32(15000000);
	}
}

I create a new folder for every dsPIC program I write. For this example, I will assume the above code is saved as “main.c” in the folder “D:\blink\”. To compile this program, I use a simple build script, which saves me from typing in the unwieldy compiler command directly. I use the exact same 2-line build script (shown below) for every dsPIC30F4011 program. Save the lines below into a file called “build.bat” in the same folder as “main.c”

xc16-gcc main.c -mcpu=30F4011 -Wl,--script=p30F4011.gld
if errorlevel 0 xc16-bin2hex a.out

At this point the program folder should contain two files:

To run the build script, open a console window, navigate to the folder where your program files are located, and type the following command:

build.bat

Here’s what that looks like in my console window:

Assuming that the C program compiles without errors, two new files will be added to the directory, “a.out” and “a.hex”. The latter file is the one that will be transferred to flash memory on the dsPIC using the PICkit 2 application.

Make sure that the PICkit 2 is connected to the dsPIC circuit, and then launch the PICkit 2 application:

Assuming the PICkit 2 is correctly connected to the circuit, the message circled in red above should be visible: “PICkit 2 found and connected. PIC Device Found.”

To download the hex file onto the dsPIC, click the “Auto Import Hex + Write Device” button (circled in blue above) and browse to find the file “a.hex” in the same directory as “main.c”. Once “a.hex” is selected the download process should begin. After a few seconds you should see the “Programming Successful” message circled in red below.

To actually run the program on the dsPIC, you may need to tick the VDD check box (circled in blue above) to supply power to the circuit. If all is well, the LED should start blinking.

Digital i/o

This program uses one digital output (RD0) and one digital input (RD1). When RD1 is high, an LED on RD0 blinks fast; when RD1 is low, the LED blinks slow.

The function __delay32() (defined in “libpic30.h”) creates a delay of the specified number of instruction cycles. In this example, the dsPIC is running at 30 MIPS (million instructions per second) so, for example, “__delay32(15000000)” creates a delay of half a second. The number “32” in the function name refers to the fact the that specified number of instruction cycles is a 32 bit unsigned value, allowing very long delays to be generated with a single call.

The same build script as for the simple example above should be used.

//
// dsPIC30F4011 example - blink an LED fast or slow
// Written by Ted Burke, Last updated 6-3-2013
//

#include <xc.h>
#include <libpic30.h>

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

int main(void)
{
	// Make RD0 a digital output
	_TRISD0 = 0;
	
	// Make RD1 a digital input
	_TRISD1 = 1;
	
	// Blink LED on RD0
	while(1)
	{
		// Toggle RD0 (turn LED on or off)
		_LATD0 = 1 - _LATD0;
		
		// Either delay for 0.1 or 0.5 seconds
		if (_RD1 == 0) __delay32(3000000); // 0.1 second delay
		else __delay32(15000000); // 0.5 second delay
	}
}

Analog input

//
// dsPIC30F4011 example - read an analog input
// Written by Ted Burke, Last updated 6-3-2013
//

#include <xc.h>
#include <libpic30.h>

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

unsigned int read_analog_channel(int channel);

int main(void)
{
	int voltage;
	
	// Make RD0 a digital output
	_TRISD0 = 0;
		
	// Configure AN0-AN8 as analog inputs
	ADCON3bits.ADCS = 15;  // Tad = 266ns, conversion time is 12*Tad
	ADCON1bits.ADON = 1;   // Turn ADC ON

	// Blink LED on RD0
	while(1)
	{
		// Toggle RD0 (turn LED on or off)
		_LATD0 = 1 - _LATD0;
		
		// Length of delay depends on AN0 pin voltage
		voltage = read_analog_channel(0);
		__delay32(voltage * 30000L);
	}
}

// This function reads a single sample from the specified
// analog input. It should take less than 5us when the
// microcontroller is running at 30 MIPS.
// The dsPIC30F4011 has a 10-bit ADC, so the value
// returned is between 0 and 1023 inclusive.
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 = 3.2us
	return ADCBUF0;
}

Serial output

TO BE WRITTEN

Serial input

TO BE WRITTEN

Using a timer

TO BE WRITTEN

Using a timer interrupt

TO BE WRITTEN

Pulse Width Modulation

TO BE WRITTEN

dsPIC30F4011 Super Example

This is my dsPIC30F4011 “super example”. When I’m writing a program for this handy microcontroller, I often use this template code as my starting point and trim out whatever I don’t need.

This example includes the following features (further details below):

• Digital output
• Analog input
• PWM output
• Serial output via UART
• Serial input via UART
• Timer 1 interrupt

//
// dsPIC30F4011 Super Example
// Written by Ted Burke
// Last updated 27-8-2012
//
// Featuring digital i/o, analog input,
// PWM output, UART Tx/Rx, Timer 1 ISR.
//

#include <xc.h>
#include <stdio.h>
#include <libpic30.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 setup();
unsigned int read_analog_channel(int n);

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

int main()
{
	int voltage;
	char c;

	// Set up digital i/o, analog input, PWM, UART and interrupt
	setup();

	while(1)
	{
		// Read a voltage from AN0 and print it via serial port
		voltage = read_analog_channel(0);
		printf("Voltage = %d\r\n", voltage);

		// Toggle LED on RD0
		_LATD0 = 1 - _LATD0;

		// Check if any characters were received via UART
		if (U1STAbits.URXDA == 1)
		{
			c = U1RXREG;
			if (c == '2') _LATD2 = 1 - _LATD2;
			if (c == '3') _LATD3 = 1 - _LATD3;
		}

		__delay32(6000000); // 200ms delay
	}

	return 0;
}

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

	// Toggle LED on RD1
	_LATD1 = 1 - _LATD1;
}

// This function sets up digital i/o, analog input,
// PWM, UART and timer interrupt.
void setup()
{
	// Configure all 4 port D pins as digital outputs
	TRISD = 0;

	// Configure AN0-AN8 as analog inputs
	ADCON3bits.ADCS = 15;  // Tad = 266ns, conversion time is 12*Tad
	ADCON1bits.ADON = 1;   // Turn ADC ON

	// Configure PWM for free running mode
	//
	//   PWM period = Tcy * prescale * PTPER = 0.33ns * 64 * PTPER
	//   PWM pulse width = (Tcy/2) * prescale * PDCx
	//
	PWMCON1 = 0x00FF;     // Enable all PWM pairs in complementary mode
	PTCONbits.PTCKPS = 3; // prescale=1:64 (0=1:1, 1=1:4, 2=1:16, 3=1:64)
	PTPER = 9375;         // 20ms PWM period (15-bit period value)
	PDC1 = 1406;          // 1.5ms pulse width on PWM channel 1
	PDC2 = 1406;          // 1.5ms pulse width on PWM channel 2
	PDC3 = 1406;          // 1.5ms pulse width on PWM channel 3
	PTMR = 0;             // Clear 15-bit PWM timer counter
	PTCONbits.PTEN = 1;   // Enable PWM time base

	// Setup UART
	U1BRG = 48;            // 38400 baud @ 30 MIPS
	U1MODEbits.UARTEN = 1; // Enable UART

	// Configure Timer 1
	// In this example, I'm setting PR1 and TCKPS for 8Hz
	PR1 = 14648;          // Set the Timer 1 period (max 65535)
	TMR1 = 0;             // Reset Timer 1 counter
	IEC0bits.T1IE = 1;    // Enable Timer 1 interrupt
	T1CONbits.TCKPS = 3;  // Prescaler (0=1:1, 1=1:8, 2=1:64, 3=1:256)
	T1CONbits.TON = 1;    // Turn on Timer 1
}

// This function reads a single sample from the specified
// analog input. It should take less than 5us when the
// microcontroller is running at 30 MIPS.
// The dsPIC30F4011 has a 10-bit ADC, so the value
// returned is between 0 and 1023 inclusive.
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 = 3.2us
	return ADCBUF0;
}

This code is written for Microchip’s XC16 compiler (xc16-gcc.exe). You can compile it in MPLAB X, but personally I’ve been having a lot of reliability problems with the IDE, so I’m currently just using a plain text editor (Notepad++) to edit my programs and a simple makefile to manage the build process with XC16. I use the (very useful) PICkit2 helper application to transfer my compiled hex file to the dsPIC chip. To be honest, I’m finding this way of working way more convenient than using MPLAB X, which takes forever to start on my laptop and really just doesn’t run all that well. By comparison, Notepad++ / XC16 / PICkit2 all run really smoothly and aren’t giving me any reliability problems. I’m not using a debugger at all – I just use printf a lot!

Here’s my makefile:

MP_CC_DIR="D:\Program Files\Microchip\xc16\v1.00\bin"
MP_CC="D:\Program Files\Microchip\xc16\v1.00\bin\xc16-gcc.exe"

all: super.hex

super.cof: main.c
	$(MP_CC) main.c -o super.cof -mcpu=30F4011 -Wall -Wl,--script=p30F4011.gld

super.hex: super.cof
	$(MP_CC_DIR)\\xc16-bin2hex super.cof -a -omf=elf

If you want something even simpler (I always want something simpler!) you can try the following build script. If you don’t have make installed, this will be easier to use than the Makefile above. Assuming you have XC16 installed, just save the following into a file called “build.bat” in the same folder as your “main.c” file. To run it, open a command window, move to the folder where your main.c file is located and type “build”. It should create a file called “a.hex” which is ready to be programmed onto the dsPIC (for example using the PICkit 2 application).

xc16-gcc main.c -mcpu=30F4011 -Wl,--script=p30F4011.gld
if errorlevel 0 xc16-bin2hex a.out