fets.c

Go to the documentation of this file.

#include "fets.h"
#include "main-header.h"
 
#define FET_TIMER 2
#define TIMER_FREQUENCY 10000
 
#define MAX_PIN_STATES 20
typedef struct pin_state {
  uint8_t       pin;
  uint8_t       pwm;            //0=on/off, 1=pwm
  uint32_t      target_pwm;     //if ispwm and target_pwm != value, we dim until target_pwm == value
  uint32_t      speed;
  uint32_t      value;          // either pwm value or 1==on,0==off
} _pin_state;
static struct pin_state pinstates[MAX_PIN_STATES];
static uint32_t volatile dim_ctr;
// #include "bare-metal.h"
 
static uint8_t timer_enabled = 0;
static uint8_t timer_use = 0;
void fets_init() {
  int r;
 
  dim_ctr = 0;
  memset(&pinstates, 0, sizeof(pinstates));
  timer_enabled = 0;
  timer_use = 0;
  if ((r = mculib_pin_out(MAIN_MCULIBHANDLE, PIN_FET_A, HAL_PIN_FASTEST))) {
    printf("[fet] Failed to set pin %i for outputmode: %i\r\n", PIN_FET_A, r);
  }
  if ((r = mculib_pin_out(MAIN_MCULIBHANDLE, PIN_FET_B, HAL_PIN_FASTEST))) {
    printf("[fet] Failed to set pin %i for outputmode: %i\r\n", PIN_FET_A, r);
  }
}
 
/*
 * static struct pin_state *get_pin(uint8_t pin) {
 * int i;
 * struct pin_state *lps = NULL;
 * for(i=0;i<MAX_PIN_STATES;i++) {
 *  struct pin_state *ps = &pinstates[i];
 *  if ( (lps == NULL) && (ps->pin == 0) ) {
 *    lps = ps;
 *  }
 *  if (ps->pin == pin) {
 *    return ps;
 *  }
 * }
 * return NULL;
 * }
 *
 */
static uint32_t calc_speed(uint32_t value, uint32_t target) {
  uint32_t v1 = value;
  uint32_t v2 = target;
 
  if (v1 > v2) {
    v2 = value;
    v1 = target;
  }
  // v2 is now bigger v1
  // v2>v1 == true
  uint32_t v = v2 - v1;
 
  v = v / 100;
  if (v == 0) {
    v = 1;
  }
  return v;
}
static struct pin_state *store_pin(uint8_t pin, uint8_t ispwm, uint32_t value) {
  int i;
  struct pin_state *lps = NULL;
 
  for (i = 0; i < MAX_PIN_STATES; i++) {
    struct pin_state *ps = &pinstates[i];
    if ((lps == NULL) && (ps->pin == 0)) {
      lps = ps;
    }
    if (ps->pin == pin) {
      ps->pwm = ispwm;
      ps->target_pwm = value;
      if (!ps->pwm) {
        ps->value = value;
      }
      ps->speed = calc_speed(ps->value, ps->target_pwm);
      return ps;
    }
  }
  if (lps == NULL) {
    printf("[fet] no more pin states available\r\n");
    return NULL;
  }
  lps->pin = pin;
  lps->pwm = ispwm;
  lps->target_pwm = value;
  if (!lps->pwm) {
    lps->value = value;
  }
  lps->speed = calc_speed(lps->value, lps->target_pwm);
  return lps;
}
 
static void do_dim() {
  if (dim_ctr < (TIMER_FREQUENCY / 100)) {
    return;
  }
  dim_ctr = 0;
  int i;
 
  for (i = 0; i < MAX_PIN_STATES; i++) {
    struct pin_state *ps = &pinstates[i];
    if ((ps->pin == 0) || (ps->pwm == 0) || (ps->speed == 0)) {
      continue;
    }
    if (ps->value == ps->target_pwm) {
      continue;
    }
    uint32_t s = ps->speed;
    if (ps->value > ps->target_pwm) {
      if (s > ps->value) {
        s = ps->value;
      }
      if (ps->value - s < ps->target_pwm) {
        s = ps->value - ps->target_pwm;
      }
      ps->value = ps->value - s;
    } else {
      if (ps->value + s > ps->target_pwm) {
        s = ps->target_pwm - ps->value;
      }
      ps->value = ps->value + s;
    }
    mculib_timer_set_pwm(MAIN_MCULIBHANDLE, FET_TIMER, ps->pin, ps->value);
    //    printf("Set pwm for pin %i to %i (stepped by %i to reach %i)\r\n",ps->pin,ps->value,s,ps->target_pwm);
  }
}
 
void fets_loop() {
  if ((timer_enabled != 0) && (timer_use == 0)) {
    int r = mculib_timer_disable(MAIN_MCULIBHANDLE, FET_TIMER);
    if (r != 0) {
      printf("[fet] failed to init timer %i: %s\r\n,", FET_TIMER, r);
    } else {
      timer_enabled = 0;
      printf("[fet] timer %i disabled \r\n", FET_TIMER);
    }
  }
  do_dim();
}
static void set_pin(int pin, int state) {
  timer_use &= ~(1 << (pin - 100));
  int r;
 
  store_pin(pin, 0, state);
  printf("Setting mosfet %i to %s\r\n", pin, (state ? "ON":"OFF"));
  if ((r = mculib_pin_out(MAIN_MCULIBHANDLE, pin, HAL_PIN_FASTEST))) {
    printf("[fet] Failed to set pin %i for outputmode: %i\r\n", pin, r);
  }
  r = mculib_pin_set(MAIN_MCULIBHANDLE, pin, state);
  if (r != 0) {
    printf("[fet] failed to set pin %i: %i\r\n", pin, r);
  }
}
 
static void timer_irq() {
  dim_ctr++;
}
 
 
void fets_set_com(struct command *com) {
  int pin = atoi(get_arg(com, 0));
  uint32_t state = atoi(get_arg(com, 1));
  int flags = 0;
 
  if (com->argctr >= 3) {
    flags = atoi(get_arg(com, 2));
  }
  pin_pwm(MAIN_MCULIBHANDLE, pin, state, flags);
}
void pin_pwm(MCULIB_HANDLE handle, int pin, uint32_t state, int flags) {
  if ((flags == 0) || (state == 0)) {
    set_pin(pin, state);
    return;
  }
  struct pin_state *ps = store_pin(pin, 1, state);
 
  // do a pwm
  if (timer_enabled == 0) {
    int r = mculib_timer_enable_simple(MAIN_MCULIBHANDLE, FET_TIMER, TIMER_FREQUENCY, &timer_irq);
    if (r != 0) {
      printf("[fet] failed to init timer %i: %s\r\n,", FET_TIMER, r);
      return;
    }
    timer_enabled = 1;
    printf("[fet] FET Timer (%i) enabled\r\n", FET_TIMER);
  }
 
  mculib_timer_set_pwm(MAIN_MCULIBHANDLE, FET_TIMER, pin, ps->value);
 
  timer_use |= (1 << (pin - 100));
  int r = mculib_timer_attach_pin_pwm(MAIN_MCULIBHANDLE, FET_TIMER, pin);
 
  if (r != 0) {
    printf("[fet] Failed to attach pin %i to timer: %i\r\n", pin, r);
    return;
  }
  /*
   * r = mculib_timer_set_pwm(MAIN_MCULIBHANDLE, FET_TIMER, pin, state);
   * if (r != 0) {
   * printf("[fet] Failed to set pwm on pin %i to timer: %i\r\n", pin, r);
   * return;
   * }
   */
 
  printf("[fet] pin %i set to pwm %i\r\n", pin, state);
}
 
void print_pwm_state() {
  printf("pin pwm target_pwm speed value\r\n");
  int i;
 
  for (i = 0; i < MAX_PIN_STATES; i++) {
    struct pin_state *ps = &pinstates[i];
    if (ps->pin == 0) {
      continue;
    }
    printf("%i %i %i %i %i\r\n", ps->pin, ps->pwm, ps->target_pwm, ps->speed, ps->value);
  }
}