led.c

Go to the documentation of this file.

#include <main-header.h>
#include "led.h"
 
// the brightness required for each R,G,B value to trigger mosfets(if enabled)
#define LED_WHITE_MIN (250 * 0xFF)
 
# define LED_TIMER_FREQUENCY 130
 
// 0=nothing, 1=fade, 2=blink,3=on,4=fade_to
static byte operation;
static uint8_t do_mosfet;
static int ctr = 0;
static int lastled = 0;
static uint16_t fadetarget[3];          //0=R, 1=G, 2=B
static uint16_t curled[3];              //0=R, 1=G, 2=B
static uint16_t ledoffval[3];           //0=R, 1=G, 2=B
static uint16_t blink_colour[3];        //0=R, 1=G, 2=B
 
typedef struct leddef {
  int   pins[3]; //rgb
  int   timers[3];
} _leddef;
 
/*
 * The timer numbers do _not_ match the STM32 documentation. The mculibrary counts
 * timers from 0..n, whereas STM counts from 1...n.. Thus "timer 3" is "stm-timer 4"
 */
struct leddef intled = { .pins = { 106, 107, 108 }, .timers = { 3, 3, 3 } };
struct leddef extled = { .pins = { 7, 110, 111 }, .timers = { 2, 1, 1 } };
 
static struct leddef *curpins;
 
static byte led_managed_by;
static byte lastledconfig;
 
typedef struct ledcolour {
  uint32_t      colour;
  uint8_t       brightness;
  uint32_t      on;
  uint32_t      off;
} _ledcolour;
 
struct ledcolour usercolour;
struct ledcolour machinecolour;
 
static void mosfet(uint8_t number, uint8_t state) {
  mculib_pin_set(MAIN_MCULIBHANDLE, number + 100, state);
}
static int isSameRGB(uint16_t src[3], uint16_t dst[3]) {
  if (src[0] != dst[0]) {
    return 0;
  }
  if (src[1] != dst[1]) {
    return 0;
  }
  if (src[2] != dst[2]) {
    return 0;
  }
  return 1;
}
 
static void copy_colour(uint16_t src[3], uint16_t dst[3]) {
  dst[0] = src[0];
  dst[1] = src[1];
  dst[2] = src[2];
}
static struct ledcolour *get_led_colour() {
  if (led_managed_by == LED_USER) {
    return &usercolour;
  }
  return &machinecolour;
}
static void colour_to_array(uint16_t *dest, uint32_t colour, uint8_t brightness) {
  dest[0] = (colour >> 16) & 0xFF;
  dest[1] = (colour >> 8) & 0xFF;
  dest[2] = (colour) & 0xFF;
  int i;
 
  for (i = 0; i < 3; i++) {
    dest[i] = dest[i] * (uint16_t)brightness;
  }
}
static void set_blink_colour(uint32_t colour, int brightness) {
  colour_to_array(blink_colour, colour, brightness);
}
 
static void set_led(uint16_t rgb[3]) {
  // the uint16 is actually RGB byte values multiplied by brightness
  copy_colour(rgb, curled);
  if (config_get_flag(CONFIG_FLAGS_INTERNAL_LED_INVERTED)) {
    mculib_timer_set_pwm(MAIN_MCULIBHANDLE, curpins->timers[0], curpins->pins[0], rgb[0]);
    mculib_timer_set_pwm(MAIN_MCULIBHANDLE, curpins->timers[1], curpins->pins[1], rgb[1]);
    mculib_timer_set_pwm(MAIN_MCULIBHANDLE, curpins->timers[2], curpins->pins[2], rgb[2]);
  } else {
    mculib_timer_set_pwm(MAIN_MCULIBHANDLE, curpins->timers[0], curpins->pins[0], 0xFFFF - rgb[0]);
    mculib_timer_set_pwm(MAIN_MCULIBHANDLE, curpins->timers[1], curpins->pins[1], 0xFFFF - rgb[1]);
    mculib_timer_set_pwm(MAIN_MCULIBHANDLE, curpins->timers[2], curpins->pins[2], 0xFFFF - rgb[2]);
  }
  // do_mosfet for some extra performance in the IRQ (set by userloop)
  if (do_mosfet) {
    // white handling
    if ((rgb[0] > LED_WHITE_MIN) && (rgb[1] > LED_WHITE_MIN) && (rgb[2] > LED_WHITE_MIN)) {
      // mosfets on
      if (config_get_flag(CONFIG_FLAGS_WHITE_MOSFET0)) {
        mosfet(0, 1);
      }
      if (config_get_flag(CONFIG_FLAGS_WHITE_MOSFET1)) {
        mosfet(1, 1);
      }
    } else {
      // mosfets off
      if (config_get_flag(CONFIG_FLAGS_WHITE_MOSFET0)) {
        mosfet(0, 0);
      }
      if (config_get_flag(CONFIG_FLAGS_WHITE_MOSFET1)) {
        mosfet(1, 0);
      }
    }
  }
}
static int inline cnt(int idx) {
  if (fadetarget[idx] > curled[idx]) {
    if ((fadetarget[idx] - curled[idx]) < 256) {
      curled[idx] = fadetarget[idx];
    } else {
      curled[idx] = curled[idx] + 255;
    }
    set_led(curled);
    return 1;
  }
  if (fadetarget[idx] < curled[idx]) {
    if ((curled[idx] - fadetarget[idx]) < 256) {
      curled[idx] = fadetarget[idx];
    } else {
      curled[idx] = curled[idx] - 256;
    }
    set_led(curled);
    return 1;
  }
  return 0;
}
 
static void led_timer_irq() {
  struct ledcolour *lc = get_led_colour();
 
  if (operation == 1) {         // fade
    return;
  } else if (operation == 2) {  // blink
    if (ctr > (lc->off + lc->on)) {
      ctr = 0;
    }
    if (ctr == 0) {
      set_blink_colour(lc->colour, lc->brightness);
      set_led(blink_colour);
    } else if (ctr == lc->on) {
      if (lc->off != 0) {
        curled[0] = 0;
        curled[1] = 0;
        curled[2] = 0;
        set_led(curled);
      }
    }
    ctr++;
  } else if (operation == 3) { // flash
    if (ctr == 0) {
      set_led(blink_colour);
    } else if (ctr == lc->on) {
      set_led(ledoffval);
      operation = 0;
    }
    ctr++;
  } else if (operation == 4) { // fade to
    if (isSameRGB(fadetarget, curled)) {
      operation = 0;
      return;
    }
    // count each byte up or down
    cnt(0);
    cnt(1);
    cnt(2);
  }
}
static void initpin(int pinno) {
  int r = 0;
  int pin = curpins->pins[pinno];
  int timer = curpins->timers[pinno];
 
  r = mculib_pin_out(MAIN_MCULIBHANDLE, pin, HAL_PIN_FASTEST);
  printf("LED: Setting pin %i to timer %i\r\n", pin, timer);
  if (r != 0) {
    printf("Failed to config pin %i to timer: %\r\n", pin, r);
    return;
  }
  r = mculib_timer_attach_pin_pwm(MAIN_MCULIBHANDLE, timer, pin);
  if (r != 0) {
    printf("Failed to attach pin %i to timer: %\r\n", pin, r);
    return;
  }
}
 
void led_init() {
  lastledconfig = config_get_flag(CONFIG_FLAGS_LEDEXTERN);
  ledoffval[0] = 0;
  ledoffval[1] = 0;
  ledoffval[2] = 0;
  printf("Initializing LEDs\r\n");
  curpins = &intled;
  int r;
 
  if (lastledconfig) {
    mculib_timer_disable(MAIN_MCULIBHANDLE, 3);
    curpins = &extled;
    r = mculib_timer_enable_simple(MAIN_MCULIBHANDLE, 2, LED_TIMER_FREQUENCY, &led_timer_irq);
    if (r != 0) {
      printf("Failed to init timer for led: %\r\n", r);
      return;
    }
    r = mculib_timer_enable_simple(MAIN_MCULIBHANDLE, 1, LED_TIMER_FREQUENCY, &led_timer_irq);
    if (r != 0) {
      printf("Failed to init timer for led: %\r\n", r);
      return;
    }
  } else {
    mculib_timer_disable(MAIN_MCULIBHANDLE, 1);
    mculib_timer_disable(MAIN_MCULIBHANDLE, 2);
    r = mculib_timer_enable_simple(MAIN_MCULIBHANDLE, 3, 300, &led_timer_irq);
    if (r != 0) {
      printf("Failed to init timer for led: %\r\n", r);
      return;
    }
  }
 
  led_set_machine_managed();
 
  initpin(0);
  initpin(1);
  initpin(2);
 
  if ((r = mculib_pin_out(MAIN_MCULIBHANDLE, 100, HAL_PIN_FASTEST))) {
    printf("led mosfetinit: failed to set pin %i to out: %i\r\n", 100, r);
    return;
  }
  if ((r = mculib_pin_out(MAIN_MCULIBHANDLE, 101, HAL_PIN_FASTEST))) {
    printf("led mosfetinit: failed to set pin %i to out: %i\r\n", 101, r);
    return;
  }
}
 
void led_flash(LED_USAGE_TYPE lut, uint32_t colour, uint32_t duration) {
  if (lut != led_managed_by) {
    return;
  }
  operation = 0;
  set_blink_colour(colour, 256);
  get_led_colour()->on = duration;
  operation = 3;
  ctr = 0;
}
 
void led_blink(LED_USAGE_TYPE lut, uint32_t colour, uint8_t brightness, uint32_t on, uint32_t off) {
  led_blink_flags(lut, colour, brightness, on, off, 0);
}
void led_blink_flags(LED_USAGE_TYPE lut, uint32_t colour, uint8_t brightness, uint32_t on, uint32_t off, uint32_t flags) {
  if (lut != led_managed_by) {
    return;
  }
 
  if (flags & LED_FLAG_FADE_TO) {
    operation = 4;
    colour_to_array((uint16_t *)&fadetarget, colour, brightness);
    return;
  }
 
  operation = 0;
  struct ledcolour *lc = get_led_colour();
 
  lc->colour = colour;
  lc->brightness = brightness;
  lc->on = on;
  lc->off = off;
  set_blink_colour(lc->colour, lc->brightness);
  operation = 2;
  ctr = 0;
}
 
void led_print_status() {
  if (operation == 2) {
    printf("R=%p, G=%p, B=%p\r\n", (int)blink_colour[0], (int)blink_colour[1], (int)blink_colour[2]);
  } else {
    printf("Unprintable operation %i\r\n", operation);
  }
}
 
 
void led_off(LED_USAGE_TYPE lut) {
  if (lut != led_managed_by) {
    return;
  }
  set_led(ledoffval);
  operation = 0;
}
void led_loop() {
  do_mosfet = config_get_flag(CONFIG_FLAGS_WHITE_MOSFET0) | config_get_flag(CONFIG_FLAGS_WHITE_MOSFET1);
 
  if (config_get_flag(CONFIG_FLAGS_LEDEXTERN) != lastledconfig) {
    led_off(led_managed_by);
    led_init();
  }
 
  //  if (lastled == curled) {
  //  return;
  //}
  //printf("Led: cur: %p, target: %p, dir=%i\r\n",curled,fadetarget,up);
  //lastled = curled;
  lastled++;
}
 
void led_set_machine_managed() {
  led_managed_by = LED_MACHINE;
}
void led_set_user_managed() {
  led_managed_by = LED_USER;
}
void led_set_wifi_managed() {
  led_managed_by = LED_WIFI;
}
 
void led_indicate(LED_INDICATOR a) {
  if (a == LED_POWERUP) {
    led_blink(a, (uint32_t)0xFFFFFFFF, (uint8_t)50, (uint32_t)50, (uint32_t)100);
  }
  // unless it is the reset indicator we do not
  // display status on leds if they are external
  if (config_get_flag(CONFIG_FLAGS_LEDEXTERN)) {
    return;
  }
  if (a == LED_FATALERROR) {
    led_blink(a, (uint32_t)0xFF0000, (uint8_t)50, (uint32_t)50, (uint32_t)100);
  } else if (a == LED_POWERUP) {
    led_blink(a, (uint32_t)0x0000FF, (uint8_t)50, (uint32_t)50, (uint32_t)100);
  } else if (a == LED_RESET) {
    led_blink(a, (uint32_t)0x010101, (uint8_t)50, (uint32_t)100, (uint32_t)100);
  } else if (a == LED_FLASHEND) {
    led_blink(a, (uint32_t)0xFF0000, (uint8_t)255, (uint32_t)10, (uint32_t)300);
  } else if (a == LED_WIFI_BRIDGE) {
    led_blink(a, (uint32_t)0xFF0000, (uint8_t)256, (uint32_t)5, (uint32_t)150);
  } else if (a == LED_WIFI_BRIDGE2) {
    led_blink(a, (uint32_t)0x00FF00, (uint8_t)256, (uint32_t)5, (uint32_t)150);
  } else if (a == LED_WIFI_STATION) {
    //    led_blink(LED_MACHINE, 0xFF0000, 255, 10, 300);
  } else if (a == LED_WIFI_APMODE) {
    //led_blink(LED_MACHINE, 0xFFFF00, 255, 10, 300);
  } else if (a == LED_WIFI_CONNECTED) {
    led_off(LED_MACHINE);
  } else if (a == LED_POWERSAVE) {
    led_blink(LED_MACHINE, 0xFFFFFF, 10, 5, 1000);
  }
}