ermicroblog

Blog Entry

H-Bridge Microchip PIC Microcontroller PWM Motor Controller

January 26, 2009 by rwb, under Microcontroller.

One of the advantages using the Microchip PIC microcontroller Pulse Width Modulation or PWM for short is; this PWM peripheral circuit is designed to control the DC motor using the full bridge mode PWM feature. The PWM peripheral works by supplying the correct signal to the H-Bridge DC motor circuit such as speed controlling and changing the DC motor direction. Therefore on this tutorial we will learn to use this sophisticated feature offered by Microchip PIC PWM. For those with the AVR microcontroller background this is also a good chance to learn the beauty of the different between AVR and PIC microcontroller especially in the PWM peripheral features.

PWM is used in many industrial mostly for controlling the motor speed. How this PWM signal could change the DC motor speed is showed on this following PWM signal timing diagram:

From the PWM timing diagram above we could see that by changing the pulse width we could change the average voltage receipt by the DC motor; the wider the pulse width; the higher the average voltage receipt by the DC motor. The shorter the pulse width, the lower the average voltage receipt by the DC motor. Therefore by varying the pulse width we could vary the DC motor speed. The ratio between the pulse width and the total length of the pulse (time on plus time off) is called duty cycle, so by saying 100% duty cycle means the DC motor is in it’s full speed and 10% duty cycle the DC motor is in it’s 10% of speed. We are going to use this following H-Bridge circuit schema on our project:

The circuit above basically is the H-Bridge transistor circuit which connected to the PIC 16F690 PWM pins through the PIC PWM output ports P1A, P1B, P1C and P1D. For more detail how the H-Bridge circuit works you could refer to the “Using Transistor as a Switch” posted on this blog.

The following is the list of hardware and software used in this tutorial:

1. PICJazz 16F690 learning board from ermicro (the PICJazz 16F690 schema)
2. One 5 to 6 volt DC Motor (in this project I’am using geared DC Motor)
3. Four 2K2 Ohm ¼ watt resistor for the H-Bridge circuit
4. Four BC639 transistors (or equivalent) for the H-Bridge circuit
5. Four 1N4148 diodes for the H-Bridge circuit
6. One 100nF (0.1uF) 16 volt for the H-Bridge circuit
7. JazzMate 2576-5V power board, the 5 volt switching power supply from ermicro for the H-Bridge circuit.
8. Microchip MPLAB IDE v8.0 or higher
9. HITEC PICC-Lite PICC-Lite Version 9.60PL1
10. Microchip PICKit2 Programmer

In this tutorial first we will learn how to use the basic single output PWM mode and later on we will use the full bridge PWM mode for controlling the H-Bridge motor circuit.

1. The PIC16F690 Microcontroller PWM peripheral

The heart of PIC16F690 PWM lays on the TIMER2 peripheral, this timer is used as the basic counter generator used by the PWM peripheral to generating the PWM pulse, the following is the PIC 16F690 simplify PWM peripheral diagram (for complete explanation please refer to the datasheet):

The TMR2 counter register clock is supplied by the prescale circuit which can be selected using the T2CKPS1 and T2CKPS0 bits in the T2CON register, the TMR2 register value is compared to the PR2 register which determine the TOP value of TMR2 counter register. When the TMR2 value is equal to the PR2 value, then the TMR2 counter register will be reset to 0.

At the same time the value of TMR2 counter register is compared to the CCPR1L register value (actually with the CCPR1H register value, but since the CCPR1H equal to the CCPR1L than we could just say CCPR1L), when the TMR2 value equal to the CCPR1L register value than the PWM peripheral circuit will reset the CCP1 output (logical “0“) and when the TMR2 counter register equal to the PR2 register value than it will set the CCP1 output (logical “1“). Therefore the PR2 register determine the PWM period, by changing the PR2 value we could change the PWM period and this mean changing the PWM frequency as well. The PWM period could be calculated using this following formula:

PWM period = (PR2 + 1) x 4 x Tosc x (TMR2 prescale value) second

Where Tosc is the system clock period in second

PWM frequency = 1 / PWM Period Hz

While the PWM pulse width is depend on the CCPR1L register value, therefore by varying the CCPR1L register value, we could change the PWM pulse width. The PWM width can be calculated using this following formula:

PWM width = (CCPR1L:CCP1CON<5:4>) x Tosc x (TMR2 prescale value) second

This following table shows the PWM frequency and resolution with the 8 MHz clock:

The PWM output behavior is controlled by the CCP1CON, PWM1CON and PSTRCON registers, we will talk about these three registers shortly, but the important think to remember that all the TRIS (three states input/output) register for each of the PWM output ports: P1A, P1B, P1C and P1D should be set to the output mode.

 

2. Single Output Mode PWM

With single output PWM mode we could sent the same PWM signal to each of available PWM pins (i.e. P1A, P1B, P1C and P1D) or to all of them at the same time. Our first C program example will show you how this single output PWM mode works. Ok let’s pasting this following code into your Microchip MPLAB IDE:

// ***************************************************************************
//  File Name    : pwm.c
//  Version      : 1.0
//  Description  : Pulse Width Modulation (PWM)
//                 Single Output, Steering Mode
//  Author(s)    : RWB
//  Target(s)    : PICJazz 16F690 Board
//  Compiler     : HITECT PICC-Lite Version 9.60PL1
//  IDE          : Microchip MPLAB IDE v8.00
//  Programmer   : PICKit2
//  Last Updated : 03 Jan 2009
// ***************************************************************************
#include <pic.h>

/*   PIC Configuration Bit:
**   INTIO     - Using Internal RC No Clock
**   WDTDIS    - Wacthdog Timer Disable
**   PWRTEN    - Power Up Timer Enable
**   MCLREN    - Master Clear Enable
**   UNPROTECT - Code Un-Protect
**   UNPROTECT - Data EEPROM Read Un-Protect
**   BORDIS    - Borwn Out Detect Disable
**   IESODIS   - Internal External Switch Over Mode Disable
**   FCMDIS    - Monitor Clock Fail Safe Disable
*/
__CONFIG(INTIO & WDTDIS & PWRTEN & MCLREN & UNPROTECT \
  & UNPROTECT & BORDIS & IESODIS & FCMDIS);

// Using Internal Clock of 8 MHz
#define FOSC 8000000L

// Delay Function
#define	_delay_us(x) { unsigned char us; \
		       us = (x)/(12000000/FOSC)|1; \
		       while(--us != 0) continue; }

void _delay_ms(unsigned int ms)
{
  unsigned char i;

  if (ms == 0) return;
  do {
    i = 4;
    do {
      _delay_us(164);
    } while(--i);
  } while(--ms);
}

void main(void)
{
  unsigned int ipwm;
  unsigned char state;

  OSCCON=0x70;         // Select 8 MHz internal clock

  TRISC = 0x00;        // Set All on PORTC as Output
  ANSEL = 0x00;        // Set PORT AN0 to AN7 digital I/O
  ANSELH = 0x00;       // Set PORT AN8 to AN11 as Digital I/O
  PORTC = 0x00;        // Turn Off all PORTC

  /* Init PWM for Single Output */
  CCP1CON=0b00001100;  // Single PWM mode; P1A, P1C active-high; P1B, P1D active-high
  CCPR1L=0;            // Start with zero Duty Cycle

  T2CON=0b00000101;    // Postscale: 1:1, Timer2=On, Prescale = 1:4
  PR2=0x65;            // Frequency: 4.90 kHz
  TMR2=0;              // Start with zero Counter

  PSTRCON=0b00000100;  // Enable Pulse Steering on P1C (RC3)
  state=0;             // Start with state 1

  for(;;) {
    ipwm=0;
    while (ipwm < 255) {
      CCPR1L=++ipwm;
      _delay_ms(5);     // Delay 5 millisecond
    } 	                    

    ipwm=0xff;
    while (ipwm > 0) {
      CCPR1L=--ipwm;
      _delay_ms(5);     // Delay 5 millisecond
    }       

     _delay_ms(100);    // Delay 100 millisecond

    if (state == 0) {
      state=1;
      PSTRCON=0b00001000;  // Enable Pulse Steering on P1D (RC2)
    } else if (state == 1) {
      state=2;
      PSTRCON=0b00001100;  // Enable Pulse Steering on P1C and P1D (RC3 and RC2)
    } else {
      state=0;
      PSTRCON=0b00000100;  // Enable Pulse Steering on P1C (RC3)
    }
  }
}

/* EOF: pwm.c */

This C program basically will use only P1C and P1D PWM output ports, since these ports are attached to the LEDs on the PICJazz 16F690 board. The program will use the PWM pulse steering mode to make these two LEDs to slowly turn to bright and slowly turn to dark by changing the PWM duty cycle.

 

2.1. CCP1CON: Enhance CCP1 Control Register

This register is use to select the PWM output configuration bit and PWM mode.

By setting P1M1=0 and P1M0=0 bits in the CCP1CON register we select the single output PWM; setting the CCP1M3=1, CCP1M2=1, CCP1M1=0 and CCP1M0=0 in the CCP1CON register we select the PWM mode with P1A, P1C active-high; P1B, P1D active-high as this following code:

/* Init PWM for Single Output */
CCP1CON=0b00001100;  // Single PWM mode; P1A, P1C active-high; P1B, P1D active-high
CCPR1L=0;            // Start with zero Duty Cycle

In this tutorial we just set the additional 2 LSB extended bits (DC1B1 and DC1B0) to all zero (logical “0“) for the CCPR1L register (10-bit wide). We start by setting the CCPR1L to zero mean we start with zero duty cycle (no PWM output). The next step is to configure the TIMER2 control register:

This register is used to set the postscale, activate the TIMER2 peripheral and set the prescale clock used by the TMR2 counter register. BY setting the T2CKPS1=0 and T2CKPS0=1 in the T2CON register we select the 1:4 prescale; and by setting the TMR2ON to logical “1” we activate the TIMER2 peripheral.

T2CON=0b00000101;    // Postscale: 1:1, Timer2=On, Prescale = 1:4
PR2=0x65;            // Frequency: 4.90 kHz
TMR2=0;              // Start with zero Counter

On the PWM mode, we are not using the postscaller output therefore we just set all the postscale bits (TOUTPS3, TOUTPS2, TOUTPS1 and TOUTPS0) to all zero. Setting the PR2=0x65 (or 101 decimal) with the 1:4 prescale and system clock of 8 MHz, then we could calculate the PWM output frequency according to the formula above as follow:

PWM period = (PR2 + 1) x 4 x Tosc x (TMR2 prescale value) second

PWM period = (101 + 1) x 4 x (1 / 8000000) x 4 = 0.000204 second
PWM frequency = 1 / PWM period = 1 / 0.000204 = 4901.96 Hz = 4.90 kHz

2.2. PSTRCON: Pulse Steering Control Register

In the single output PWM mode this register is use to control where the PWM ports to be used as the PWM output signal.

By activating the desire steering bit in the PSTRCON register, we could control the PWM output signal whether to use just one port or simultaneously use all the available PWM output ports. On the example program above we use the program state to change these bits. First we activate only the P1C (RC3) port:

PSTRCON=0b00000100;  // Enable Pulse Steering on P1C (RC3)
state=0;             // Start with state 1

Then inside the endless loop we change these bits according to the state status as this following code:

if (state == 0) {
  state=1;
  PSTRCON=0b00001000;  // Enable Pulse Steering on P1D (RC2)
} else if (state == 1) {
  state=2;
  PSTRCON=0b00001100;  // Enable Pulse Steering on P1C and P1D (RC3 and RC2)
} else {
  state=0;
  PSTRCON=0b00000100;  // Enable Pulse Steering on P1C (RC3)
}

The steering sync bit (STRSYNC) in the PSTRCON register is set to zero, means the output steering update occur at the beginning of the instruction cycle.

2.3. Inside the C Program

The C program begins by selecting the 8 MHz internal clock and setting all the I/O ports used on this examples. After doing the PWM and TIMER2 peripherals setup, we go the endless loop (the for(;;) C statement with no argument); inside this loop we use the CCPR1L register to change the PWM duty cycle by assigning the value from 0 to 255 for turning the LEDs slowly from dark to bright and assigning the CCPR1L register value from 255 to 0 for turning the LEDs from bright to dark.

ipwm=0;
while (ipwm < 255) {
  CCPR1L=++ipwm;
  _delay_ms(5);     // Delay 5 millisecond
} 	                    

ipwm=0xff;
while (ipwm > 0) {
  CCPR1L=--ipwm;
  _delay_ms(5);     // Delay 5 millisecond
}

2.4. Downloading the Code

After compiling and simulating your code hook up your PICKit2 programmer to the PICJazz 16F690 board ICSP port turn the PICJazz 16F690 power. From the MPLAB IDE menu select Programmer -> Select Programmer -> Pickit2 it will automatically configure the connection and display it on the PICkit2 tab Output windows:

Now you are ready to down load the code from MPLAB IDE menu select Programmer -> Program; this will down load the HEX code into the PICJazz 16F690 board:

3. Full Bridge Mode PWM

After learning the PWM principal by using the single output mode, now we come to the best part; the ability to easily control the H-Bridge DC motor circuit is what makes the PIC microcontrollers unique among the other microcontroller’s types. Ok let’s take a look at the following C program code:

// ***************************************************************************
//  File Name    : pwm2.c
//  Version      : 1.0
//  Description  : Pulse Width Modulation (PWM)
//                 H-Bridge DC Motor Controller
//  Author(s)    : RWB
//  Target(s)    : PICJazz 16F690 Board
//  Compiler     : HITECT PICC-Lite Version 9.60PL1
//  IDE          : Microchip MPLAB IDE v8.00
//  Programmer   : PICKit2
//  Last Updated : 03 Jan 2009
// ***************************************************************************
#include <pic.h>

/*   PIC Configuration Bit:
**   INTIO     - Using Internal RC No Clock
**   WDTDIS    - Wacthdog Timer Disable
**   PWRTEN    - Power Up Timer Enable
**   MCLREN    - Master Clear Enable
**   UNPROTECT - Code Un-Protect
**   UNPROTECT - Data EEPROM Read Un-Protect
**   BORDIS    - Borwn Out Detect Disable
**   IESODIS   - Internal External Switch Over Mode Disable
**   FCMDIS    - Monitor Clock Fail Safe Disable
*/
__CONFIG(INTIO & WDTDIS & PWRTEN & MCLREN & UNPROTECT \
  & UNPROTECT & BORDIS & IESODIS & FCMDIS);

// Using Internal Clock of 8 MHz
#define FOSC 8000000L

// Delay Function
#define	_delay_us(x) { unsigned char us; \
		       us = (x)/(12000000/FOSC)|1; \
		       while(--us != 0) continue; }

void _delay_ms(unsigned int ms)
{
  unsigned char i;

  if (ms == 0) return;
  do {
    i = 4;
    do {
      _delay_us(164);
    } while(--i);
  } while(--ms);
}

void main(void)
{
  unsigned int ipwm;
  unsigned char direction;

  OSCCON=0x70;         // Select 8 Mhz internal clock

  TRISC = 0x00;        // Set All on PORTC as Output
  TRISA = 0x03;        // Input for RA0 and RA1
  ANSEL = 0x01;        // Set PORT AN0 to analog input AN1 to AN7 digital I/O
  ANSELH = 0x00;       // Set PORT AN8 to AN11 as Digital I/O
  PORTC = 0x00;        // Turn Off all PORTC

  /* Init PWM for Full Bridge Output */
  CCP1CON=0b01001100;  // Full Bridge Forward; P1A, P1C active-high; P1B, P1D active-high
  CCPR1L=0;            // Start with zero Duty Cycle

  T2CON=0b00000101;    // Postscale: 1:1, Timer2=On, Prescale = 1:4
  PR2=0x65;            // Frequency: 4.90 KHz
  TMR2=0;              // Start with zero Counter

  /* Init ADC */
  ADCON0=0b00000000;   // Select Left justify result. ADC port channel 0
  ADCON1=0b00110000;   // Select the FRC for 8 MHz
  ADON=1;	        // turn on the ADC conversion module

  direction=0;         // Start with Forward Direction
  ipwm=0;

  for(;;) {
    if (RA1 == 0) {           // Change the Motor Direction when pressed
     _delay_ms(1);
     if (RA1 == 0) {          // Read again for simple debounce
       if (direction == 0) {
         direction=1;         // Reverse direction
         P1M1=1;
         P1M0=1;
       } else {
         direction=0;         // Forward direction
         P1M1=0;
         P1M0=1;
       }
     }
    }

    GODONE=1;	              // initiate conversion on the channel 0
    while(GODONE) continue;  // Wait conversion done

    ipwm = ADRESH;           // Get the highest 8 bit MSB result, ignore the 2 bit LSB
    CCPR1L=ipwm;             // Set the Duty Cycle base on the ADC result

    /* Blink the LED attached on RC0 */
    RC0=1;                   // Turn On
    _delay_ms(ipwm);
    RC0=0;                   // Turn Off
    _delay_ms(ipwm);
  }
}

/* EOF: pwm2.c */

The basic PWM setup routines is almost the same with our previous program, but in this program I used the PIC 16F690 ADC peripheral for adjusting the DC motor speed; the motor speed is depend on the voltage value read by the PIC 16F690 ADC peripheral from the PICJazz 16F690 board user’s trimpot that works as the voltage divider circuit. This value will be assigned to the CCPR1L duty cycle register.

I also use the PICJazz 16F690 user’s switch that works as a toggle switch to change the DC motor direction; and to make it more interesting, I use the LED attached to the RC0 port as the program life beacon; this LED will blink according to the value we assigned to the CCPR1L register.

3.1. Full Bridge PWM Mode Setup

The full bridge PWM mode is selected by setting the P1M1 and P1M0 bits in the CCP1CON register, there are 2 available modes for the full bridge PWM mode; the first one is called full bridge output forward, this can be selected by setting the P1M1=0 and P1M0 = 1 in the CCP1CON register. In this mode the P1D pin will be the modulated port; P1A port will active; while P1B, P1C will inactive:

On the forward full bridge PWM mode the TR1 transistor will on saturate and the TR4 transistor will on/off base on the PWM signal supplied by P1D port, while the TR2 and TR3 transistors inactive. The current will flow from TR1 transistor through DC Motor and go to the TR4 transistor, this make the DC motor to turn on the forward direction.

The second full bridge PWM mode is the reverse full bridge PWM mode, this mode can be selected by setting the P1M1=1 and P1M0 = 1 in the CCP1CON register. In this mode the P1B pin will be the modulated port; P1C port will active; while P1A, P1D will inactive:

On the reverse full bridge PWM mode the TR3 transistor will on saturate and the TR2 transistor will on/off base on the PWM signal supplied by P1B port, while the TR1 and TR4 transistors inactive. The current will flow from TR3 transistor through DC Motor and go to the TR2 transistor, this make the DC motor to turn on the reverse direction.

The following is the C program code for the PWM setup we use in this project:

/* Init PWM for Full Bridge Output */
CCP1CON=0b01001100;  // Full Bridge Forward; P1A, P1C active-high; P1B, P1D active-high
CCPR1L=0;            // Start with zero Duty Cycle

T2CON=0b00000101;    // Postscale: 1:1, Timer2=On, Prescale = 1:4
PR2=0x65;            // Frequency: 4.90 KHz
TMR2=0;              // Start with zero Counter

The other register that I mention before is the PWM1CON register (enhanced PWM control register). This register is used in half bridge PWM mode to put a time delay to the actual PWM signal transition from zero to active; we are not using this feature on the full bridge PWM mode.

3.2. The PIC 16F690 ADC Peripheral Setup

The ADC peripheral is used to read the voltage value on the analog input port RA0, this voltage value is supplied by the user’s trimpot on the PICJazz 16F690 board. Adjusting the trimpot means changing the voltage value as well; by converting this voltage value to the digital equivalent value and assign this value to the CCPR1L (duty cycle) register, we could change the PWM duty cycle and this will effecting the DC motor speed.

The complete PIC microcontroller ADC setup explanation could be read on the article “PIC Analog to Digital Converter C Programming” posted on this blog. The following is the C program code for setting the PIC 16F690 ADC peripheral:

/* Init ADC */
ADCON0=0b00000000;   // Select Left justify result. ADC port channel 0
ADCON1=0b00110000;   // Select the FRC for 8 MHz
ADON=1;	             // Turn on the ADC conversion module

By setting the ADFM bit to logical “0” in the ADCON0 register we use the “left justified” result. This mean the higher 8 bits ADC result value will be placed in the ADRESH register and the lower 2 bits ADC result value in the ADRESL register, because we just need the 8 bit value for the CCPR1L register, so the lowest 2 bits value in ADRESL register can be ignored:

ipwm = ADRESH;           // Get the highest 8 bit MSB result, ignore the 2 bit LSB
CCPR1L=ipwm;             // Set the Duty Cycle base on the ADC result

3.3. Inside the C Program

The C program begins by selecting the 8 MHz internal clock and setting all the I/O ports used on this examples. After doing the PWM, TIMER2 and ADC peripherals setup, we go the endless loop (the for(;;) C statement with no argument); inside this loop first we read the user’s switch, this switch is attached to the input port RA1 and work as the toggle switch to change the DC motor direction:

if (RA1 == 0) {            // Change the Motor Direction when pressed
  _delay_ms(1);
  if (RA1 == 0) {          // Read again for simple debounce
    if (direction == 0) {
      direction=1;         // Reverse direction
      P1M1=1;
      P1M0=1;
    } else {
      direction=0;         // Forward direction
      P1M1=0;
      P1M0=1;
    }
  }
}

By setting the P1M1=1 and P1M0=1 bits in the CCP1CON register, we select the reverse full bridge PWM mode; setting the P1M1=0 and P1M0=1 bits in the CCP1CON register, we select the forward full bridge PWM mode.

The PIC ADC peripheral than read the analog input channel 0 (RA0) port and assigned the value to the CCPR1L register and as the _delay_ms() function argument to the life beacon LED attached to the output port RC0.

GODONE=1;	         // initiate conversion on the channel 0
while(GODONE) continue;  // Wait conversion done

ipwm = ADRESH;           // Get the highest 8 bit MSB result, ignore the 2 bit LSB
CCPR1L=ipwm;             // Set the Duty Cycle base on the ADC result

/* Blink the LED attached on RC0 */
RC0=1;                   // Turn On
_delay_ms(ipwm);
RC0=0;                   // Turn Off
_delay_ms(ipwm);

3.4. Downloading the Code

After compiling and simulating your code hook up your PICKit2 programmer to the PICJazz 16F690 board ICSP port turn the PICJazz 16F690 power. From the MPLAB IDE menu select Programmer -> Select Programmer -> Pickit2 it will automatically configure the connection and display it on the PICkit2 tab Output windows:

Now you are ready to down load the code from MPLAB IDE menu select Programmer -> Program; this will down load the HEX code into the PICJazz 16F690 board:

After all the hard work, now it’s time to watch to your PIC microcontroller controlling the H-Bridge DC motor circuit:

Bookmarks and Share

105 Responses to “H-Bridge Microchip PIC Microcontroller PWM Motor Controller”

• Search This Site

  

  Custom Search

• Future Post

  Controlling the Motor is one of interesting topics in the embedded world especially for the robotics enthusiasts, on the next post we will learn the basic of motor electronic circuit as well as how to control it with microcontroller.

  Therefore don't miss it, stay tune on this blog !
  
  

• Categories

  Categories Select Category Blognote Development Board News Electronics Microcontroller Robotics Yet Another Tips

• Blogroll

  • ermicro shop
  • ermicroblog Amazon Store
  • ermicroblog on YouTube
  • ermicroblog video on Metacafe

• Archives

  Archives Select Month October 2014 September 2013 June 2013 February 2013 December 2012 December 2011 September 2011 July 2011 April 2011 February 2011 January 2011 December 2010 September 2010 July 2010 May 2010 April 2010 March 2010 February 2010 January 2010 December 2009 November 2009 October 2009 September 2009 August 2009 July 2009 June 2009 May 2009 April 2009 March 2009 February 2009 January 2009 December 2008 November 2008
•