/ - Diff - Colony - Robotics Club

Revision 1102

Added by Martin Herrmann about 15 years ago

Basic orb PWM functionality on Timer0

     	//DDRF=2;
     	//motors_init ();
     	//motor2_set (FORWARD, 64);
     	//orb_init ();
     	//orb_enable ();
-...
     	//delay_ms (1000);
     	while (1)
+    	{
     		orb_tick (0);
     		delay_ms (1000);
+    	}

      */
     /*
      * Random notes:
      *   - Current motor frequency is 32 us/30 KHz
      *   - AVR suckage: there is not timer mode with immediate OCR update and
      *     overflow interrupt at TOP (CTC value)
      *   - AVR suckage: Set on compare match/Clear on overflow not available with
      *     non-PWM modes (especially not with immediate OCR update)
      */
     #include "lights.h"
     #include <avr/interrupt.h>
     #include "dragonfly_lib.h"
-...
     #define ORB2_GREEN 5
     #define ORB2_BLUE  6
     // ***********
     // ** Masks **
     // ***********
-...
     // ** Types **
     // ***********
     struct pwm_channel
     struct pwm_channel_t
+    {
         uint8_t time;
         uint8_t mask;
-...
     // ** Variables **
     // ***************
     struct pwm_channel channels[NUM_ORBS*NUM_COLORS];
     #define num_pwm_channels NUM_ORBS*NUM_COLORS
     struct pwm_channel_t pwm_channels[num_pwm_channels];
     uint8_t pwm_init_mask;
     // ********************
     // ** Initialization **
     // ********************
     static void dset(uint8_t num)
+    {
     	PORTF|=1<<num;
+    }
     static void dclear(uint8_t num)
+    {
     	PORTF&=~(1<<num);
+    }
     /**
      * Initializes the PWM for Orb control. This must be called before
      * the orbs are used for them to function.
      **/
     void orb_init ()
+    {
     	// Timer mode:
     	//   OCRnx update "immediate" is required. This leaves "Normal" mode and the
     	//   "CTC" modes. "Normal" doesn't allow setting a reload value, and the
     	//   prescaler is too limited. So CTC is used. CTC can match to OCRnA and
     	//   ICRn. For the motor, OCRnA is already in use for the compare match
     	//   output unit. So ICRn is used.
     	//   This leaves: WGMn3:0=1100.
     	//   This mode does not provide an overflow interrupt, so Output Compare
     	//   has to be used instead.
     	// Use 8 bit TC0. Timer mode:
     	//   We cannot use CTC mode because it can only clear on OCR0 (in contrast
     	//   to the 16 bit timers which can also use the ICR for that) and OCR0 is
     	//   already used for generating output compare interrupts. We also need
     	//   immediate (non double buffered) update of OCR0, so the only mode left
     	//   is "Normal".
     	//   Note that for a timer counting from 0 to 255, there are 256 states and
     	//   thus 257 output possibilities (0/256...256/256)! Possible ways to deal
     	//   with that:
     	//     1. use a 16 bit variable for the PWM value (memory waste, overhead)
     	//     2. use an additional flag for the 257th value (inconvenient)
     	//     3. use 1/256...256/256 (skip 0, never complete off)
     	//     4. use 0/256...256/256 (skip 256, never complete on)
     	//     5. skip a value somewhere in the middle
     	//   For this implementation, variant 4 was chosen.
     	// Enable the output ports and turn off the LEDs
     	ORBDDR  |=  all_orbs_mask;
     	ORBPORT &= ~all_orbs_mask;
     	ORBPORT |=  all_orbs_mask;
     	// Set all orbs to "off"
     	orb_set (0, 0, 0);
         // Set up the timer
         // Prescaler 8 is 66 ms or 15 Hz (8 MHz/prescaler 8/2^16)
     	TCCR3A=0;
         TCCR3B=_BV(CS31); // Prescaler 8
         //TCCR3B=_BV(CS31) | _BV(CS30); // Prescaler 64
         TCCR3C=0;
         ETIMSK |= _BV(TOIE3) | _BV(OCIE3C); // Enable Overflow Interrupt and Output compare 3 interrupt
         // Clear Timer on Compare match:
         // Either from OCR3A (WGM3 3:0=4) or from ICR3 (WGM3 3:0=12
     	// *** Set up the timer
     	// DOING: Select a good reload so
     	//   - there are 256 values (not so important)
     	//   - the refresh rate is around 20..25 Hz
     	// Then, check if it can be co-used w/ the compare match output unit.
         ICR3=10000; // Refresh rate (period): 10ms
     	OCR3C=0;
     	//TCCR3A |= _BV(WGM31);
         TCCR3B |= _BV(WGM33) | _BV(WGM32);
     	// TOP is 6, counter counts 0 1 2 3 4 5 6 (7 intervals) => 8 possibilities
     	// OCR=0 => 1/8, OCR=7 => 8/8
         //OCR3C=1; // Compare after (?) 1
     	// Normal mode, Compare match output off, Prescaler 1024
     	TCCR0=_BV(CS02) | _BV(CS01) | _BV(CS00);
     	// Enable compare match and overflow interrupts
     	TIMSK=_BV(OCIE0) | _BV(TOIE0);
         // Debug
         DDRF=6;
     	// In PWM mode, the OCR is double buffered (updated at TOP or BOTTOM)
     	// The output compare flag (and interrupt) is set at the next timer clock
     	// cycle after compare match. So time=pwm_value-1 (for pwm_value==0: don't
     	// switch on at all)
     	// ORB1: 255/127/1
     	// ORB2: 0/126/254
     //	//init timer3
     //	TCCR3A = 0;
     //	TCCR3B = _BV(CS31); //prescale = 8
     //	TCCR3C = 0;
     //	ETIMSK |= _BV(OCIE3C); //turn on oc3c interrupt
     //	OCR3C = TCNT3+ORB_RESET;
     	// Init mask: all masks where value>0
     	pwm_init_mask=
     		orb1_red_mask |
     		orb1_green_mask |
     		orb1_blue_mask |
     		orb2_green_mask |
     		orb2_blue_mask
+    		;
     	// Channels: value-1
     	pwm_channels[0].mask=orb2_red_mask   ; pwm_channels[0].time= 10-1;//0
     	pwm_channels[1].mask=orb1_blue_mask  ; pwm_channels[1].time= 20-1;//1
     	pwm_channels[2].mask=orb2_green_mask ; pwm_channels[2].time= 30-1;//126
     	pwm_channels[3].mask=orb1_green_mask ; pwm_channels[3].time=200-1;//127
     	pwm_channels[4].mask=orb2_blue_mask  ; pwm_channels[4].time=220-1;//254
     	pwm_channels[5].mask=orb1_red_mask   ; pwm_channels[5].time=230-1;//255
+    }
     //
     // ****************
     // ** Timer ISRs **
     // ****************
     volatile uint8_t x;
     volatile uint8_t i;
     volatile uint8_t current_pwm_channel=0;
     void orb_tick (uint8_t t)
     SIGNAL (SIG_OVERFLOW0)
+    {
     	x++;
     	// Turn all appropriate PWM channels on
     	// TODO invert earlier
     	ORBPORT&=~pwm_init_mask;
     	// Start at the first channel
     	current_pwm_channel=0;
     	// Load the first OCR
     	OCR0=pwm_channels[current_pwm_channel].time;
+    }
     SIGNAL (SIG_OVERFLOW3)
     SIGNAL(SIG_OUTPUT_COMPARE0)
+    {
+    }
     	// TODO:
     	//   - delayed interrupt
     	//   - identical values
     	// Turn the current channel off
     	// TODO invert earlier
     	ORBPORT|=pwm_channels[current_pwm_channel].mask;
     // Timer values: 0 1 2 3 4 5 6 7 8 9
     	// Increment the channel
     	current_pwm_channel++;
     	// If there is a next channel, load its OCR value
     	if (current_pwm_channel<=(num_pwm_channels-1))
     		if (pwm_channels[current_pwm_channel].time<255)
     			OCR0=pwm_channels[current_pwm_channel].time;
+    }
     SIGNAL (SIG_OUTPUT_COMPARE3C)
+    {
     	if (i==0)
+    	{
     		dset (1);
     		dset (2);
     		i=1;
     		OCR3C=1000;
+    	}
     	else if (i==1)
+    	{
     		dclear (1);
     		OCR3C=2000;
     		i=2;
+    	}
     	else if (i==2)
+    	{
     		dclear (2);
     		OCR3C=0;
     		i=0;
+    	}
+    }
     // ************************
     // ** Setting RGB colors **
     // ************************

Also available in: Unified diff

Project

General

Profile

Colony

Revision 1102