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