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         pwmleds[0].state = ST_DISABLED;
  76 }
  77
  78 void pwmled_set_mode(unsigned char n, unsigned char mode)
  79 {
  80         pwmled_t *led = pwmleds + n;
  81
  82         if (!ST_CAN_SET_MODE(led->state))
  83                 return;
  84
  85         if (led->mode) { // save the previous state
  86                 led->mode_pwm[led->mode - 1] = led->pwm;
  87                 led->err_sums[led->mode - 1] = led->err_sum;
  88         }
  89
  90         led->mode = mode;
  91
  92         if (mode > 0 && mode <= N_PWMLED_MODES) {
  93                 led->target = adc_vals[n*N_PWMLED_MODES + mode - 1];
  94                 led->state = ST_ON;
  95                 led->pwm = led->mode_pwm[mode - 1];
  96                 led->err_sum = led->err_sums[mode - 1];
  97                 led->mode_changed = 1;
  98                 pwm_set(led->pwm);
  99         } else {
 100                 led->state = ST_OFF;
 101                 pwm_off();
 102         }
 103 }
 104
 105 #define PWMLED_PROBE_STEADY_COUNT 10
 106
 107 static inline unsigned char pwmled_probed_ok(unsigned char n, uint16_t old_pwm)
 108 {
 109         pwmled_t *led = pwmleds + n;
 110
 111         if (led->pwm == old_pwm) {
 112                 if (led->probe_steady < PWMLED_PROBE_STEADY_COUNT)
 113                         led->probe_steady++;
 114         } else {
 115                 led->probe_steady = 0;
 116         }
 117
 118         if (led->probe_steady < PWMLED_PROBE_STEADY_COUNT
 119                 && old_pwm <= led->pwm)
 120                 return 0;
 121
 122         // probed OK
 123         led->mode_pwm[led->mode - 1] = led->pwm;
 124         led->err_sums[led->mode - 1] = 0;
 125
 126         // next mode to probe?
 127         if (led->mode < N_PWMLED_MODES) {
 128                 led->probe_steady = 0;
 129                 led->err_sum = 0;
 130
 131                 led->mode++;
 132                 led->target = adc_vals[n*N_PWMLED_MODES+led->mode-1];
 133
 134                 return 0;
 135         } else {
 136                 unsigned char i;
 137
 138                 led->state = ST_OFF;
 139                 pwm_off();
 140
 141                 log_byte(0xF0);
 142                 log_byte(n);
 143                 // log_word(jiffies);
 144
 145                 for (i = 0; i < N_PWMLED_MODES; i++)
 146                         log_word(led->mode_pwm[i]);
 147
 148                 log_flush();
 149
 150                 // pattern_reload();
 151                 // pwmled_set_mode(n, 2);
 152
 153                 return 1;
 154         }
 155 }
 156
 157 static inline void pwmled_err(unsigned char n)
 158 {
 159         pwmleds[n].state = ST_DISABLED;
 160         pwm_off();
 161
 162         log_byte(0xF1);
 163         log_byte(n);
 164         // log_word(jiffies);
 165         log_flush();
 166 }
 167
 168
 169 void pwmled_adc(unsigned char n, uint16_t adcval)
 170 {
 171         pwmled_t *led = pwmleds + n;
 172         uint16_t old_pwm;
 173         int32_t sum;
 174         unsigned char shift;
 175
 176         if (!ST_IS_ON(led->state))
 177                 return;
 178
 179         if (led->state == ST_ON && led->mode_changed) {
 180                 led->mode_changed--;
 181                 return;
 182         }
 183         // FIXME: test for maximum adcval value (adc_max[n])
 184
 185         old_pwm = led->pwm;
 186
 187         shift = led->state == ST_PROBING ? 3 : 8;
 188
 189         sum = ((int32_t)led->pwm << shift)
 190                 + led->err_sum + led->target - adcval;
 191
 192         if (sum < 0)
 193                 sum = 0;
 194
 195         led->pwm = sum >> shift;
 196         sum -= led->pwm << shift;
 197         led->err_sum = sum;
 198
 199         if (led->pwm >= PWM_MAX
 200                 || (led->pwm > (2*PWM_MAX/3) && adcval < 0x08)) {
 201                 pwmled_err(n);
 202                 return;
 203         }
 204
 205         if (led->state == ST_PROBING)
 206                 if (pwmled_probed_ok(n, old_pwm))
 207                         return;
 208
 209         if (led->pwm == old_pwm)
 210                 return;
 211
 212         pwm_set(led->pwm);
 213 }
 214