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_targets_0[] = {
  46         MA_GAIN_TO_ADC(  50, 20),
  47         MA_GAIN_TO_ADC( 100, 20),
  48         MA_GAIN_TO_ADC( 200, 20),
  49         MA_GAIN_TO_ADC( 350, 20),
  50 };
  51
  52 static uint16_t adc_targets_1[] = {
  53         MA_GAIN_TO_ADC(   5, 20),
  54         MA_GAIN_TO_ADC(  10, 20),
  55         MA_GAIN_TO_ADC(  20, 20),
  56 };
  57
  58 static uint16_t adc_targets_2[] = {
  59 #ifdef TESTING_FW
  60         MA_GAIN_TO_ADC(  50,  1),
  61         MA_GAIN_TO_ADC( 100,  1),
  62         MA_GAIN_TO_ADC( 150,  1),
  63         MA_GAIN_TO_ADC( 240,  1),
  64         MA_GAIN_TO_ADC( 350,  1),
  65 #else
  66         MA_GAIN_TO_ADC( 150,  1),
  67         MA_GAIN_TO_ADC( 300,  1),
  68         MA_GAIN_TO_ADC( 500,  1),
  69         MA_GAIN_TO_ADC( 800,  1),
  70         MA_GAIN_TO_ADC(1200,  1),
  71 #endif
  72 };
  73
  74 static uint16_t adc_vals[N_PWMLEDS*N_PWMLED_MODES];
  75
  76 #define ST_DISABLED 0
  77 #define ST_OFF      1
  78 #define ST_PROBING  2
  79 #define ST_ON       3
  80 // The above are constructed so that the following work:
  81 #define ST_IS_ON(s)     ((s) & 0x02)
  82 #define ST_CAN_SET_MODE(s)      ((s) & 0x01)
  83
  84 void init_pwmled()
  85 {
  86         unsigned char i, j;
  87
  88         for (i = 0; i < N_PWMLEDS; i++) {
  89                 pwmled_t *led = pwmleds + i;
  90                 led->err_sum = 0;
  91                 led->target = adc_vals[i*N_PWMLED_MODES];
  92                 led->mode = 1;
  93                 led->probe_steady = 0;
  94                 led->state = ST_OFF;
  95                 led->pwm = 1;
  96                 pwm_set(i, led->pwm);
  97
  98                 for (j = 0; j < N_PWMLED_MODES; j++) {
  99                         led->mode_pwm[j] = 0;
 100                         led->err_sums[j] = 0;
 101                 }
 102         }
 103
 104         pwmled_set_brightness(PWMLED_BRIGHTNESS(0, 2, 1, 0, 2));
 105 }
 106
 107 void pwmled_set_mode(unsigned char n, unsigned char mode)
 108 {
 109         pwmled_t *led = pwmleds + n;
 110
 111         if (!ST_CAN_SET_MODE(led->state))
 112                 return;
 113
 114         if (led->mode) { // save the previous state
 115                 led->mode_pwm[led->mode - 1] = led->pwm;
 116                 led->err_sums[led->mode - 1] = led->err_sum;
 117         }
 118
 119         led->mode = mode;
 120
 121         if (mode > 0 && mode <= N_PWMLED_MODES) {
 122                 led->target = adc_vals[n*N_PWMLED_MODES + mode - 1];
 123                 led->state = ST_ON;
 124                 led->pwm = led->mode_pwm[mode - 1];
 125                 led->err_sum = led->err_sums[mode - 1];
 126                 led->mode_changed = 1;
 127                 pwm_set(n, led->pwm);
 128         } else {
 129                 led->state = ST_OFF;
 130                 pwm_off(n);
 131         }
 132 }
 133
 134 #define CHECK_BRIGHTNESS(var, expr, array) \
 135         do { \
 136                 (var) = (expr); \
 137                 if ((var) >= sizeof(array)/sizeof(array[0])) \
 138                         (var) = sizeof(array)/sizeof(array[0]) - 1; \
 139         } while (0)
 140
 141 void pwmled_set_brightness(uint16_t brightness)
 142 {
 143         unsigned char i;
 144
 145         CHECK_BRIGHTNESS(i, brightness & 0x7, adc_targets_0);
 146         adc_vals[0] = adc_targets_0[i];
 147         CHECK_BRIGHTNESS(i, (brightness >> 3) & 0x7, adc_targets_0);
 148         adc_vals[1] = adc_targets_0[i];
 149         adc_vals[2] = adc_vals[1];
 150
 151         CHECK_BRIGHTNESS(i, (brightness >> 6) & 0x7, adc_targets_1);
 152         adc_vals[3] = adc_targets_1[i];
 153         adc_vals[4] = adc_vals[3];
 154         adc_vals[5] = adc_vals[3];
 155
 156         CHECK_BRIGHTNESS(i, (brightness >> 9) & 0x7, adc_targets_2);
 157         adc_vals[6] = adc_targets_2[i];
 158         CHECK_BRIGHTNESS(i, (brightness >> 12) & 0x7, adc_targets_2);
 159         adc_vals[7] = adc_targets_2[i];
 160         adc_vals[8] = adc_vals[7];
 161
 162         for (i = 0; i < N_PWMLEDS; i++) {
 163                 pwmleds[i].err_sum = 0;
 164                 pwmled_set_mode(i, pwmleds[i].mode);
 165         }
 166 }
 167
 168 #define PWMLED_PROBE_STEADY_COUNT 10
 169
 170 static inline unsigned char pwmled_probed_ok(unsigned char n, uint16_t old_pwm)
 171 {
 172         pwmled_t *led = pwmleds + n;
 173
 174         if (led->pwm == old_pwm) {
 175                 if (led->probe_steady < PWMLED_PROBE_STEADY_COUNT)
 176                         led->probe_steady++;
 177         } else {
 178                 led->probe_steady = 0;
 179         }
 180
 181         if (led->probe_steady < PWMLED_PROBE_STEADY_COUNT
 182                 && old_pwm <= led->pwm)
 183                 return 0;
 184
 185         // probed OK
 186         led->mode_pwm[led->mode - 1] = led->pwm;
 187         led->err_sums[led->mode - 1] = 0;
 188
 189         // next mode to probe?
 190         if (led->mode < N_PWMLED_MODES) {
 191                 led->probe_steady = 0;
 192                 led->err_sum = 0;
 193
 194                 led->mode++;
 195                 led->target = adc_vals[n*N_PWMLED_MODES+led->mode-1];
 196
 197                 return 0;
 198         } else {
 199                 unsigned char i;
 200
 201                 led->state = ST_OFF;
 202                 pwm_off(n);
 203
 204                 log_byte(0xF0);
 205                 log_byte(n);
 206                 log_word(jiffies);
 207
 208                 for (i = 0; i < N_PWMLED_MODES; i++)
 209                         log_word(led->mode_pwm[i]);
 210
 211                 log_flush();
 212
 213                 pattern_reload();
 214
 215                 return 1;
 216         }
 217 }
 218
 219 static inline void pwmled_err(unsigned char n)
 220 {
 221         pwmleds[n].state = ST_DISABLED;
 222         pwm_off(n);
 223
 224         log_byte(0xF1);
 225         log_byte(n);
 226         log_word(jiffies);
 227         log_flush();
 228 }
 229
 230
 231 void pwmled_adc(unsigned char n, uint16_t adcval)
 232 {
 233         pwmled_t *led = pwmleds + n;
 234         uint16_t old_pwm;
 235         int32_t sum;
 236         unsigned char shift;
 237
 238         if (!ST_IS_ON(led->state))
 239                 return;
 240
 241         if (led->state == ST_ON && led->mode_changed) {
 242                 led->mode_changed--;
 243                 return;
 244         }
 245         // FIXME: test for maximum adcval value (adc_max[n])
 246
 247         old_pwm = led->pwm;
 248
 249         // shift = led->state == ST_PROBING ? 3 : 8;
 250         shift = 3;
 251
 252         sum = ((int32_t)led->pwm << shift)
 253                 + led->err_sum + led->target - adcval;
 254
 255         if (sum < 0)
 256                 sum = 0;
 257
 258         led->pwm = sum >> shift;
 259         sum -= led->pwm << shift;
 260         led->err_sum = sum;
 261
 262         if (led->pwm >= PWM_MAX
 263                 || (n == 1 && led->pwm > PWM_MAX/2 && adcval < 0x08)) {
 264                 pwmled_err(n);
 265                 return;
 266         }
 267
 268         if (led->state == ST_PROBING)
 269                 if (pwmled_probed_ok(n, old_pwm))
 270                         return;
 271
 272         if (led->pwm == old_pwm)
 273                 return;
 274
 275         pwm_set(n, led->pwm);
 276 }
 277