projects/step-up/pwmled.c

   1 #include <avr/io.h>
   2
   3 #include "lights.h"
   4
   5 typedef struct {
   6         uint16_t target, pwm;
   7         int16_t err_sum;
   8         unsigned char mode, state;
   9         union {
  10                 unsigned char probe_steady, mode_changed;
  11         };
  12         uint16_t mode_pwm[N_PWMLED_MODES];
  13         int16_t err_sums[N_PWMLED_MODES];
  14 } pwmled_t;
  15
  16 pwmled_t pwmleds[N_PWMLEDS];
  17
  18 #define SENSE_MOHM      3000    /* 1 Ohm */
  19 /*
  20  * Voltage in uV at ADC reading == 1 is 1100/gain/1024
  21  * ADC module returns sum of 1 << PWMLED_ADC_SHIFT measurements
  22  * Voltage in uV measured is current in mA * sense resistance in mOhm
  23  */
  24 #define MA_GAIN_TO_ADC(ma, gain) ((uint16_t) \
  25         ((uint32_t)(ma) \
  26         * (SENSE_MOHM) \
  27         * (1 << (PWMLED_ADC_SHIFT)) \
  28         * 1024 \
  29         / (1100000/(gain))))
  30
  31 static uint16_t adc_max[N_PWMLEDS] = {
  32         MA_GAIN_TO_ADC(  30,  1),
  33         MA_GAIN_TO_ADC(  30,  1),
  34 };
  35
  36 static uint16_t adc_vals[N_PWMLEDS*N_PWMLED_MODES] = {
  37         /* pwmled0 */
  38         MA_GAIN_TO_ADC(   2,  1),
  39         MA_GAIN_TO_ADC(   5,  1),
  40         MA_GAIN_TO_ADC(  10,  1),
  41         MA_GAIN_TO_ADC(  20,  1),
  42         /* pwmled1 */
  43         MA_GAIN_TO_ADC(   2,  1),
  44         MA_GAIN_TO_ADC(   8,  1),
  45         MA_GAIN_TO_ADC(  14,  1),
  46         MA_GAIN_TO_ADC(  20,  1),
  47 };
  48
  49 #define ST_DISABLED 0
  50 #define ST_OFF      1
  51 #define ST_PROBING  2
  52 #define ST_ON       3
  53 // The above are constructed so that the following work:
  54 #define ST_IS_ON(s)     ((s) & 0x02)
  55 #define ST_CAN_SET_MODE(s)      ((s) & 0x01)
  56
  57 void init_pwmled()
  58 {
  59         unsigned char i, j;
  60
  61         for (i = 0; i < N_PWMLEDS; i++) {
  62                 pwmled_t *led = pwmleds + i;
  63                 led->err_sum = 0;
  64                 led->target = adc_vals[i*N_PWMLED_MODES];
  65                 led->pwm = 0;
  66                 led->mode = 1;
  67                 led->state = ST_PROBING;
  68                 led->probe_steady = 0;
  69
  70                 for (j = 0; j < N_PWMLED_MODES; j++) {
  71                         led->mode_pwm[j] = 0;
  72                         led->err_sums[j] = 0;
  73                 }
  74         }
  75 }
  76
  77 void pwmled_set_mode(unsigned char n, unsigned char mode)
  78 {
  79         pwmled_t *led = pwmleds + n;
  80
  81         if (!ST_CAN_SET_MODE(led->state))
  82                 return;
  83
  84         if (led->mode) { // save the previous state
  85                 led->mode_pwm[led->mode - 1] = led->pwm;
  86                 led->err_sums[led->mode - 1] = led->err_sum;
  87         }
  88
  89         led->mode = mode;
  90
  91         if (mode > 0 && mode <= N_PWMLED_MODES) {
  92                 led->target = adc_vals[n*N_PWMLED_MODES + mode - 1];
  93                 led->state = ST_ON;
  94                 led->pwm = led->mode_pwm[mode - 1];
  95                 led->err_sum = led->err_sums[mode - 1];
  96                 led->mode_changed = 1;
  97                 pwm_set(n, led->pwm);
  98         } else {
  99                 led->state = ST_OFF;
 100                 pwm_off(n);
 101         }
 102 }
 103
 104 #define PWMLED_PROBE_STEADY_COUNT 10
 105
 106 static inline unsigned char pwmled_probed_ok(unsigned char n, uint16_t old_pwm)
 107 {
 108         pwmled_t *led = pwmleds + n;
 109
 110         if (led->pwm == old_pwm) {
 111                 if (led->probe_steady < PWMLED_PROBE_STEADY_COUNT)
 112                         led->probe_steady++;
 113         } else {
 114                 led->probe_steady = 0;
 115         }
 116
 117         if (led->probe_steady < PWMLED_PROBE_STEADY_COUNT
 118                 && old_pwm <= led->pwm)
 119                 return 0;
 120
 121         // probed OK
 122         led->mode_pwm[led->mode - 1] = led->pwm;
 123         led->err_sums[led->mode - 1] = 0;
 124
 125         // next mode to probe?
 126         if (led->mode < N_PWMLED_MODES) {
 127                 led->probe_steady = 0;
 128                 led->err_sum = 0;
 129
 130                 led->mode++;
 131                 led->target = adc_vals[n*N_PWMLED_MODES+led->mode-1];
 132
 133                 return 0;
 134         } else {
 135                 unsigned char i;
 136
 137                 led->state = ST_OFF;
 138                 pwm_off(n);
 139
 140                 log_byte(0xF0);
 141                 log_byte(n);
 142                 // log_word(jiffies);
 143
 144                 for (i = 0; i < N_PWMLED_MODES; i++)
 145                         log_word(led->mode_pwm[i]);
 146
 147                 log_flush();
 148
 149                 // pattern_reload();
 150                 // pwmled_set_mode(n, 2);
 151
 152                 return 1;
 153         }
 154 }
 155
 156 static inline void pwmled_err(unsigned char n)
 157 {
 158         pwmleds[n].state = ST_DISABLED;
 159         pwm_off(n);
 160
 161         log_byte(0xF1);
 162         log_byte(n);
 163         // log_word(jiffies);
 164         log_flush();
 165 }
 166
 167
 168 void pwmled_adc(unsigned char n, uint16_t adcval)
 169 {
 170         pwmled_t *led = pwmleds + n;
 171         uint16_t old_pwm;
 172         int32_t sum;
 173         unsigned char shift;
 174
 175         if (!ST_IS_ON(led->state))
 176                 return;
 177
 178         if (led->state == ST_ON && led->mode_changed) {
 179                 led->mode_changed--;
 180                 return;
 181         }
 182         // FIXME: test for maximum adcval value (adc_max[n])
 183
 184         old_pwm = led->pwm;
 185
 186         shift = led->state == ST_PROBING ? 3 : 8;
 187
 188         sum = ((int32_t)led->pwm << shift)
 189                 + led->err_sum + led->target - adcval;
 190
 191         if (sum < 0)
 192                 sum = 0;
 193
 194         led->pwm = sum >> shift;
 195         sum -= led->pwm << shift;
 196         led->err_sum = sum;
 197
 198         if (led->pwm >= PWM_MAX
 199                 || (led->pwm > (2*PWM_MAX/3) && adcval < 0x08)) {
 200                 pwmled_err(n);
 201                 return;
 202         }
 203
 204         if (led->state == ST_PROBING)
 205                 if (pwmled_probed_ok(n, old_pwm))
 206                         return;
 207
 208         if (led->pwm == old_pwm)
 209                 return;
 210
 211         pwm_set(n, led->pwm);
 212 }
 213