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