How to blink LEDs with different frequency

cmicrochipmicrocontrollerpictimer

I have a pic32mx and three LEDs.
[datasheet pic32mx] (http://hades.mech.northwestern.edu/images/2/21/61132B_PIC32ReferenceManual.pdf)

I need a function that gets the number of LEDs and frequency, and then blinking the LED with that frequency.

For example I need to blink 1, 2, 4 and 8 times per second.
I have some code, but I don't know how to make it blink with the given frequency. Can somebody explain?

void main() {
T2CON = 0x0;                     // Stop and clean Control Register
T2CONSET = 0x0070;       // 16 bit timer, prescaler at 1:256,  internal clock source
PMR = 0x0;                        // Clean Timer Register
PR2 = 0xFFFF;                    //  Load value
IPC2SET = 0x0000000C;  // Set priority level=3
IPC2SET = 0x00000001;  //  Set subpriority level=1
IFS0CLR = 0x00000100;  // Clear the Timer2 interrupt status flag
IEC0SET = 0x00000100;  // Enable Timer2 interrupts
T2CONSET = 0x8000;      // START TIMER2
}

void __ISR(8,ipl3) TimerHandler {

//somecode

IFS0CLR = 0x00000100;
}

Best Answer

Lets say your led's connected to RD0 RD1 & RD2. First you need a exact 1sec delay. Following function will provide you 1sec delay

void Delayms( unsigned t)
{
  T1CON = 0x8000; 
  while (t--)
  { 
    TMR1 = 0;
    while (TMR1 < FPB/1000);
  }
}

Now you said that blink led for 1,2,4 or 8 times per second.That means to blink led 1 times per second means half of the 1sec, led will be on and half of 1sec led will be off, which you can do it like this:

int main()
{
  TRISD = 0; //making all led's output
  while(1)
  {
    PORTD = 1; //led's will be on
    Delayms(500) //led's will be on for 500ms
    PORTD = 0;//led's will be off
    Delayms(500); //led's will be off for 500ms
  }
}

Now blinking led's 2 times per second means led will be on for 250ms then led off for 250ms and again the same thing. You can do it by replacing the delay by 250ms. So in this way you can blink led's for 4 or 8 times per second.

Related Solutions

Electronic – How to modulate PWM frequency in realtime with a Microchip dsPIC

For anyone who's interested, here is the solution I arrived at today:

#include <p33fxxxx.h>

_FOSCSEL(FNOSC_PRIPLL);
_FOSC(FCKSM_CSDCMD & OSCIOFNC_OFF & POSCMD_XT);
_FWDT(FWDTEN_OFF);

static int curFreq = 0;
static int nextFreq = 0;

static unsigned int PWM_TABLE[7][2] =
{
    {132, 66}, {131, 66}, {130, 65}, {129, 65}, {128, 64}, {127, 64}, {126, 63} // Compare, duty
};

int main(void)
{
    int i, ipl;

    PLLFBD = 0x009E;                // Set processor clock to 32 MHz (16 MIPS)
    CLKDIV = 0x0048; 

    LATCbits.LATC1 = 0;             // Make RC1 an output for a debug pin
    TRISCbits.TRISC1 = 0;

    OC7CONbits.OCM = 0b000;         // Turn PWM mode off    
    OC7RS = PWM_TABLE[curFreq][1];  // Set PWM duty cycle
    PR2 = PWM_TABLE[curFreq][0];    // Set PWM period
    OC7CONbits.OCM = 0b110;         // Turn PWM mode on

    T2CONbits.TON = 0;              // Disable Timer 2
    TMR2 = 0;                       // Clear Timer 2 register    
    IPC1bits.T2IP = 1;              // Set the Timer 2 interrupt priority level
    IFS0bits.T2IF = 0;              // Clear the Timer 2 interrupt flag
    IEC0bits.T2IE = 1;              // Enable the Timer 2 interrupt
    T2CONbits.TON = 1;              // Enable Timer 2

    while (1)
    {                
        for (i = 0; i < 1600; i++) {}      // Delay roughly 1 ms
        SET_AND_SAVE_CPU_IPL(ipl, 2);      // Lock out the Timer 2 interrupt
        curFreq = (curFreq + 1) % 7;       // Bump to next frequency
        nextFreq = 1;                      // Signal frequency change to ISR
        RESTORE_CPU_IPL(ipl);              // Allow the Timer 2 interrupt        
    }
}

void __attribute__((__interrupt__)) _T2Interrupt(void)
{   
    IFS0bits.T2IF = 0;                  // Clear the Timer 2 interrupt flag     

    if (nextFreq)
    {        
        nextFreq = 0;                   // Clear the frequency hop flag
        OC7RS = PWM_TABLE[curFreq][1];  // Set the new PWM duty cycle
        PR2 = PWM_TABLE[curFreq][0];    // Set the new PWM period         
    }
}

I confirmed with the scope and a debug pin my suspicion: the original code was suffering from a race condition. The main loop did not bother to synchronize changes to PR2 with the actual state of the TMR2 counter, and so would occasionally set PR2 to a value LESS THAN (or maybe equal to) the current TMR2 value. This, in turn, would cause TMR2 to count up until it rolled over, then continue counting until it reached PR2 and generated a rising edge. During the time TMR2 was counting up to 65535 to roll over, no PWM output was being generated. At 16 MIPS, the rollover time for a 16-bit timer like TMR2 is roughly 4 ms, explaining my 4 ms PWM dropout. So, the code was doing exactly what I wrote it to do :)

In the second snippet, the code is correctly synchronizing changes to PR2 and the duty cycle register with the TMR2 rollover event, and so the 4 ms dropout had gone away. I mentioned a "weird" waveform associated with that example: it was due to the RD6/OC7 pin being configured as an output and having a low value set in the LATD register. The second snippet actually turns PWM mode off inside the Timer 2 ISR: this lets the GPIO functionality take over and pulls RD6/OC7 down for a few microseconds before reenabling PWM and generating a rising edge, leading to a "hiccup" waveform.

The second snippet also has a problem in that it reconfigures PR2 and the duty cycle register on every Timer 2 rollover, regardless of whether the main loop has commanded a frequency change or not. It seems to me from observation that the timer rolls over and generates a rising edge on the PWM pin and THEN the Timer 2 ISR gets control a few nanoseconds later (owing I'm sure to vector latency, etcetera). Turning PWM off and rejiggering the registers every time through doesn't get you quite the right frequency and duty cycle in the long run because the hardware has already generated a rising edge and started counting up to the next compare value.

What this means is that in the corrected snippet I posted today, the work done in the Timer 2 ISR needs to be minimized! Because I'm running PWM at such a high frequency, and because there is a small latency between the rising edge generated by the PWM hardware and the invocation of the Timer 2 ISR, by the time I get into the ISR TMR2 has already had time to count up to a fair number. My code needs to set PR2 and the duty cycle register immediately and directly (i.e. no function calls, and even the table lookup is pushing it), otherwise it runs the risk of missing the compare and causing the 4 ms rollover bug that was my original problem.

Anyway, I think this is an accurate description of things, and I'm running the code in my "real" application with encouraging results so far. If anything else changes I'll post here, and of course any corrections to the above would be massively appreciated.

Thanks for your help, pingswept.

Electronic – How to blink an LED on ARM STR9

The first thing is to remove all of the stuff unrelated to flashing the LED.

int main (void) {

  SCU->GPIOOUT[7]  = 0x5555;              /* P7.0..7 output - mode 1          */
  GPIO7->DDR       = 0xFF;                /* P7.0..7 Outputs (LED Data)       */

    while (1) {                             /* Loop forever                     */
    for (n = 0x01; n <= 0xFF; n <<= 1) {  
      GPIO7->DR[0x3FC] = n;               /* Turn on LED                      */
  }
}

I haven't looked at the datasheet, but I would guess that:

SCU->GPIOOUT sets the function of the pins to GPIO. GPIO7->DDR sets the pins to outputs (Data Direction Register) GPIO7->DR sets the data to be output.

The next step is to look at those registers in the documentation and check their exact function.

Best Answer

Related Solutions

Electronic – How to modulate PWM frequency in realtime with a Microchip dsPIC

Electronic – How to blink an LED on ARM STR9

Related Topic