/branches/library_refactor/projects/libdragonfly/lights.c - Diff - Colony - Robotics Club

Revision 1131

Added by Martin Herrmann about 15 years ago

Cleaned up lights.h
Implemented predefined color setting
Implemented binary/PWM mode switching

       TODO:
     	- Find out the interrupt time
     	- Optimize the OC interrupt
         - enable_orb_pwm use everywhere, add methods to switch on/off, add init
     	  function
     	- test old code: continuously setting the orbs
     	- fix sync/volatile
     	- make functions static
      */
     /*
-...
     #define orb2_blue_mask   _BV (ORB2_BLUE )
     // Mask for all LEDs
     const uint8_t all_orbs_mask=
     	orb1_red_mask | orb1_green_mask | orb1_blue_mask |
     #define all_orbs_mask \
     	orb1_red_mask | orb1_green_mask | orb1_blue_mask | \
     	orb2_red_mask | orb2_green_mask | orb2_blue_mask;
     // Mask for the individual LEDs, organized as an array for programmatic access.
-...
     	struct pwm_channel_t *a, *b;
     	// The actual sorting
     	a=first; b=a+1; done=true;
     	bubble next bubble next bubble next bubble next bubble
     	if (done) return;
-...
     	else
+    	{
     		// Binary mode.
     		// Don't do anything, the orbs pins are set in orb_n_set.
     		// It would be more consistent to set them here (because you could
     		// update them independently and then apply the changes at once), but it
     		// is faster this way, and being fast is the whole point of using the
     		// binary orb mode anyway.
     		// The outputs are inverted.
     		uint8_t on=0;
     		if (orb_values[0][0]) on |= orb_mask[0][0];
     		if (orb_values[0][1]) on |= orb_mask[0][1];
     		if (orb_values[0][2]) on |= orb_mask[0][2];
     		if (orb_values[1][0]) on |= orb_mask[1][0];
     		if (orb_values[1][1]) on |= orb_mask[1][1];
     		if (orb_values[1][2]) on |= orb_mask[1][2];
     		ORBPORT |= all_orbs_mask; // All orbs off
     		ORBPORT &= ~on; // Selected orbs on
+    	}
+    }
     // TODO: make a public version of this one, but keep a private one which does
     // not sort them so you can update both sides and update only once.
     static void orb_n_set (uint8_t num, uint8_t red, uint8_t green, uint8_t blue)
     static void set_orb_values (uint8_t num, uint8_t red, uint8_t green, uint8_t blue)
+    {
     	if (enable_orb_pwm)
+    	{
     		// PWM mode
     		orb_values[num][0]=red;
     		orb_values[num][1]=green;
     		orb_values[num][2]=blue;
+    	}
     	else
+    	{
     		// Binary mode
     		// The outputs are inverted.
     		if (!red)   ORBPORT|=orb_mask[num][0]; else ORBPORT&=~orb_mask[num][0];
     		if (!green) ORBPORT|=orb_mask[num][1]; else ORBPORT&=~orb_mask[num][1];
     		if (!blue)  ORBPORT|=orb_mask[num][2]; else ORBPORT&=~orb_mask[num][2];
+    	}
     	// PWM mode
     	orb_values[num][0]=red;
     	orb_values[num][1]=green;
     	orb_values[num][2]=blue;
+    }
     // ************************************
     // ** Frontend orb setting functions **
     // ************************************
     // All of these functions use orb_n_set to set the actual values, and then call
     // apply_orbs() to apply the changes. orb_n_set should be used (although it
     // would be faster to set the array directly) because the binary/pwm mode has
     // to be handled.
     // ***********************
     // ** RGB color setting **
     // ***********************
     // All of these functions use set_orb_values to set the actual values, and then call apply_orbs() to apply the changes.
     // set_orb_values should be used (even though it would be faster to set the array directly) because the binary/pwm mode
     // has to be handled.
     /**
      * @param num the number of the orb to set (0 or 1)
      */
     void orb_n_set (uint8_t num, uint8_t red, uint8_t green, uint8_t blue)
+    {
     	set_orb_values (num, red, green, blue);
     	apply_orbs ();
+    }
     /**
      * Set orb1 to the color specified. orb_init must be called before this function
      * may be used.
+     *
-...
      **/
     void orb1_set (uint8_t red, uint8_t green, uint8_t blue)
+    {
     	orb_n_set (0, red, green, blue);
     	set_orb_values (0, red, green, blue);
     	apply_orbs ();
+    }
-...
      **/
     void orb2_set (uint8_t red, uint8_t green, uint8_t blue)
+    {
     	orb_n_set (1, red, green, blue);
     	set_orb_values (1, red, green, blue);
     	apply_orbs ();
+    }
-...
      **/
     void orb_set (uint8_t red, uint8_t green, uint8_t blue)
+    {
     	orb_n_set (0, red, green, blue);
     	orb_n_set (1, red, green, blue);
     	set_orb_values (0, red, green, blue);
     	set_orb_values (1, red, green, blue);
     	apply_orbs ();
+    }
-...
     	uint8_t red1, uint8_t green1, uint8_t blue1,
     	uint8_t red2, uint8_t green2, uint8_t blue2)
+    {
     	orb_n_set (0, red1, green1, blue1);
     	orb_n_set (1, red2, green2, blue2);
     	set_orb_values (0, red1, green1, blue1);
     	set_orb_values (1, red2, green2, blue2);
     	apply_orbs ();
+    }
     // ******************************
     // ** Predefined color setting **
     // ******************************
     // Macros for extracting a color.
     #define C_RED(col)   (((col & 0xE0) >> 5) * 36)
     #define C_GREEN(col) (((col & 0x1C) >> 2) * 36)
     #define C_BLUE(col)  (((col & 0x03)     ) * 85)
     /**
      * Set both orbs to the specified color. This function
      * is intended to be used with the predefined
      * colors. orb_init must be called before this
      * function may be used.
      * Set both orbs to the specified color. This function is intended to be used with the predefined colors.
+     *
      * @param col the color to set the orbs to
+     *
      * @see orb_init
      **/
     void orb_set_color(uint8_t col)
+    {
     // uint16_t red, green, blue;
     //
     // red = ((col & 0xE0) >> 5) * 36;
     // green = ((col & 0x1C) >> 2) * 36;
     // blue = (col & 0x03) * 85;
     //
     // orb_set(red, green, blue);
     	orb_set (C_RED(col), C_GREEN(col), C_BLUE(col));
+    }
     /**
      * Set orb1 to the specified color. This function
      * is intended to be used with the predefined
      * colors. orb_init must be called before this
      * function may be used.
      * Set orb1 to the specified color. This function is intended to be used with the predefined colors.
+     *
      * @param col the color to set the orbs to
+     *
      * @see orb_init
      **/
     void orb1_set_color(uint8_t  col)
     void orb1_set_color(uint8_t col)
+    {
     // uint16_t red, green, blue;
     //
     // red = ((col & 0xE0) >> 5) * 36;
     // green = ((col & 0x1C) >> 2) * 36;
     // blue = (col & 0x03) * 85;
     //
     // orb1_set(red, green, blue);
     	orb1_set (C_RED(col), C_GREEN(col), C_BLUE(col));
+    }
     /**
      * Set orb2 to the specified color. This function
      * is intended to be used with the predefined
      * colors. orb_init must be called before this
      * function may be used.
      * Set orb2 to the specified color. This function is intended to be used with the predefined colors.
+     *
      * @param col the color to set the orbs to
+     *
      * @see orb_init
      **/
     void orb2_set_color(uint8_t  col)
     void orb2_set_color(uint8_t col)
+    {
     // uint16_t red, green, blue;
     //
     // red = ((col & 0xE0) >> 5) * 36;
     // green = ((col & 0x1C) >> 2) * 36;
     // blue = (col & 0x03) * 85;
     //
     // orb2_set(red, green, blue);
     	orb2_set(C_RED(col), C_GREEN(col), C_BLUE(col));
+    }
     //DOES THIS WORK?
     // Disables the timer1 interrupt, disabling the Orb's color fading capabilities
     // You can still turn the red, green, and blue leds on and off with set_orb_dio
     /* If we use the PWM for anything else besides the ORB, this implementation needs to be done better */
     /**
      * Disables the orb color fading capabilities
      * by disabling the timer1 interrupt.
      * Set the specified orb to the specified color. This function is intended to be used with the predefined colors.
+     *
      * @see orb_init
      * @param num the number of the orb to set (0 or 1)
      * @param col the color to set the orbs to
      **/
     void orb_disable()
     void orb_n_set_color(uint8_t num, uint8_t col)
+    {
     //	TCCR3B &= 0;  	//Turn off everything
     //	ORB_PORT |= _BV(ORB1_RED);
     //	ORB_PORT |= _BV(ORB1_GREEN);
     //	ORB_PORT |= _BV(ORB1_BLUE);
     //	ORB_PORT |= _BV(ORB2_RED);
     //	ORB_PORT |= _BV(ORB2_GREEN);
     //	ORB_PORT |= _BV(ORB2_BLUE);
     	orb_n_set(num, C_RED(col), C_GREEN(col), C_BLUE(col));
+    }
     //DOES THIS WORK?
     // Enables the timer1 interrupt, enabling the Orb's color fading capabilities
     /**
      * Enables the orb's color fading capabilities.
      * Set the orbs to the respecitve color. This function is intended to be used with the predefined colors.
+     *
      * @see orb_init
      * @param col1 the color to set orb 1 to
      * @param col2 the color to set orb 2 to
      **/
     void orb_enable()
     void orbs_set_color(uint8_t col1, uint8_t col2)
+    {
     ////	TCCR0 |= _BV(COM01) | _BV(COM00)  | _BV(WGM00) | _BV(CS01);	//Toggle OC Pin on match, FAST PWM Mode, clock/8
     //	TCCR3B =_BV(CS31);
     	orbs_set (C_RED(col1), C_GREEN(col1), C_BLUE(col1), C_RED(col2), C_GREEN(col2), C_BLUE(col2));
+    }
     /** @} **/ //end group
     #undef C_BLUE
     #undef C_GREEN
     #undef C_RED2
     // ********************
     // ** Initialization **
     // ********************
     // ******************
     // ** Mode setting **
     // ******************
     void orb_disable_timer (void)
+    {
     	TIMSK&=~( _BV(OCIE0) | _BV(TOIE0));
+    }
     void orb_enable_timer (void)
+    {
     	TIMSK|= _BV(OCIE0) | _BV(TOIE0);
+    }
     /**
      * Initializes the PWM for Orb control. This must be called before
      * the orbs are used for them to function.
      **/
     void orb_init ()
+    {
     	// 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
-...
     	// Using and 8 bit timer has the added advantage that all the comparisons
     	// are faster.
     	// Normal mode, Compare match output off, Prescaler
     	TCCR0=_BV(CS02) | _BV(CS01) | _BV(CS00); // 1024, 30 Hz
     	TCCR0=_BV(CS02) | _BV(CS01); // 1024, 30 Hz
     	TIMSK|= _BV(OCIE0) | _BV(TOIE0);
+    }
     void orb_disable_timer (void)
+    {
     	TIMSK&=~( _BV(OCIE0) | _BV(TOIE0));
+    }
     void orb_set_mode (orb_mode_t mode)
+    {
     	if (mode==orb_mode_binary)
+    	{
     		enable_orb_pwm=false;
     		orb_disable_timer ();
+    	}
     	else // orb_mode_pwm
+    	{
     		enable_orb_pwm=true;
     		orb_enable_timer ();
+    	}
     	apply_orbs ();
+    }
     // ********************
     // ** Initialization **
     // ********************
     // Orb initialization code common to all modes.
     static void orb_init_common (void)
+    {
     	// Enable the output ports and turn off the LEDs
     	ORBDDR  |=  all_orbs_mask;
     	ORBPORT |=  all_orbs_mask;
     	// Set all orbs to "off"
     	orb_set (0, 0, 0);
         // Debug
         DDRF=6; // TODO remove
+    }
     	// *** Set up the timer
     /**
      * Initializes the orbs in PWM mode. One of the orb_init* functions must be called before the orbs can be used.
+     *
      * @see orb_init_pwm
      **/
     void orb_init_binary (void)
+    {
     	orb_init_common ();
     	orb_set_mode (orb_mode_binary);
+    }
     	// Normal mode, Compare match output off, Prescaler
     	TCCR0=_BV(CS02) | _BV(CS01) | _BV(CS00); // 1024, 30 Hz
     	TCCR0=_BV(CS02) | _BV(CS01); // 1024, 30 Hz
     /**
      * Initializes the orbs in PWM mode. One of the orb_init* functions must be called before the orbs can be used.
+     *
      * @see orb_init_binary
      **/
     void orb_init_pwm (void)
+    {
     	orb_init_common ();
     	orb_set_mode (orb_mode_pwm);
+    }
     	// Enable compare match and overflow interrupts
     	orb_enable_timer ();
     /**
      * A synonym for orb_init_pwm
+     *
      * @see orb_init_pwm
      **/
     void orb_init ()
+    {
     	orb_init_pwm ();
+    }
         // Debug
         DDRF=6;
     // ***************
     // ** Debugging **
     // ***************
     void orb_test (void)
+    {
     	// 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
-...
     //		delay_ms (10);
     //	}
+    }

Also available in: Unified diff

Project

General

Profile

Colony

Revision 1131