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