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