X-Git-Url: https://www.fi.muni.cz/~kas/git//home/kas/public_html/git/?p=bike-lights.git;a=blobdiff_plain;f=firmware%2Fpwmled.c;h=c156d8175f01440eef1601e4cc2609cc06082646;hp=3e4e1f495b419872b897cd68800eac9351b5d208;hb=9fd1101ae25f19ddd7b13a4660532339ddce3309;hpb=0d98bdd496538991b106bc64c45df8e89f23ea32 diff --git a/firmware/pwmled.c b/firmware/pwmled.c index 3e4e1f4..c156d81 100644 --- a/firmware/pwmled.c +++ b/firmware/pwmled.c @@ -5,8 +5,12 @@ typedef struct { uint16_t target, pwm; int16_t err_sum; - unsigned char mode, state, probe_steps; + unsigned char mode, state; + union { + unsigned char probe_steady, mode_changed; + }; uint16_t mode_pwm[N_PWMLED_MODES]; + int16_t err_sums[N_PWMLED_MODES]; } pwmled_t; pwmled_t pwmleds[N_PWMLEDS]; @@ -14,52 +18,52 @@ pwmled_t pwmleds[N_PWMLEDS]; #define PWMLED2_TESTING_WITH_350MA_LED #define SENSE_MOHM 33 /* 0.033 Ohm */ -#define MA_MOHM_GAIN_TO_ADC(ma, mohm, gain) (\ - ((unsigned long)(ma))*(mohm) /* voltage at sensing resistor in uV */ \ - /(1100000UL/gain/1024UL) /* voltage of ADC reading == 1 */ \ -) +/* + * Voltage in uV at ADC reading == 1 is 1100/gain/1024 + * ADC module returns sum of 1 << PWMLED_ADC_SHIFT measurements + * Voltage in uV measured is current in mA * sense resistance in mOhm + */ +#define MA_GAIN_TO_ADC(ma, gain) ((uint16_t) \ + ((uint32_t)(ma) \ + * (SENSE_MOHM) \ + * (1 << (PWMLED_ADC_SHIFT)) \ + * 1024 \ + / (1100000/(gain)))) static uint16_t adc_max[N_PWMLEDS] = { - MA_MOHM_GAIN_TO_ADC( 400, SENSE_MOHM, 20), - MA_MOHM_GAIN_TO_ADC( 30, SENSE_MOHM, 20), -#ifdef PWMLED2_TESTING_WITH_350MA_LED - MA_MOHM_GAIN_TO_ADC( 400, SENSE_MOHM, 1) +#ifdef TESTING_FW + MA_GAIN_TO_ADC( 400, 20), + MA_GAIN_TO_ADC( 30, 20), + MA_GAIN_TO_ADC( 800, 1) #else - MA_MOHM_GAIN_TO_ADC(2500, SENSE_MOHM, 1) + MA_GAIN_TO_ADC( 900, 20), + MA_GAIN_TO_ADC( 30, 20), + MA_GAIN_TO_ADC(2500, 1) #endif }; -static uint16_t adc_vals[N_PWMLEDS*N_PWMLED_MODES] = { - /* pwmled0 */ - MA_MOHM_GAIN_TO_ADC( 20, SENSE_MOHM, 20), - MA_MOHM_GAIN_TO_ADC( 50, SENSE_MOHM, 20), - MA_MOHM_GAIN_TO_ADC( 100, SENSE_MOHM, 20), - MA_MOHM_GAIN_TO_ADC( 350, SENSE_MOHM, 20), - /* pwmled1 */ - 16, 32, 64, 112, -#if 0 - MA_MOHM_GAIN_TO_ADC( 5, SENSE_MOHM, 20), - MA_MOHM_GAIN_TO_ADC( 12, SENSE_MOHM, 20), - MA_MOHM_GAIN_TO_ADC( 16, SENSE_MOHM, 20), - MA_MOHM_GAIN_TO_ADC( 20, SENSE_MOHM, 20), -#endif - /* pwmled2 */ - 24, 32, 40, 48 -#if 0 -#ifdef PWMLED2_TESTING_WITH_350MA_LED - MA_MOHM_GAIN_TO_ADC( 100, SENSE_MOHM, 1), - MA_MOHM_GAIN_TO_ADC( 140, SENSE_MOHM, 1), - MA_MOHM_GAIN_TO_ADC( 250, SENSE_MOHM, 1), - MA_MOHM_GAIN_TO_ADC( 350, SENSE_MOHM, 1), -#else - MA_MOHM_GAIN_TO_ADC( 150, SENSE_MOHM, 1), - MA_MOHM_GAIN_TO_ADC( 350, SENSE_MOHM, 1), - MA_MOHM_GAIN_TO_ADC( 700, SENSE_MOHM, 1), - MA_MOHM_GAIN_TO_ADC(2400, SENSE_MOHM, 1), -#endif -#endif +static uint16_t adc_targets_0[] = { + MA_GAIN_TO_ADC( 50, 20), + MA_GAIN_TO_ADC( 100, 20), + MA_GAIN_TO_ADC( 200, 20), + MA_GAIN_TO_ADC( 350, 20), }; +static uint16_t adc_targets_1[] = { + MA_GAIN_TO_ADC( 5, 20), + MA_GAIN_TO_ADC( 10, 20), + MA_GAIN_TO_ADC( 20, 20), +}; + +static uint16_t adc_targets_2[] = { + MA_GAIN_TO_ADC( 50, 1), + MA_GAIN_TO_ADC( 100, 1), + MA_GAIN_TO_ADC( 200, 1), + MA_GAIN_TO_ADC( 350, 1), +}; + +static uint16_t adc_vals[N_PWMLEDS*N_PWMLED_MODES]; + #define ST_DISABLED 0 #define ST_OFF 1 #define ST_PROBING 2 @@ -76,14 +80,19 @@ void init_pwmled() pwmled_t *led = pwmleds + i; led->err_sum = 0; led->target = adc_vals[i*N_PWMLED_MODES]; - led->pwm = 0; led->mode = 1; - led->state = ST_PROBING; - led->probe_steps = 0; + led->probe_steady = 0; + led->state = ST_OFF; + led->pwm = 1; + pwm_set(i, led->pwm); - for (j = 0; j < N_PWMLED_MODES; j++) + for (j = 0; j < N_PWMLED_MODES; j++) { led->mode_pwm[j] = 0; + led->err_sums[j] = 0; + } } + + pwmled_set_brightness(PWMLED_BRIGHTNESS(0, 2, 1, 0, 2)); } void pwmled_set_mode(unsigned char n, unsigned char mode) @@ -93,11 +102,10 @@ void pwmled_set_mode(unsigned char n, unsigned char mode) if (!ST_CAN_SET_MODE(led->state)) return; - if (led->mode) // save the previous state + if (led->mode) { // save the previous state led->mode_pwm[led->mode - 1] = led->pwm; - - if (n == 1) - log_byte(mode); + led->err_sums[led->mode - 1] = led->err_sum; + } led->mode = mode; @@ -105,7 +113,8 @@ void pwmled_set_mode(unsigned char n, unsigned char mode) led->target = adc_vals[n*N_PWMLED_MODES + mode - 1]; led->state = ST_ON; led->pwm = led->mode_pwm[mode - 1]; - led->err_sum = 0; + led->err_sum = led->err_sums[mode - 1]; + led->mode_changed = 1; pwm_set(n, led->pwm); } else { led->state = ST_OFF; @@ -113,85 +122,147 @@ void pwmled_set_mode(unsigned char n, unsigned char mode) } } -void pwmled_adc(unsigned char n, uint16_t adcval) +#define CHECK_BRIGHTNESS(var, expr, array) \ + do { \ + (var) = (expr); \ + if ((var) >= sizeof(array)/sizeof(array[0])) \ + (var) = sizeof(array)/sizeof(array[0]) - 1; \ + } while (0) + +void pwmled_set_brightness(uint16_t brightness) { - pwmled_t *led = pwmleds + n; - int16_t sum, pwm_div; - uint16_t old_pwm; + unsigned char i; - if (!ST_IS_ON(led->state)) - return; + CHECK_BRIGHTNESS(i, brightness & 0x7, adc_targets_0); + adc_vals[0] = adc_targets_0[i]; + CHECK_BRIGHTNESS(i, (brightness >> 3) & 0x7, adc_targets_0); + adc_vals[1] = adc_targets_0[i]; + adc_vals[2] = adc_vals[1]; - // FIXME: test for maximum adcval value (adc_max[n]) + CHECK_BRIGHTNESS(i, (brightness >> 6) & 0x7, adc_targets_1); + adc_vals[3] = adc_targets_1[i]; + adc_vals[4] = adc_vals[3]; + adc_vals[5] = adc_vals[3]; - sum = led->err_sum += (int16_t)(led->target) - (int16_t)adcval; + CHECK_BRIGHTNESS(i, (brightness >> 9) & 0x7, adc_targets_2); + adc_vals[6] = adc_targets_2[i]; + CHECK_BRIGHTNESS(i, (brightness >> 12) & 0x7, adc_targets_2); + adc_vals[7] = adc_targets_2[i]; + adc_vals[8] = adc_vals[7]; - // FIXME: try to work faster during probing - pwm_div = 64; //led->state == ST_PROBING ? (1 << 5) : (1 << 8); - old_pwm = led->pwm; + for (i = 0; i < N_PWMLEDS; i++) { + pwmleds[i].err_sum = 0; + pwmled_set_mode(i, pwmleds[i].mode); + } +} - if (sum >= pwm_div) { - uint16_t diff = sum/pwm_div; - led->pwm += diff; - led->err_sum -= diff * pwm_div; +#define PWMLED_PROBE_STEADY_COUNT 10 - } else if (sum <= -pwm_div) { - uint16_t diff = (-sum)/pwm_div; +static inline unsigned char pwmled_probed_ok(unsigned char n, uint16_t old_pwm) +{ + pwmled_t *led = pwmleds + n; - if (led->pwm >= diff) - led->pwm -= (int16_t)diff; - else - led->pwm = 0; - led->err_sum += diff * pwm_div; + if (led->pwm == old_pwm) { + if (led->probe_steady < PWMLED_PROBE_STEADY_COUNT) + led->probe_steady++; + } else { + led->probe_steady = 0; } - if (led->state == ST_PROBING) { - if (led->pwm == old_pwm) { - if (led->probe_steps < 10) - led->probe_steps++; - } else { - led->probe_steps = 0; - } + if (led->probe_steady < PWMLED_PROBE_STEADY_COUNT + && old_pwm <= led->pwm) + return 0; - if (led->probe_steps >= 10 || old_pwm > led->pwm) { + // probed OK + led->mode_pwm[led->mode - 1] = led->pwm; + led->err_sums[led->mode - 1] = 0; + + // next mode to probe? + if (led->mode < N_PWMLED_MODES) { + led->probe_steady = 0; + led->err_sum = 0; - led->mode_pwm[led->mode - 1] = led->pwm; + led->mode++; + led->target = adc_vals[n*N_PWMLED_MODES+led->mode-1]; - if (led->mode < N_PWMLED_MODES) { - led->probe_steps = 0; - led->err_sum = 0; + return 0; + } else { + unsigned char i; + + led->state = ST_OFF; + pwm_off(n); - led->mode++; - led->target = adc_vals[n*N_PWMLED_MODES+led->mode-1]; - } else { - unsigned char i; + log_byte(0xF0); + log_byte(n); + log_word(jiffies); - led->state = ST_OFF; + for (i = 0; i < N_PWMLED_MODES; i++) + log_word(led->mode_pwm[i]); - log_byte(0xF0); - log_byte(n); - log_word(jiffies); + log_flush(); - for (i = 0; i < N_PWMLED_MODES; i++) - log_word(led->mode_pwm[i]); + pattern_reload(); - log_flush(); - } - } + return 1; } +} - if (led->pwm == old_pwm) +static inline void pwmled_err(unsigned char n) +{ + pwmleds[n].state = ST_DISABLED; + pwm_off(n); + + log_byte(0xF1); + log_byte(n); + log_word(jiffies); + log_flush(); +} + + +void pwmled_adc(unsigned char n, uint16_t adcval) +{ + pwmled_t *led = pwmleds + n; + uint16_t old_pwm; + int32_t sum; + unsigned char shift; + + if (!ST_IS_ON(led->state)) return; - if (led->pwm > (PWM_MAX << PWM_STEP_SHIFT)/2) { - pwm_off(n); - led->state = ST_DISABLED; - log_byte(0xF1); - log_byte(n); - log_word(jiffies); - log_flush(); + if (led->state == ST_ON && led->mode_changed) { + led->mode_changed--; + return; + } + // FIXME: test for maximum adcval value (adc_max[n]) + + old_pwm = led->pwm; + + // shift = led->state == ST_PROBING ? 3 : 8; + shift = 3; + + sum = ((int32_t)led->pwm << shift) + + led->err_sum + led->target - adcval; + + if (sum < 0) + sum = 0; + + led->pwm = sum >> shift; + sum -= led->pwm << shift; + led->err_sum = sum; + + if (led->pwm >= PWM_MAX + || (n == 1 && led->pwm > PWM_MAX/2 && adcval < 0x08)) { + pwmled_err(n); + return; } + if (led->state == ST_PROBING) + if (pwmled_probed_ok(n, old_pwm)) + return; + + if (led->pwm == old_pwm) + return; + pwm_set(n, led->pwm); }