some fixes for PWM, but the resolution in the lower end still sucks.

[moodlight.git] / ledpwm.c

/* $Id: ledpwm.c,v 1.5 2010/08/08 17:06:11 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 };
volatile uint16_t ledpwm_curoreg = 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 void ledpwm_programnextstep(void) {
  uint16_t nextval = 0xffff;
  uint16_t tmp1 = ledpwm_curoreg; /* Copy so the compiler can place it into
                 * a register despite the volatile. */
  uint8_t i;
  for (i = 0; i < 3; i++) {
    if ((ledpwm_val[i] > tmp1) && (ledpwm_val[i] <= nextval)) {
      nextval = ledpwm_val[i];
    }
  }
  /* tmp1 now reused */
  tmp1 = TCNT1L;
  tmp1 |= (uint16_t)TCNT1H << 8;
  if ((tmp1 + 30) > nextval) { /* 30 cycles is more or less a guess.
    * This needs to be set to the number of cycles the code takes from
    * here until the iret. */
    nextval = tmp1 + 30;
  }
  OCR1AH = nextval >> 8;
  OCR1AL = nextval & 0xff;
  ledpwm_curoreg = nextval;
}

/* This gets called from timers.c which holds the 'main' (interrupt)
 * handler for the timer1 overflow. */
void ledpwm_TIMER1OVF_hook(void) {
  /* Turn on all LEDs */
  if (ledpwm_val[LEDPWM_REDLED] > 0) {
    LEDPORT |= _BV(LEDPINR);
  }
  if (ledpwm_val[LEDPWM_GREENLED] > 0) {
    LEDPORT |= _BV(LEDPING);
  }
  if (ledpwm_val[LEDPWM_BLUELED] > 0) {
    LEDPORT |= _BV(LEDPINB);
  }
  ledpwm_curoreg = 0;
  ledpwm_programnextstep();
}

/* Called on compare match */
ISR(TIMER1_COMPA_vect)
{
  uint8_t orval = 0x00;
  if (ledpwm_val[LEDPWM_REDLED] > ledpwm_curoreg) {
    orval |= _BV(LEDPINR);
  }
  if (ledpwm_val[LEDPWM_GREENLED] > ledpwm_curoreg) {
    orval |= _BV(LEDPING);
  }
  if (ledpwm_val[LEDPWM_BLUELED] > ledpwm_curoreg) {
    orval |= _BV(LEDPINB);
  }
  LEDPORT = (LEDPORT & (uint8_t)~(_BV(LEDPINR) | _BV(LEDPING) | _BV(LEDPINB))) | orval;
  ledpwm_programnextstep();
}

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

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

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