completely redid PWM: Now calculate 'microprograms', i.e. pairs of

[moodlight.git] / ledpwm.c

/* $Id: ledpwm.c,v 1.6 2010/08/08 18:09:40 simimeie Exp $
 * Functions for led brightness control via PWM (pulse width modulation).
 */

#include <avr/io.h>
#include <avr/interrupt.h>
#include "ledpwm.h"

/*
 * Our hardware connections on the first prototype are as follows:
 *  Red ->   PD6 (OC0A)
 *  Green -> PD5 (OC0B)
 *  Blue ->  PD3 (OC2B)  CHANGED umgeloetet durch Julian jetzt PD7
 * In the next hardware revision this will be:
 *  Red ->   PC3
 *  Green -> PC2
 *  Blue ->  PC1
 */

#define LEDPORT PORTD
#define LEDDDR DDRD
#define LEDPINR 6
#define LEDPING 5
#define LEDPINB 7

uint8_t ledpwm_re = 0xff, ledpwm_gr = 0xff, ledpwm_bl = 0xff;
uint8_t ledpwm_bri = 128;
/* Internal */
volatile uint16_t ledpwm_val[3] = { 0x8000, 0x8000, 0x8000 };
typedef struct {
  uint16_t atcntval;  /* at this counter value */
  uint8_t orval;   /* or this value onto the output */
} ledpwm_microprog;
ledpwm_microprog ledpwm_mprogs[2][10];
volatile uint8_t ledpwm_activemprog = 0;
volatile ledpwm_microprog * ledpwm_amprogptr = &ledpwm_mprogs[0][0];


/* To do a 16-bit write, the high byte must be written before the low byte.
 * For a 16-bit read, the low byte must be read before the high byte */

static inline uint16_t getnextminimum(uint16_t curmin) {
  uint16_t res = 0xffff;
  uint8_t i; uint8_t found = 0;
  for (i = 0; i < 3; i++) {
    if ((ledpwm_val[i] > curmin) && (ledpwm_val[i] <= res)) {
      res = ledpwm_val[i];
      found = 1;
    }
  }
  if (found) {
    return res;
  } else {
    return 0; /* We already had the maximum, no higher values there (EOL) */
  }
}

static void ledpwm_recalculateprogram(void) {
  uint8_t nextprog = !ledpwm_activemprog;
  uint8_t i = 0;
  uint16_t nextminimum = 0;
  uint8_t orval;
  
  do {
    orval = 0;
    if (ledpwm_val[LEDPWM_REDLED] > nextminimum) {
      orval |= _BV(LEDPINR);
    }
    if (ledpwm_val[LEDPWM_GREENLED] > nextminimum) {
      orval |= _BV(LEDPING);
    }
    if (ledpwm_val[LEDPWM_BLUELED] > nextminimum) {
      orval |= _BV(LEDPINB);
    }
    ledpwm_mprogs[nextprog][i].atcntval = nextminimum;
    ledpwm_mprogs[nextprog][i].orval = orval;
    /* now calculate nextminimum */
    nextminimum = getnextminimum(nextminimum);
    i++;
  } while (nextminimum > 0);
  while (i < 10) { /* Fill the rest with dummys that cause no harm */
    ledpwm_mprogs[nextprog][i].atcntval = 0;
    ledpwm_mprogs[nextprog][i].orval = 0;
    i++;
  }
  /* activate the freshly calculated microprogram */
  ledpwm_activemprog = nextprog;
  return;
}

static inline void programnextpwmstep(void) {
  uint16_t curcnt;
  curcnt = TCNT1L;
  curcnt |= (uint16_t)TCNT1H << 8;
  while (((curcnt + 40) > ledpwm_amprogptr->atcntval) && (ledpwm_amprogptr->atcntval > 0)) {
    /* Something to do in the next few CPU cycles, so wait for it! */
    if (curcnt >= ledpwm_amprogptr->atcntval) { /* Execute! */
      LEDPORT = (LEDPORT & (uint8_t)~(_BV(LEDPINR) | _BV(LEDPING) | _BV(LEDPINB))) | ledpwm_amprogptr->orval;
      ledpwm_amprogptr++;
    }
    curcnt = TCNT1L;
    curcnt |= (uint16_t)TCNT1H << 8;
  }
  /* Now program the overflow interrupt */
  if (ledpwm_amprogptr->atcntval > 0) {
    uint16_t nextval = ledpwm_amprogptr->atcntval;
    OCR1AH = nextval >> 8;
    OCR1AL = nextval & 0xff;
  }
}

/* This gets called from timers.c which holds the 'main' (interrupt)
 * handler for the timer1 overflow. */
void ledpwm_TIMER1OVF_hook(void) {
  /* (Re-)Start microprogram */
  ledpwm_amprogptr = &ledpwm_mprogs[ledpwm_activemprog][0];
  LEDPORT = (LEDPORT & (uint8_t)~(_BV(LEDPINR) | _BV(LEDPING) | _BV(LEDPINB))) | ledpwm_amprogptr->orval;
  ledpwm_amprogptr++;
  programnextpwmstep();
}

/* Called on compare match */
ISR(TIMER1_COMPA_vect)
{
  LEDPORT = (LEDPORT & (uint8_t)~(_BV(LEDPINR) | _BV(LEDPING) | _BV(LEDPINB))) | ledpwm_amprogptr->orval;
  ledpwm_amprogptr++;
  programnextpwmstep();
}

void ledpwm_init(void) {
  /* Set our Port Pins to output */
  LEDDDR |= _BV(LEDPINR) | _BV(LEDPING) | _BV(LEDPINB);
  /* DO NOT initialize TIMER1 frequency and overflow interrupt.
   * timers.c already does that. */
  /* Enable TIMER1 output compare interrupt A */
  TIMSK1 |= _BV(OCIE1A);
  ledpwm_recalculateprogram();
}

void ledpwm_setled(uint8_t led, uint16_t val) {
  if (led > 2) { return; /* ignore invalid values */ }
  ledpwm_val[led] = val;
  ledpwm_recalculateprogram();
}

void ledpwm_set(uint8_t red, uint8_t green, uint8_t blue, uint8_t br) {
  ledpwm_val[LEDPWM_REDLED]   = red * br;
  ledpwm_val[LEDPWM_GREENLED] = green * br;
  ledpwm_val[LEDPWM_BLUELED]  = blue * br;
  ledpwm_recalculateprogram();
}