Low-cost, 8-bit, single-chip microcontrollers are stingy when it comes to on-chip PWM (pulse-width-modulation) resources. The use of a PWM resource often forces a designer to sacrifice a capture/compare or timer channel because the PWM channel shares the same on-chip hardware. This Design Idea describes how you can use an on-chip unused synchronous serial port to generate PWM signals and convert them to a slow-moving analog signal ().

 

Many microcontroller-based stand-alone electronic units don’t use the synchronous serial port. Thus, you can use the microcontroller’s baud-rate generator and parallel-to-serial-converter blocks to generate bit patterns to form a 256-bit PWM pattern. You can then filter the PWM output with an RC filter to extract an analog signal (). The synchronous communication is devoid of the start and stop bits of asynchronous mode, so the bit pattern can generate long periods of high or low level.

 

You can generate raw data with a decimal value of 165 using this concept ().

 

A PWM-conversion cycle consists of generating 256 bits—that is, 32 bytes. The number of “on” bits corresponds to the value of the raw data to convert into PWM. Hence, for 165 bits as the raw data, 165 bits are on and 91 bits are off. To generate a 165-bit on-period, the first 20 bytes—that is, 160 bits—transmit as 0×ff on-state bytes. The trick lies in judiciously composing the 21st, or transition, byte. This byte has some of its LSBs (least significant bits) as ones and the rest as zeros to form the required length of the on-period. In this case, the circuit needs five more on bits: 160+5=165. Hence, the transition byte should have a 00011111b pattern (byte=0×1f).

 illustrates the process in flow-chart form.

 

You can tailor the PWM frequency to your application by selecting a crystal, PLL (phase-locked loop), and baud rate. A simple RC filter can convert the PWM into a slow-moving analog value. Although this idea describes an 8-bit PWM, you can increase or decrease resolution by changing the total bits per PWM cycle. You correspondingly increase or decrease the conversion time.

 provides a sample code for illustrating the concept. The code uses the PIC18F4525, which has a 4-MHz crystal and 10-kHz baud rate for the synchronous serial communication, yielding 10,000/256=39.31 Hz of PWM frequency. You can filter it with a 0.1-sec RC filter, which is sufficient for slow-moving analog signals, such as speed setpoints for motion-control applications. By using a 20-MHz crystal, you can achieve synchronous serial baud rates greater than 1.5 MHz and PWM frequencies of a few kilohertz.

 

/*    This is a demo program from illustrating PWM generation using Synchronous Serial PortMicro-controller for this code is 18F4525 Controller. however the code can be ported to any equivalent CPUDate= 15/05/2009Author: vishwas VaidyaVersion 1.00 contains the code for outputting a byte on synchronous serial transmitterVariable Raw_Data is output to synchronous transmitterInitialisations relevant for Synchronous Serial Communication1.0 TRISC<6:7> = 1; PORT C FOR SERIAL COMMUNICATION.2.0 SPEN = 1; .....RSCTA<7>3.0 SPBRG = 0x64 ; For 4MHZ crystal Fosc/4x100 = 10 KHZ4.0 TXSTA =0xBF  ; CSRC = 1; TX9 = 0;TXEN = 1;SYNC = 1; b3,b2 = x;TRMT = i/p;TX9D = x5.0 RCSTA =0x80     ; SPEN = 1; all other bits beind Rx related reset to zero.Initialisations for Transmit Interrupt1.0 Bit PEIE ..(INTCON <6>) = 1 FOR ENABLING PERIPHERAL INTERRUPTS2.0 Bit TXIE .. (PIE1 <4> ) = 13.0 Ensure that GIE is set    *///Project includes//#include 
     
      #include 
      
       //Project defines#define           tmr1_reload_L                 0x0A        //Timer 1 reload values for 1ms timing, therotical = 0xFBE7#define           tmr1_reload_H                 0xFC        //fine tuned for RPM accuracy, practical = 0xFC0A//Global variablesunsigned char timer_100ms;                      //system timer variablesunsigned char timer_500ms;unsigned char timer_1000ms;int timer_100ms_flag;                           //flag for 100ms timer    unsigned char Tx_Byte;                // Byte to be Transmitted in Tx interrupt//------Variables for DAC house Keeping and Start conversion Startunsigned char RawData; //Input digital data to be converted into analogunsigned char Next_On_Byte_Count; // Number of 0xFF bytes in on duty period of PWM for next DAC cycleunsigned char Next_Off_Byte_Count;// Number of 0x00 bytes to be transmitted in off state     unsigned char Next_Transition_Byte; // Last byte in On duty period beffore off duty starts(for Next DAC cycle)unsigned char Remainder;  // Remainder of division of RawData by 32            //Look-up table for mapping remainder of RawData/32 for generation of "Transition byte"//into number of '1's. e.g. remainder of 02 is mapped as 0x03 where number of ones are two.const unsigned char Transition_Byte_Array [8] ={
    0X00,0x01, 0x03, 0x7, 0x0F, 0x1F, 0x3F, 0x7F}; unsigned char On_Byte_Count; // Number of 0xFF bytes in on duty period of PWM for current DAC cycleunsigned char Transition_Byte; // Last byte in On duty period beffore off duty starts for current DAC cycle//----Variables for DAC House Keeping end. //--------Variables for Transmit_Byte start---int On_Period_Flag ; //On Period is in Progress            ....... in 18f4525 defination as "bit" is not allow.int Eoc_Flag ;//End of conversion flagunsigned char DivisionData;//Debug division algorithm unsigned char Off_Byte_Count; //Number of Off state bytes (0x00) during off period.int Get_Next_Byte_Flag ;// Indicates that TxByte contents should be updated for next byte interval            //---------Variables for Transmit Byte end.unsigned char New_RawData;    //Function definationsvoid controller_init (void){      //Ports configuration      TRISA = 0xFF;                    //PortA configured as input port      TRISB = 0xFF;                       //PortB configured as input port      TRISC = 0b11010010;                 //PortC configured for Serial Communication, RC2 as output pin for EGR output      TRISD = 0b11110000;                 //PortD lower nibble configured as output        TRISEbits.PSPMODE = 0;            //Parallel slave port mode disabled for PortD digital I/O operation//Debugging code for division     DivisionData = 0x08;    DivisionData = DivisionData * 0x15; //     DivisionData = 0xff/ DivisionData   ;     // Debug division algo     //ADC module configuration      ADCON0 = 0b00000001;                //ADC clock as Fosc/8 and CH0 selected                 ADCON1 = 0b00000000;            //PortA configured as analog input pin      ADCON2 = 0b00000001;            //oscilator frequency focs/8                   PIE1bits.ADIE = 0;            //Disable ADC interrupt                //SPI module configuration    PIE1bits.SSPIE = 0;            //SPI interrupt disabled    SSPSTAT = 0b00111111;               //SPI module configuration    SSPCON1 = 0b00100001;                //                                                        //Timer 1 configuration for 1ms interrupt generation    TMR1L = tmr1_reload_L;              //Load timer for next cycle    TMR1H = tmr1_reload_H;    T1CON = 0b00000001;                 //1:1 prescaler, internal clock source, enable timer    // USART configuration for Synchronus Communication    SPBRG = 0x64 ; //For 4MHZ crystal Fosc/4x100 = 10 KHZ    TXSTA =0xBF  ; //CSRC = 1; TX9 = 0;TXEN = 1;SYNC = 1; b3,b2 = x;TRMT = i/p;TX9D = x    RCSTA =0x80     ; //SPEN = 1; all other bits beind Rx related reset to zero.        //Interrupts configuration        INTCONbits.GIE = 1;            //Global interrupt enable bit    INTCONbits.PEIE = 1;            //Peripheral interrupt enable bit    PIE1bits.TMR1IE = 1;                //enable timer 1 interrupt    INTCONbits.INT0IE = 1;            //Enable INT0 external interrupt    INTCON2bits.INTEDG0 = 0;            //INT interrupt configured for rising edge            PIE1bits.TXIE = 1;                 // Enable Transmit Interrupt        INTCONbits.RBIF = 0;                           //disable interrupt on portB pin change            Tx_Byte    = 0x0F;                //Load Transmit Byte for first interrupt    }//void interrupt isr (void)void isr (void){      //Timer 1 used to generate 1ms periodic interrupt.       if (PIR1bits.TMR1IF)      {            PIR1bits.TMR1IF = 0;                   //clear interrupt flag            TMR1L = tmr1_reload_L;        //Reload timer for next cycle            TMR1H = tmr1_reload_H;                        if ( timer_100ms == 100 )            {                  timer_100ms = 0;        //reset 100ms_timer if 100msecs elapsed                  timer_100ms_flag = 1;   //set timer flag            }            else                  timer_100ms++;          //else increment 100ms_timer      }                if ( PIR1bits.TXIF)    {
    // Load transmit register with the byte to be transmitted            TXREG = Tx_Byte    ;        Get_Next_Byte_Flag = 1; //Get next value of Tx_byte            }                }void system_init (void){            timer_100ms = 0;                    //initialise system timers      timer_500ms = 0;      timer_1000ms = 0;            On_Period_Flag =1;        //Initial period in PWM is on state      Eoc_Flag =1;                    // Assume conversion is over at the start      Tx_Byte    = 0x3F    ;         // First byte is mostly all bits on      Get_Next_Byte_Flag =1;                     }void system_timers_update (void){      timer_500ms++;                      //increment timer      if (timer_500ms == 5)               //reset timer every 0.5 second            timer_500ms = 0;            timer_1000ms++;                     //increment timer      if (timer_1000ms == 10)             //reset timer every 1 second            timer_1000ms = 0;}//Function for DAC House Keeping/* This routine takes RawData as input from the calling routine and works out PWMon duty cycle period for the same. This period is specified as number of 0xFF bytes(NextOnByteCount) followed by last byte (known as NextTransitionByte) to completethe own "duty-cycle period". For example for Rawdata = 0x86 = 134 decimalWe should have 134 bits on and 122 bits off in 256 bit interval. To generate134 bit on interval we can generate 16 bytes with value 0xff to give 128 bit on time giving NextOnByteCount = 0x28 (40 Decimal). To complete remaining 6 bit interval out of 134 bit on time we should ouput0x00111111b = 0x3F which gives first 6 bits as "1". Remember that shifting sequence is from lsb to msb.*/void DAC_House_Keeping (void){    Next_On_Byte_Count = RawData >> 3 ;     //RawDat/8 = number of on bytes with 0xff value    Remainder = RawData - (Next_On_Byte_Count << 3) ;    //Remainder indicates last byte in on period    Next_Transition_Byte = Transition_Byte_Array[Remainder];    //Map remainder into on bits.    Next_Off_Byte_Count = 31 - Next_On_Byte_Count ;        //OffByte +OnByte +TransitionByte = 32}//Function for Start of conversion/*This routine is invoked when End_Of_Conversion is true(Eocflag) and new RawData is available forconversion. The new Raw data is processed by the DAC_House_Keeping routine to generateOnByteCount and TransitionByte for next cycle. These values are updated at the start of every new conversion cycle. EocFlag is rest to mark "conversion in progress" condition*/ void Start_DA_Conversion (void)    {    On_Period_Flag = 1; //Initial perid of of PWM is on state        Tx_Byte = 0xff ;//First Byte will be 0x ff in most cases.        On_Byte_Count = Next_On_Byte_Count; // Set number of 0xff bytes during on duty        Off_Byte_Count = Next_Off_Byte_Count;//Set number of 0x00 bytes        Transition_Byte = Next_Transition_Byte; //Set the last byte at the transition from on to off        Eoc_Flag = 0 ; // Conversion is in progress now.    }//-----------------Comments for Transmit_Next_Byte Start---------------------------------------------// Function for Byte Transmition on synchronous communication channel/* This routine actually implements PWM on serial synchronous channel. It is invokedevery time the transmit interrupt submits a byte to the synchronous transmitter. Get_Next_Byte_Flag triggers this routineThe PWM cycle is logically divided into three segments, viz: On duty, transition and off duty. The byte to be transmitted (TxByte)takes on three possible values depending on which segementof the PWM cycle is currently in progress:1.0 If on duty is in progress then TxByte = 0x ff(THIS CONDITION is defined when OnBytecount >0 and On_Period_flag is set)2.0 If "on to off" transition is in progress then TxByte = Transition_Byte(This condition is defined when Onbyte count = 0 and On_Period_flag is set. Oncethis condition is detected, transition byte is submitted for transmission and On_Period_flag is reset. )3.0 If off duty is in progress then TxByte = 0x00*///--------------------------------Code for Transmit_Next_Byte Start----------------void Transmit_Next_Byte (void){        Get_Next_Byte_Flag = 0;//Reset the flag set by Transmit ISR    if (On_Period_Flag)     { // Onduty is in progress        if (On_Byte_Count > 0)         {             On_Byte_Count --;        }        else         {        //On_Byte_count = 0 implies no more 0x ff to be transmitted            if (!(Tx_Byte == Transition_Byte))            {                Tx_Byte = Transition_Byte;            }             // Transmit Transition_Byte    if not already transmitted.            //However if Transition_Byte is transmitted last time             // then start off duty cycle                     else             {                 Tx_Byte = 0x00; // off state byte                On_Period_Flag = 0;//On period ends                Off_Byte_Count--;// Start tracking off_bytes transmitted            }            }    }    else     {            if (Off_Byte_Count > 0)         {            Off_Byte_Count --;        }        else         {            Eoc_Flag =1;        } //If off_bytes have been all transmitted,                } }                   //end the conversion cycle.//Main program// this program illustrates how the "Software DAC chip" formed by sync. serial port can be used to convert digital raw-data// into PWM/analog voltage. Actual application can be built by expanding this concept. void main (void){      controller_init ();                 //initialise controller      system_init ();                     //initialise global variables, timers & counters      New_RawData = 0xA5;      DivisionData = 0x05;      DivisionData = 0x01/ DivisionData   ;     // Debug division algo      while (1)      {     New_RawData = 0xA5;        //RawData = 165 Say. 5 On Bytes, TransitionByte=0x1f,Off Bytes=2. Actual application can contain code for generating the raw data corrosponding to the application.             system_timers_update ();      //system timer function                    if (timer_100ms_flag) { timer_100ms_flag = 0;                  RawData = New_RawData;        //update Raw Data                       DAC_House_Keeping ();         //Prepare for next conversion cycle                                    }                                // Keep converting the RawData from digital to analog        if (Eoc_Flag) Start_DA_Conversion ();//Start at EOC rising edge converting    if (Get_Next_Byte_Flag) Transmit_Next_Byte();//Keep transmitting on serial line      }}