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.
 

Arduino rotates a small servo motor with buttons

 

A servo is a kind of motor built in a module. The module contains a DC motor and a feed back control circuit. The feed back circuit regulates the motor rotating position to a specific angle receives from its master MCU, for example and Arduino.

Picture of this example

Controlling the position needs a specific timing. Conventionally, the signal timing frequency is 50 Hz. For more information about the servo motor timing, see this post. 

Servo motors are available in many physical sizes and interfaces. Choosing a servo motor depends on the application. With Arduino, there are many libraries to interface with external hardware module, including the servo motor. The Servo.h is already available after the installing of Arduino IDE. Servo control pin can be any where within the digital I/O pin and it's selected by source code writing.

To use the servo library we must #include <Servo.h>. Additionally, we must create a servo object, for example,

Servo sg90;

Using a very simple servo motor like the SG90 requires a few methods.

1. attach() - sg90.attach(pin) : where pin is any pin on the Arduino board in use.
2. write() - sg90.write(angle): where angle is between 0 and 190 degree.

Other sophisticated  servo motors have an angle reading line. But we don't need it here, as a simple example.

SG90 servo from device's specification

A typical servo SG90 has three lines - GND, VCC and Control. Control and VCC line requires a +5V pulse. Control line is the orange one's. It's no other than a PWM signal with low frequency.

SG90 pin diagram and its timing from the device's specification

In this example post, I use three tactile switches to rotate a SG90 servo motor with three corresponding angles 0 , 90 and 180 degrees respectively. I use four pin A0, A1, A2 and A3. 

Some required parts

Connections Diagram

Arduino code from Github gist lists below.

Click here to download Arduino sketch.

Arduino rotates a servo motor using a potentiometer

In the previous post, I use three tactile switches to rotate a servo motor to three angle positions. However, using a potentiometer, we can continuously rotates the angle of servo motor in accordance to the adjustment of the potentiometer. 

A picture of this example

With the  Arduino Servo.h and analogRead function, this task could be done easily. In this example, a potentiometer connects to pin A0 work as an analog input adjusting the angle of rotation. A servo again, connects to pin A3.

Connections Diagram

The analogRead() function return a 10-bit (1024) value from any reading from a specific analog input pin. Hence, this analog value must convert from 1024 to 180 in degree. This could be done by a simple equation as will be shown in source code.

Click here to download the sketch archive of this example.

ATMega32 Timer/Counter1 in Fast PWM Mode

Introduction

Timer/Counter1 module of ATMega32 is configurable to operate in fast Pulse Width Modulation (PWM) mode. There are two PWM blocks inside this module - PWM A and PWM B. Hence there are two corresponding output pins for these two blocks - OC1A and OC1B.

PWM output pulse has two mode, non-inverting and inverting mode. Its set and clear output pulse is the comparison between TCNT1 and OC1X register (OC1A or OC1B).

Fast PWM Mode - Timing Diagram

To make ATMega32 operates in this mode, user must set WGM13:0 of  Timer/Counter1 Control Register (TCCR1x) to 5, 6, 7, 14, or 15. Its frequency is calculated as below.

Fast PWM Mode Frequency

Its resolution is between 8 and 10-bit. Where,

Fast PWM Resolution

Programming

We need to configure some registers for fast PWM mode.

• Timer/Counter1 Control Register A (TCCR1A)

TCCR1A

This register contains some settings for fast PWM mode. Compare Output Mode bits used for selecting between inverting and non-inverting mode of fast PWM mode.

Compare Output Mode Bits of TCCR1A

Waveform Generation Mode Bits must be set to any value as listed to make this module operates in fast PWM mode.

Waveform Generation Mode Bits

• Timer/Counter1 Control Register B (TCCR1B)

This register contains prescaler selection for fast PWM mode. 

TCCR1B

Clock Select Bits (CS12:10) allow user to set its prescaler effecting output frequency of fast PWM.

Clock Selection Bits

• Output Compare Register A 

This is a pair of 8-bit registers - OCR1AH and OCR1AL. This register is a compare variable of TCNT1 that toggle output waveform of PWM signal.

Output Compare Register A

Now we make a simple example of using fast PWM. PWM A generates its output waveform on OC1A pin with a frequency of 490Hz, and 50% duty cycle. Output signal is non-inverting mode. Its resolution is 8-bit.

Schematic Diagram

Microcontroller clock is 16MHz from external crystal oscillator.

Source Code:

/*

 * timer_1_fast_pwm_8_bit_1.c

 *

 * Created: 2/10/2021 3:41:04 PM

 * Author : admin

 */ 

#include <avr/io.h>

int main(void)

{

/*OC1A PD5 Output*/

DDRD|=(1<<5);

/*Non-inverting mode, fast PWM 8-bit*/

TCCR1A=(1<<COM1A1)|(1<<COM1B1)|(1<<WGM12)|(1<<WGM10);

/*1:64 Prescaler*/

TCCR1B=(1<<CS11)|(1<<CS10);

/*Select 50% duty cycle*/

OCR1AH=0;

OCR1AL=127;

    while (1) 

    {

    }

}

Click here to download archive. 

Now let use both of this PWM output of Timer/Counter1 module. Either OC1A and OC1B output signal are inverting with different duty cycle, but its frequency is unique. 

Simulation screen shot

Source code:

/*

 * timer_1_fast_pwm_8_bit_2.c

 *

 * Created: 3/3/2021 8:38:00 PM

 * Author : admin

 */ 

#include <avr/io.h>

int main(void)

{

    /*OC1A and OC1B Output*/

DDRD=(1<<5)|(1<<4);

/*inverting fast PWM 8-bit*/

TCCR1A=(1<<COM1A1)|(1<<COM1B1)|(1<<COM1A0)|(1<<WGM12)|(1<<WGM10);

/*1::64 Pre-Scaler*/

TCCR1B=(1<<CS11)|(1<<CS10);

/*OC1A duty cycle*/

OCR1AH=0;

OCR1AL=127;

/*OC1B duty cycle*/

OCR1BH=0;

OCR1BL=75;

    while (1) 

    {

    }

}

Click here to download this example.