dsPIC30F2010 CCS PICC Bootloaders Example

Overview

A boot-loader is a computer program that is responsible for booting a computer and booting an operating system. If it also provides an interactive menu with multiple boot choices then it's often called a boot manager.

dsPIC30F2010 ds18B20 Demo Program with Boot Loader

It also applicable for some 8-bit micro-controller with self re-programmable under software control capabilities, for instance the PIC16F877A, PIC16F887, PIC18F4550, dsPIC30F1010, dsPIC30F2010 etc. It's a block of micro-controller program that manage the process of loading embedded program to any location of Flash memory. It must locates at beginning or at the end of micro-controller Flash memory address.

The dsPIC30F2010 is a self re-programmable Flash micro-controller that allow the user to take the advantage of using a boot loader program.

Program Space Memory Map for dsPIC30F2010

The user just need to burn its boot-loader firmware once using a conventional device programmer, for instance a serial port JDM programmer or even a USB PICKIT3. Then the following embedded program must reserves the boot-loader memory section to prevent ROM program overwriting.  

Preliminary Boot Loader Firmware Flashing to dsPIC30F2010

The boot loader section should locate at the beginning or at the last section of Flash program memory space. However locating it at beginning is very suitable to prevent boot loader program overwriting that can destroy the boot loader functionalities. 

A boot-load embedded program can be uploaded to its target MCU an appropriate host PC boot-loader software on any OS platform via a typical serial port or even a USB port. CCS PICC provides a serial port and USB port boot-loader for some of their devices.

CCS PICC PCD Boot Loader Example

Boot Loader for 8-bit PIC Micro-controllers  

CCS PICC provide C boot/boot-loader C driver and example for its target chips. For its 8-bit PIC16 and PIC18 chips there are a "bootloader.h" header file and "loader.c" C driver. We can check its "ex_bootloader.c" for boot-loader firmware and "ex_bootload.c" for boot program example. In that example, the boot-loader firmware locates at the beginning of program memory. This example boot the program via RS-232 port.

On the other hand we can use CCS PICC Create Project Wizard to generate a boot-loader firmware for 8-bit PIC micro-controllers. There are two options, boot-loader at the start of memory and boot-loader at the end of memory. 

There many method of bootloading the program such as I2C and USB. 

Boot Loader for 16-bit PIC Micro-controllers  

Since the architecture of 16-bit DSC PIC micro-controllers are far different from the 8-bit PIC micro-controllers, the boot-loader C driver are in separated files. There are two C driver files, the "pcd_bootloader.h" and the "loader_pcd.c" C source files. 

There are two C examples file of using the PCD boot-loader firmware. The "ex_pcd_bootloader.c" is firmware of boot-loader prior to boot program. It requires a user input button and reset button to enter firmware loading mode. The "ex_pcd_bootload.c" C sample program is an example of loading the boot program into the chip. It use CCS PICC Serial Input/Output software and boot-loader software to load the program. In this program the boot-loader section locates at the beginning of the program.

Some newer version of CCS PICC as an instance of CCS PICC v5.119 has problem when compiling the boot-loader firmware for some dsPIC30FXXXX series. However I use an older version of CCS PICC v5.049 instead. It works very well without errors and problems.

CCS PICC v5.049 IDE

Boot Loader firmware

Initially I need to prepare a boot-loader firmware for my dsPIC30F2010 DSC.

pcd_bootloader.c

1. 
   /*CCS PICC Compiler version 5.049*/
2. #include <30F2010.h>
3. #fuses HS,NODEBUG,NOWDT,PR,CKSFSM
4. #use delay(clock=20000000)
5. #use rs232(BAUD=9600,UART1)
6. 
   
7. #define PUSH_BUTTON PIN_C14
8. #define BOOT_LED PIN_D0
9. 
   
10. #define _bootloader
11. //#define BOOTLOADER_MODE2X
12. 
    
13. #include <pcd_bootloader.h>
14. #include <loader_pcd.c>
15. 
    
16. #org APPLICATION_START
17. void application(void)
18. {
19. while(TRUE);
20. }
21. 
    
22. void main(void)
23. {
24. output_c(0);
25. output_d(0);
26. set_tris_d(0);
27. set_tris_c(1<<14);
28. //set_pullup(TRUE,PUSH_BUTTON);
29. output_high(PUSH_BUTTON);
30. if(!input(PUSH_BUTTON))
31. {
32. output_high(BOOT_LED);
33. // Let the user know it is ready to accept a download
34. printf("\r\nWaiting for download...");
35. // Load the program
36. load_program();
37. }
39. output_low(BOOT_LED);
40. application();
42. while(1);
44. }
45. 
    
46. #int_default
47. void isr(void)
48. {
49. jump_to_isr(LOADER_END+5);
50. }
51. 
    

After compile this program I need to burn its hex file into my target chip using a PICKIT2 device programmer.

Preliminary Boot Loader Firmware Flashing to dsPIC30F2010

From this point the dsPIC30F2010 has a start-of-memory boot-loader firmware. It doesn't need a device programmer any more. That is a blank program that contain only boot-loader section. To test how it works we just, 

1- press and hold the input push button connects to pin RC14

2- at the same time press the reset button and release them.

3- then you will see an LED(pin RD0) turns on the micro-controller enter its loading program mode. 

The dsPIC30F2010 Prototype Board waiting for program loading

 

dsPIC30F2010 waiting for loading program from host PC

 

Click here to download this example package.

Boot Load Example Program

From here we can load any firmware with a boot loader setting to dsPIC30F2010 via host PC serial port and CCS PICC boot loader software. I modify the "ex_pcd_bootload.c" to blinks an LED then I load it into the dsPIC30F2010 via CCS PICC boot-loader software.

1. 
   
2. /*CCS PICC Compiler version 5.049*/
3. #include <30F2010.h>
4. #fuses HS,NODEBUG,NOWDT,PR,CKSFSM
5. #use delay(clock=20M)
6. #use rs232(UART1,BAUD=9600)
7. 
   
8. //#define BOOTLOADER_MODE2X
9. 
   
10. //This is a necessary include file. It reserves space so that the
11. //bootloader is not overwritten.
12. #include <pcd_bootloader.h>
13. 
    
14. #define LED_0 PIN_D1
15. 
    
16. print_message(void){
17. delay_ms(10);
18. printf("\rCCS PICC v5.049 PCD BOOTLOADER\n\r");
19. }
20. 
    
21. void main()
22. {
23. print_message();
24. unsigned int16 counter=0;
25. output_d(0);
26. set_tris_d(0);
29. while(TRUE)
30. {
31. output_toggle(LED_0);
32. printf("Counter Variable: %Lu\n\r",counter);
33. counter++;
34. delay_ms(1000);
35. }
36. }

After compile this program we just press and hold the boot button, and then press and release the reset pin to enter programming loading mode.

Make sure that the SIOW.exe is already open and connected with an appropriate baud rate. 

press and hold the boot button, and then press and release the reset pin

 

CCS PICC SIOW Waiting for download

 

Click on CCS PICC Bootloader tool

 

Downloading Program

After the program downloading is completed the application on the MCU will run.

Running Program

 Click here to download this example.

ds18B20 LCD Example with Boot-Loader

I modify my program in this post adding a boot-loader program. However it consumes more program memory. I copied the "ds18b20.c" to my project folder since the older version of v5.049 doesn't have this driver.

• pcd_bootload_ds18b20_lcd.c

  

1. 
   /*CCS PICC Compiler version 5.049*/
2. #include <30F2010.h>
3. #fuses HS,NODEBUG,NOWDT,PR,CKSFSM
4. #use delay(clock=20M)
5. #use rs232(UART1,BAUD=9600)
6. 
   
7. //#define BOOTLOADER_MODE2X
8. 
   
9. //This is a necessary include file. It reserves space so that the
10. //bootloader is not overwritten.
11. #include <pcd_bootloader.h>
12. 
    
13. #define PIN_DS18B20_DATA PIN_B0
14. #include "ds18b20.c"
15. 
    
16. #define LCD_RS_PIN PIN_E4
17. #define LCD_RW_PIN PIN_E5
18. #define LCD_ENABLE_PIN PIN_E5
20. #define LCD_DATA4 PIN_E0
21. #define LCD_DATA5 PIN_E1
22. #define LCD_DATA6 PIN_E2
23. #define LCD_DATA7 PIN_E3
24. 
    
25. #include "lcd.c"
26. 
    
27. #define lcd_clear() lcd_putc('\f')
28. #define lcd_home() lcd_putc('\a')
29. /*For 16x4 LCD Only*/
30. #define line_1() lcd_send_byte(0,0x80);
31. #define line_2() lcd_send_byte(0,0xC0);
32. #define line_3() lcd_send_byte(0,0x90);
33. #define line_4() lcd_send_byte(0,0xD0);
34. 
    
35. print_message(void){
36. delay_ms(10);
37. printf("\rCCS PICC v5.049 PCD BOOTLOADER\n\r");
38. }
39. 
    
40. void main(){
41. print_message();
42. signed int16 val;
44. printf("\n\rdsPIC30F2010 Prototype Board.");
45. printf("\n\rSaturday 26th September 2025");
46. printf("\n\rds18b20 Humidity Sensor Example\n\r");
47. printf("\r\n\r\ds18b20.c - DHT11 example starting\r\n\r\n");
48. ds18b20_init();
49. lcd_init();
51. printf(LCD_PUTC,"dsPIC30F2010 LCD");
52. line_2();
53. printf(LCD_PUTC,"ds18b20 Sensor");
54. line_3();
55. printf(LCD_PUTC,"PCD BootLoader");
56. line_4();
57. printf(LCD_PUTC,"CCS PICC v5.049");
58. delay_ms(5000);
59. lcd_clear();
61. while(1){
62. ds18b20_read(&val);
63. printf("temperature = %ldC\r\n", val/(signed int16)16);
64. lcd_home();
65. printf(LCD_PUTC," ds18b20 Sensor");
66. line_2();
67. printf(LCD_PUTC," Temperature");
68. line_3();
69. printf(LCD_PUTC," %ld%cC",val/(signed int16)16,0xDF);
70. line_4();
71. printf(LCD_PUTC," and %f%cF",1.8*(val/(signed int16)16)+32,0xDF);
72. delay_ms(1000);
73. }
74. }

Since the boot-loader section locates at the start of program memory. It doesn't matter even the the compiled boot-load application exceeds the the ROM capacity. It just has an abnormal function.

CCS PICC Memory Use

 I tested it on my DIY dsPIC30F2010 Prototype Board.

Downloading the program

 

After uploading this program we can see the result.

Data send over serial port

 This C driver work fine as I prototype it on my PCBA.

dsPIC30F2010 ds18B20 Demo Program with Boot Loader

 

ds18B20 Temperature Sensor Reading

Click here to download this example.

 

DHT-11 LCD Example with Boot-Loader

I add this boot-load feature to my previous programming example that the dsPIC30F2010 read the humidity and temperature data from a DHT-11 environmental sensor. The result will display on a TC1604A-04 16x4 LCM. 

1. 
   
2. /*CCS PICC Compiler version 5.049*/
3. #include <30F2010.h>
4. #fuses HS,NODEBUG,NOWDT,PR,CKSFSM
5. #use delay(clock=20M)
6. #use rs232(UART1,BAUD=9600)
7. 
   
8. //#define BOOTLOADER_MODE2X
9. 
   
10. //This is a necessary include file. It reserves space so that the
11. //bootloader is not overwritten.
12. #include <pcd_bootloader.h>
13. 
    
14. #define LED_0 PIN_D1
15. 
    
16. #define PIN_DHT11_DATA PIN_B0
17. #include "dht11.c"
19. #define LCD_RS_PIN PIN_E4
20. #define LCD_RW_PIN PIN_E5
21. #define LCD_ENABLE_PIN PIN_E5
23. #define LCD_DATA4 PIN_E0
24. #define LCD_DATA5 PIN_E1
25. #define LCD_DATA6 PIN_E2
26. #define LCD_DATA7 PIN_E3
27. 
    
28. #include "lcd.c"
29. 
    
30. #define lcd_clear() lcd_putc('\f')
31. #define lcd_home() lcd_putc('\a')
32. /*For 16x4 LCD Only*/
33. #define line_1() lcd_send_byte(0,0x80);
34. #define line_2() lcd_send_byte(0,0xC0);
35. #define line_3() lcd_send_byte(0,0x90);
36. #define line_4() lcd_send_byte(0,0xD0);
37. 
    
38. print_message(void){
39. delay_ms(10);
40. printf("\rCCS PICC v5.049 PCD BOOTLOADER\n\r");
41. }
42. 
    
43. void main()
44. {
45. print_message();
46. unsigned int8 relativeHumidity;
47. unsigned int8 tempC;
49. printf("\n\rdsPIC30F2010 Prototype Board.");
50. printf("\n\rFriday 26 September 2025");
51. printf("\n\rDHT-11 Humidity Sensor Example\n\r");
52. printf("\r\n\r\dht-11.c - DHT11 example starting\r\n\r\n");
54. dht11_init();
55. lcd_init();
57. printf(LCD_PUTC,"dsPIC30F2010 LCD");
58. line_2();
59. printf(LCD_PUTC,"DHT-11 Sensor");
60. line_3();
61. printf(LCD_PUTC,"PCD BootLoader");
62. line_4();
63. printf(LCD_PUTC,"CCS PICC v5.049");
64. delay_ms(5000);
65. lcd_clear();
67. while(1){
68. dht11_read(&relativeHumidity, &tempC);
69. printf("HUMIDITY=%03u%%, TEMPERATURE=%02uC\r\n", relativeHumidity, tempC);
70. lcd_home();
71. printf(LCD_PUTC," DHT-11 Sensor");
72. line_2();
73. printf(LCD_PUTC," Reading:");
74. line_3();
75. printf(LCD_PUTC,"Humidity: %03u%%",relativeHumidity);
76. line_4();
77. printf(LCD_PUTC,"Temperature:%02u%cC",tempC,0xDF);
78. output_toggle(LED_0);
79. delay_ms(1000);
80. }
81. }

 The total line of program instructions is less then the previous example (275 instructions).

Program Uploading

 The sensor data also send over the PC serial port.

 

CCS PICC SIOW Data Sending

Start-Up Program

Environmental Data Reading/Displaying

 

Click here to download this example.

dsPIC30F2010 Prototype Board CCS PICC Examples (Continue)

In previous post I putted some examples of using the dsPIC30F2010 prototype board. However it's too long. So I need to write some remaining posts here.

PCBWay.com Sponsor PCB Project

 

Creating a PWM Output Using Code Generation Wizard

Generating a PWM output signal could be done from scratch with a few line of code using CCS PICC. We can use its code generation wizard or even manually. 

PWM Output Pin of OC1

 

After clicking on Create Project it will generate source code. Then pressing F9 to compile this project.

The main.c C source code is just like below.

1. #include <main.h>
2. 
   
3. 
   
4. void main()
5. {
6. 
   
7. while(TRUE)
8. {
9. //TODO: User Code
10. }
11. 
    
12. }

 Then double click on the main.h header file we will see its source code.

1. #include <30F2010.h>
2. #device ICSP=1
3. #use delay(crystal=20000000)
4. 
   
5. #FUSES NOWDT //No Watch Dog Timer
6. #FUSES CKSFSM //Clock Switching is enabled, fail Safe clock monitor is enabled
7. 
   
8. 
   
9. #use pwm(OC1,TIMER=2,FREQUENCY=10000,DUTY=0)

It will generate a PWM signal output at pin OC1 (RC13) with a frequency of 10kHz and 0% duty cycle. If we want a 50% duty cycle we need to change the DUTY parameter to 50, and rebuilt it.

PWM Duty Cycle Adjusting with ADC

After using the code generation wizard I got some idea of using PWM in CCS PICC. So I modify and write more codes to adjust PWM signal. I use the on-board ADC input from a potentiometer. Then it will convert to PWM duty cycle ranging from 0% to 100%.

1. #include "board.h"
2. 
   
3. #use pwm(OC1,TIMER=2,FREQUENCY=10000,STREAM=_1,DUTY=50)
4. void main()
5. {
6. long adc_value = 0;
7. float duty_cycle = 0;
8. setup_adc_ports(sAN4);
9. setup_adc(ADC_CLOCK_INTERNAL | ADC_TAD_MUL_31);
10. 
    
11. 
    
12. while(TRUE)
13. {
14. //TODO: User Code
15. set_adc_channel(4);
16. delay_us(10);
17. adc_value = read_adc();
18. duty_cycle = (1000.0*adc_value)/1023;
19. pwm_set_duty(_1,(int)duty_cycle);
20. //pwm_set_duty_percent(_1,(int)duty_cycle);
21. delay_ms(100);
22. }
23. 
    
24. }

And its "board.h" file:

1. #include <30F2010.h>
2. #device ADC=10
3. #device ICSP=1
4. #fuses HS,NODEBUG,NOWDT,PR,CKSFSM
5. #use delay(crystal=20000000)
6. 
   
7. 
   
8. #use FIXED_IO( D_outputs=PIN_D1,PIN_D0 )
9. #use rs232(UART1, baud=9600, stream=UART_PORT1)
10. 
    
11. #define LED0 PIN_D0
12. #define LED1 PIN_D1
13. #define SW0 PIN_C13
14. #define SW1 PIN_C14
15. 
    
16. #define DELAY 500
17. 
    

It work fine without wiring additional components. However we can connect the OC1(RC13) PWM pin to a larger LED ( for instance a 5VDC 10mm LED).

 

Low Duty Cycle

High Duty Cycle

Click here to download its source file.  

ADC with On-board Tactile Switches and PWM

Fortunately there are two on-board tactile switches that could be used to adjust PWM duty cycle. So I will use ADC channel 4, SW4 (RC13) and SW5(RC14) to adjust PWM duty cycle of OC1 and OC2 respectively.

PWM Adjustment Using Pot and Tactile Switches

The PWM OC1 is generated by Timer 2 while the PWM OC2 is generated by Timer 3. 

1. #include "board.h"
2. 
   
3. #use pwm(OC1,TIMER=2,FREQUENCY=10000,STREAM=_1,DUTY=0)
4. #use pwm(OC2,TIMER=3,FREQUENCY=10000,STREAM=_2,DUTY=0)
5. 
   
6. void main()
7. {
8. long adc_value = 0;
9. int oc2_count=0;
10. float duty_cycle = 0;
11. set_pullup(TRUE,PIN_C13);
12. set_pullup(TRUE,PIN_C14);
13. setup_adc_ports(sAN4);
14. setup_adc(ADC_CLOCK_INTERNAL | ADC_TAD_MUL_31);
15. 
    
16. while(TRUE)
17. {
18. //TODO: User Code
19. set_adc_channel(4);
20. delay_us(10);
21. adc_value = read_adc();
22. duty_cycle = (1000.0*adc_value)/1023;
23. pwm_set_duty(_1,(int)duty_cycle);
25. if(input(SW0)==0){
26. if(oc2_count<1000) oc2_count+=100;
27. pwm_set_duty(_2,oc2_count);
28. delay_ms(250);
29. }
30. if(input(SW1)==0){
31. if(oc2_count>0) oc2_count-=100;
32. pwm_set_duty(_2,oc2_count);
33. delay_ms(250);
34. }
35. }
36. 
    
37. }

Its "board.h" header file:

1. #include <30F2010.h>
2. #device ADC=10
3. #device ICSP=1
4. #fuses HS,NODEBUG,NOWDT,PR,CKSFSM
5. #use delay(crystal=20000000)
6. 
   
7. #use rs232(UART1, baud=9600, stream=UART_PORT1)
8. 
   
9. #define LED0 PIN_D0
10. #define LED1 PIN_D1
11. #define SW0 PIN_C13
12. #define SW1 PIN_C14
13. 
    
14. #define DELAY 500
15. 
    

Click here to download its source file.

Timer Tick Example

We can use timer tick for timing delay and scheduling instead of using the delay function. We can call it from scratch using the CCS PICC IDE PIC24 project wizard.

Timer Tick Example Using Timer 1

 Then we get generated code lists below.

• main.h

1. #include <30F2010.h>
2. #device ICSP=1
3. #use delay(crystal=20000000)
4. 
   
5. #FUSES NOWDT //No Watch Dog Timer
6. #FUSES CKSFSM //Clock Switching is enabled, fail Safe clock monitor is enabled
7. 
   
8. 
   
9. #use timer(timer=1,tick=100us,bits=32,NOISR)
10. 
    
11. #define TICK_TYPE unsigned int32

• main.c

 

1. #include <main.h>
2. TICK_TYPE GetTickDifference(TICK_TYPE currTick, TICK_TYPE prevTick)
3. {
4. return(currTick-prevTick);
5. }
6. 
   
7. void timer_1_tick(void)
8. {
9. //TODO: User Code
10. }
11. 
    
12. 
    
13. void main()
14. {
15. 
    
16. TICK_TYPE CurrentTick,PreviousTick;
17. 
    
18. 
    
19. 
    
20. //Example program using Tick Timer
21. CurrentTick = PreviousTick = get_ticks();
22. 
    
23. while(TRUE)
24. {
25. CurrentTick = get_ticks();
26. 
    
27. if(GetTickDifference(CurrentTick, PreviousTick) >= ((TICK_TYPE)TICKS_PER_SECOND*1)/1000)
28. {
29. timer_1_tick();
30. PreviousTick = CurrentTick;
31. }
32. 
    
33. //TODO: User Code
34. }
35. 
    
36. }

 Then I need to add some codes to these existing source codes.

•  main.h

 

1. #include <30F2010.h>
2. #device ICSP=1
3. #use delay(crystal=20000000)
4. 
   
5. #FUSES NOWDT //No Watch Dog Timer
6. #FUSES CKSFSM //Clock Switching is enabled, fail Safe clock monitor is enabled
7. 
   
8. 
   
9. #use FIXED_IO( D_outputs=PIN_D1,PIN_D0 )
10. 
    
11. #define LED1 PIN_D0
12. #define LED2 PIN_D1
13. 
    
14. 
    
15. #use timer(timer=1,tick=100us,bits=32,NOISR)
16. 
    
17. #define TICK_TYPE unsigned int32
18. 
    

• main.c

1. #include <main.h>
2. 
   
3. unsigned int16 count_1_ms=0, count_100_ms=0;
4. 
   
5. TICK_TYPE GetTickDifference(TICK_TYPE currTick, TICK_TYPE prevTick)
6. {
7. return(currTick-prevTick);
8. }
9. 
   
10. void timer_1_tick(void)
11. {
12. //TODO: User Code
13. count_1_ms++;
14. if(count_1_ms>=100) {
15. output_toggle(LED2);
16. count_1_ms=0;
17. count_100_ms++;
18. }
19. if(count_100_ms>=5){
20. output_toggle(LED1);
21. count_100_ms=0;
22. }
23. }
24. 
    
25. 
    
26. void main()
27. {
28. 
    
29. TICK_TYPE CurrentTick,PreviousTick;
30. 
    
31. 
    
32. 
    
33. //Example program using Tick Timer
34. CurrentTick = PreviousTick = get_ticks();
35. 
    
36. while(TRUE)
37. {
38. CurrentTick = get_ticks();
39. 
    
40. if(GetTickDifference(CurrentTick, PreviousTick) >= ((TICK_TYPE)TICKS_PER_SECOND*1)/1000)
41. {
42. timer_1_tick();
43. PreviousTick = CurrentTick;
44. }
45. 
    
46. //TODO: User Code
47. }
48. 
    
49. }

 It will blink LEDs connect to RD0 and RD1 at different rates.

 

RD0 and RD1 at different rates

RD0 and RD1 at different rates

 Click here to download its source file.

Timer 1 Interrupt Example Using Coder Generation Wizard

Timer1 module operates in many modes up to software configuration, internal, gated and external. We can write its source manually or even using the CCS PICC code generation wizard. 

Using Code Generation Wizard

Then it will generate a skeleton code below that we have to add more code manually.

1. #include <main.h>
2. 
   
3. #INT_TIMER1
4. void timer1_isr(void)
5. {
6. 
   
7. }
8. 
   
9. 
   
10. 
    
11. void main()
12. {
13. 
    
14. setup_timer1(TMR_INTERNAL | TMR_DIV_BY_1, 1000);
15. 
    
16. enable_interrupts(INT_TIMER1);
17. enable_interrupts(INTR_GLOBAL);
18. 
    
19. while(TRUE)
20. {
21. //TODO: User Code
22. }
23. 
    
24. }

 Then I need to add more codes both in main function and Timer interrupt service routine "#INT_TIMER1".

 

1. #include <main.h>
2. 
   
3. unsigned int16 timer_1_counts=0;
4. #INT_TIMER1
5. void timer1_isr(void)
6. {
7. output_toggle(PIN_D0);
8. timer_1_counts++;
9. clear_interrupt(INT_TIMER1);
10. }
11. 
    
12. 
    
13. 
    
14. void main()
15. {
16. 
    
17. setup_timer1(TMR_INTERNAL | TMR_DIV_BY_256, 1000);
18. 
    
19. enable_interrupts(INT_TIMER1);
20. enable_interrupts(INTR_GLOBAL);
21. 
    
22. while(TRUE)
23. {
24. //TODO: User Code
25. if(timer_1_counts>=100){
26. output_toggle(pin_d1);
27. timer_1_counts=0;
28. }
29. }
30. 
    
31. }

This source codes will blink pin RD0 and RD1 at different rates. Click here to download its source file.

Change Notify (CN) Interrupt

Change Notify Interrupt (CNI) allow the program to fast response to external event change. For instance a change from logic high to low or vice versa. There are two tactile switches connect to RC13(CN1) and RC14(CN0) respectively. There are no external pull up or pull down resistors. So you need to add more external components to detect input logic change requirement.

TABLE 8-2: INPUT CHANGE NOTIFICATION REGISTER MAP (BITS 15-0)

Fortunately the Change Notify Interrupt (CNI) come with internal pull-up enable feature that we can enable or disable it by software setting. The CNENx and CNPUx special register responsible for this task. 

 

The program below demonstrate a simple use of Change Notify (CN) Interrupt of pin CN0(RC14). The LED connects to pin RD0 keeps blinking at the rate of 500ms in main program's loop. Whenever the CN0 input logic changes to logic low the CNI occurs. It will toggle the LED connects to pin RD1.

• main.c 

1. #include <main.h>
2. 
   
3. /*CN Pull Up Enable Register*/
4. #byte CNPU1=0x0C4;
5. #bit CN0PU=CNPU1.0;
6. /*CN Interrupt Enable Register*/
7. #byte CNIEN1=0x0C0;
8. #bit CN0EN=CNIEN1.0;
9. 
   
10. /*Interrupt Service Routine for CN Interrupt*/
11. #INT_CNI
12. void cni_isr(void)
13. {
14. if(!input(CN0)) output_toggle(LED2);
15. clear_interrupt(INT_CNI);
16. }
17. 
    
18. 
    
19. void main()
20. {
21. /*PortC As Inputs*/
22. set_tris_c(0xFFFF);
23. /*Turn On CN0 PullUp and CN0 Interrupt*/
24. CN0PU=1;
25. CN0EN=1;
26. /*Enable Interrupt*/
27. enable_interrupts(INTR_CN_PIN|PIN_C13);
28. enable_interrupts(INTR_GLOBAL);
29. clear_interrupt(INT_CNI);
30. while(TRUE)
31. {
32. //TODO: User Code
33. output_toggle(LED1);
34. delay_ms(500);
35. }
36. 
    
37. }

•  main.h

1. #include <30F2010.h>
2. #device ICSP=1
3. #use delay(crystal=20000000)
4. 
   
5. #FUSES NOWDT
6. //No Watch Dog Timer
7. #FUSES CKSFSM
8. //Clock Switching is enabled, fail Safe clock monitor is enabled
9. 
   
10. 
    
11. #use FIXED_IO( D_outputs=PIN_D1,PIN_D0 )
12. 
    
13. #define CN1 PIN_C13
14. #define CN0 PIN_C14
15. #define LED1 PIN_D0
16. #define LED2 PIN_D1
17. 
    
18. 
    

 I tested this demo program on my dsPIC30F2010 prototype board. It work fine and very fast. Click here to download this example program.

Now I use all tactile switches connect to RC13 and RC14 to generate Change Notification Interrupt (CNI). Every time the CN interrupts occur it will toggle the LEDs.

• main.c

 

1. #include <main.h>
2. 
   
3. /*CN Pull Up Enable Register*/
4. #byte CNPU1=0x0C4;
5. #bit CN0PU=CNPU1.0;
6. #bit CN1PU=CNPU1.1;
7. /*CN Interrupt Enable Register*/
8. #byte CNIEN1=0x0C0;
9. #bit CN0EN=CNIEN1.0;
10. #bit CN1EN=CNIEN1.1;
11. 
    
12. /*Interrupt Service Routine for CN Interrupt*/
13. #INT_CNI
14. void cni_isr(void)
15. {
16. if(!input(CN0)) output_toggle(LED2);
17. if(!input(CN1)) output_toggle(LED1);
18. clear_interrupt(INT_CNI);
19. }
20. 
    
21. 
    
22. void main()
23. {
24. /*PortC As Inputs*/
25. set_tris_c(0xFFFF);
26. /*Turn On CN0 PullUp and CN0 and CN1 Interrupt*/
27. CN0PU=1;
28. CN0EN=1;
29. CN1PU=1;
30. CN1EN=1;
31. /*Enable Interrupt*/
32. //enable_interrupts(INTR_CN_PIN|PIN_C13);
33. //enable_interrupts(INTR_CN_PIN|PIN_C14);
34. enable_interrupts(INT_CNI);
35. enable_interrupts(INTR_GLOBAL);
36. clear_interrupt(INT_CNI);
37. while(TRUE)
38. {
39. //TODO: User Code
40. }
41. 
    
42. }

I take some special registers of CN interrupt to use in this program because using the CCS PICC built-in library is not enough.

• main.h

1. #include <30F2010.h>
2. #device ICSP=1
3. #use delay(crystal=20000000)
4. 
   
5. #FUSES NOWDT
6. //No Watch Dog Timer
7. #FUSES CKSFSM
8. //Clock Switching is enabled, fail Safe clock monitor is enabled
9. 
   
10. 
    
11. #use FIXED_IO( D_outputs=PIN_D1,PIN_D0 )
12. 
    
13. #define CN1 PIN_C13
14. #define CN0 PIN_C14
15. #define LED1 PIN_D0
16. #define LED2 PIN_D1
17. 
    
18. 
    
19. 
    

There are some bounce while pressing the tactile switches. So it's suitable to add and RC filter circuit to eliminate this noise. Using a software delay in the ISR is a good choice to bypass this noisy bouncing period.

 

Click here to download this program example.