Colony

  TODO:

    - do the inversion of flags when computing then, not in the ISR

	- do the timing right

	- handle 0 values (use the pwm_init_mask)

	- Determine sorting time, possibly improve sorting algorithm

 */

/*

 *   - Frequency is 120 Hz (8 ms) next lower (prescaler) is 30 Hz which flickers

 *     Not that we could still use the slower prescaler and manually reload

 *     after 127. This would still cost resolution, but 128 steps should be

 *     enough.

 *   - Overflow interrupt 2.5 us (0.03%), compare interrupts are 6*10us (when

 *     using all different values) (0.75%) or 1*26 us (when using all same

 *     values)

 *   - Where to put the time base?

 *     - buzzer => doesn't work because of varying frequency

 *     - motors => possible? would trigger often (?)

 *     - lights => must put lights on 16 bit timer (no OCR left)

uint8_t orb_values[NUM_ORBS][NUM_COLORS];

// TODO use everywhere, add methods to switch on/off, add init function

bool enable_orb_pwm=true;

PORTF=2;

PORTF=0;

PORTF=4;

	//   - synchronization OK?

	// If the interrupt is executed w/o delay, TCNT0 == time+1 (and TIME=OCR0)

	// TODO improve (check overflow; maybe use return after last; fix

	// 0/1/254/255 values)

	while (TCNT0==pwm_channels[current_pwm_channel].time+1)

	{

		// Turn the current channel off

		ORBPORT|=pwm_channels[current_pwm_channel].mask;

		// 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;

	}

PORTF=0;

// ************************************

// ** Internal orb setting functions **

// ************************************

// 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 apply_orbs (void)

	if (enable_orb_pwm)

	{

		// PWM mode

		// Sort the orb values.

		// 1. Write the orb values and corresponding masks to the pwm channels

		// array unsorted

		for (uint8_t orb=0; orb<2; ++orb)

		{

			for (uint8_t color=0; color<3; ++color)

			{

				// TODO this should be faster w/o multiplication

				uint8_t index=NUM_COLORS*orb+color;

				pwm_channels[index].time=orb_values[orb][color];

				pwm_channels[index].mask=orb_mask[orb][color];

			}

		}

		// 2. Sort the values. Use bubble sort for now.

		for (uint8_t count=num_pwm_channels-1; count>0; --count)

		{

			for (uint8_t i=num_pwm_channels-1; i>0; --i)

			{

				if (pwm_channels[i].time<pwm_channels[i-1].time)

				{

					uint8_t temp;

					// Swap the times

					temp=pwm_channels[i].time;

					pwm_channels[i].time=pwm_channels[i-1].time;

					pwm_channels[i-1].time=temp;

					// Swap the masks

					temp=pwm_channels[i].mask;

					pwm_channels[i].mask=pwm_channels[i-1].mask;

					pwm_channels[i-1].mask=temp;

				}

			}

		}

		pwm_init_mask=all_orbs_mask; // FIXME use real values

		// Sort the values from orb_values[NUM_ORBS][NUM_COLORS].

	}

	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.

	}

static void orb_n_set (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];

	}

}

// ************************************

// ** 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.

	apply_orbs ();

	apply_orbs ();

	orb_n_set (0, red, green, blue);

	orb_n_set (1, red, green, blue);

	apply_orbs ();

void orbs_set (

	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);

	apply_orbs ();

}

// ********************

// ** Initialization **

// ********************

/**

 * 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

	//   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.

	// Using and 8 bit timer has the added advantage that all the comparisons

	// are faster.

	// 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);

	// *** Set up the timer

	// 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

	// Enable compare match and overflow interrupts

	TIMSK=_BV(OCIE0) | _BV(TOIE0);

    // Debug

    DDRF=6;

	// 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: red

	// ORB2: green

	// Left: greenish red, Right: greenish blue

	// For testing, set some pretty colors

	orbs_set (250, 127, 3, 3, 127, 250);

	//orbs_set (252, 129, 5, 3, 127, 250);

	//orbs_set (127, 127, 127, 127, 127, 127);

//	// 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= 3-1;//0

//	pwm_channels[1].mask=orb1_blue_mask  ; pwm_channels[1].time= 3-1;//1

//	pwm_channels[2].mask=orb2_green_mask ; pwm_channels[2].time=127-1;//126

//	pwm_channels[3].mask=orb1_green_mask ; pwm_channels[3].time=127-1;//127

//	pwm_channels[4].mask=orb2_blue_mask  ; pwm_channels[4].time=250-1;//254

//	pwm_channels[5].mask=orb1_red_mask   ; pwm_channels[5].time=250-1;//255

}