backlight_pwm.c (5875B)
1 #include "backlight.h" 2 #include "gpio.h" 3 #include "wait.h" 4 #include <hal.h> 5 6 // Maximum duty cycle limit 7 #ifndef BACKLIGHT_LIMIT_VAL 8 # define BACKLIGHT_LIMIT_VAL 255 9 #endif 10 11 #ifndef BACKLIGHT_PAL_MODE 12 # if defined(USE_GPIOV1) 13 # define BACKLIGHT_PAL_MODE PAL_MODE_ALTERNATE_PUSHPULL 14 # else 15 // GPIOV2 && GPIOV3 16 # define BACKLIGHT_PAL_MODE 2 17 # endif 18 #endif 19 20 // GENERIC 21 #ifndef BACKLIGHT_PWM_DRIVER 22 # define BACKLIGHT_PWM_DRIVER PWMD4 23 #endif 24 #ifndef BACKLIGHT_PWM_CHANNEL 25 # define BACKLIGHT_PWM_CHANNEL 3 26 #endif 27 28 // Support for pins which are on TIM1_CH1N 29 #ifdef BACKLIGHT_PWM_COMPLEMENTARY_OUTPUT 30 # if BACKLIGHT_ON_STATE == 1 31 # define PWM_OUTPUT_MODE PWM_COMPLEMENTARY_OUTPUT_ACTIVE_HIGH; 32 # else 33 # define PWM_OUTPUT_MODE PWM_COMPLEMENTARY_OUTPUT_ACTIVE_LOW; 34 # endif 35 #else 36 # if BACKLIGHT_ON_STATE == 1 37 # define PWM_OUTPUT_MODE PWM_OUTPUT_ACTIVE_HIGH; 38 # else 39 # define PWM_OUTPUT_MODE PWM_OUTPUT_ACTIVE_LOW; 40 # endif 41 #endif 42 43 #ifndef BACKLIGHT_PWM_COUNTER_FREQUENCY 44 # define BACKLIGHT_PWM_COUNTER_FREQUENCY 0xFFFF 45 #endif 46 47 #ifndef BACKLIGHT_PWM_PERIOD 48 # define BACKLIGHT_PWM_PERIOD 256 49 #endif 50 51 static PWMConfig pwmCFG = { 52 .frequency = BACKLIGHT_PWM_COUNTER_FREQUENCY, /* PWM clock frequency */ 53 .period = BACKLIGHT_PWM_PERIOD, /* PWM period in counter ticks. e.g. clock frequency is 10KHz, period is 256 ticks then t_period is 25.6ms */ 54 }; 55 56 #ifdef BACKLIGHT_BREATHING 57 static virtual_timer_t breathing_vt; 58 #endif 59 60 // See http://jared.geek.nz/2013/feb/linear-led-pwm 61 static uint16_t cie_lightness(uint16_t v) { 62 if (v <= 5243) // if below 8% of max 63 return v / 9; // same as dividing by 900% 64 else { 65 uint32_t y = (((uint32_t)v + 10486) << 8) / (10486 + 0xFFFFUL); // add 16% of max and compare 66 // to get a useful result with integer division, we shift left in the expression above 67 // and revert what we've done again after squaring. 68 y = y * y * y >> 8; 69 if (y > 0xFFFFUL) { // prevent overflow 70 return 0xFFFFU; 71 } else { 72 return (uint16_t)y; 73 } 74 } 75 } 76 77 static uint32_t rescale_limit_val(uint32_t val) { 78 // rescale the supplied backlight value to be in terms of the value limit 79 return (val * (BACKLIGHT_LIMIT_VAL + 1)) / 256; 80 } 81 82 void backlight_init_ports(void) { 83 #ifdef USE_GPIOV1 84 palSetPadMode(PAL_PORT(BACKLIGHT_PIN), PAL_PAD(BACKLIGHT_PIN), BACKLIGHT_PAL_MODE); 85 #else 86 palSetPadMode(PAL_PORT(BACKLIGHT_PIN), PAL_PAD(BACKLIGHT_PIN), PAL_MODE_ALTERNATE(BACKLIGHT_PAL_MODE)); 87 #endif 88 89 pwmCFG.channels[BACKLIGHT_PWM_CHANNEL - 1].mode = PWM_OUTPUT_MODE; 90 pwmStart(&BACKLIGHT_PWM_DRIVER, &pwmCFG); 91 92 backlight_set(get_backlight_level()); 93 94 #ifdef BACKLIGHT_BREATHING 95 chVTObjectInit(&breathing_vt); 96 if (is_backlight_breathing()) { 97 breathing_enable(); 98 } 99 #endif 100 } 101 102 void backlight_set(uint8_t level) { 103 if (level > BACKLIGHT_LEVELS) { 104 level = BACKLIGHT_LEVELS; 105 } 106 107 if (level == 0) { 108 // Turn backlight off 109 pwmDisableChannel(&BACKLIGHT_PWM_DRIVER, BACKLIGHT_PWM_CHANNEL - 1); 110 } else { 111 // Turn backlight on 112 uint32_t duty = (uint32_t)(cie_lightness(rescale_limit_val(0xFFFF * (uint32_t)level / BACKLIGHT_LEVELS))); 113 pwmEnableChannel(&BACKLIGHT_PWM_DRIVER, BACKLIGHT_PWM_CHANNEL - 1, PWM_FRACTION_TO_WIDTH(&BACKLIGHT_PWM_DRIVER, 0xFFFF, duty)); 114 } 115 } 116 117 void backlight_task(void) {} 118 119 #ifdef BACKLIGHT_BREATHING 120 121 # define BREATHING_STEPS 128 122 123 /* To generate breathing curve in python: 124 * from math import sin, pi; [int(sin(x/128.0*pi)**4*255) for x in range(128)] 125 */ 126 static const uint8_t breathing_table[BREATHING_STEPS] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 3, 4, 5, 6, 8, 10, 12, 15, 17, 20, 24, 28, 32, 36, 41, 46, 51, 57, 63, 70, 76, 83, 91, 98, 106, 113, 121, 129, 138, 146, 154, 162, 170, 178, 185, 193, 200, 207, 213, 220, 225, 231, 235, 240, 244, 247, 250, 252, 253, 254, 255, 254, 253, 252, 250, 247, 244, 240, 235, 231, 225, 220, 213, 207, 200, 193, 185, 178, 170, 162, 154, 146, 138, 129, 121, 113, 106, 98, 91, 83, 76, 70, 63, 57, 51, 46, 41, 36, 32, 28, 24, 20, 17, 15, 12, 10, 8, 6, 5, 4, 3, 2, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; 127 128 static void breathing_callback(virtual_timer_t *vtp, void *p); 129 130 bool is_breathing(void) { 131 return chVTIsArmed(&breathing_vt); 132 } 133 134 void breathing_enable(void) { 135 /* Update frequency is 256Hz -> 3906us intervals */ 136 chVTSetContinuous(&breathing_vt, TIME_US2I(3906), breathing_callback, NULL); 137 } 138 139 void breathing_disable(void) { 140 chVTReset(&breathing_vt); 141 142 // Restore backlight level 143 backlight_set(get_backlight_level()); 144 } 145 146 // Use this before the cie_lightness function. 147 static inline uint16_t scale_backlight(uint16_t v) { 148 return v / BACKLIGHT_LEVELS * get_backlight_level(); 149 } 150 151 static void breathing_callback(virtual_timer_t *vtp, void *p) { 152 uint8_t breathing_period = get_breathing_period(); 153 uint16_t interval = (uint16_t)breathing_period * 256 / BREATHING_STEPS; 154 155 // resetting after one period to prevent ugly reset at overflow. 156 static uint16_t breathing_counter = 0; 157 breathing_counter = (breathing_counter + 1) % (breathing_period * 256); 158 uint8_t index = breathing_counter / interval % BREATHING_STEPS; 159 uint32_t duty = cie_lightness(rescale_limit_val(scale_backlight(breathing_table[index] * 256))); 160 161 chSysLockFromISR(); 162 pwmEnableChannelI(&BACKLIGHT_PWM_DRIVER, BACKLIGHT_PWM_CHANNEL - 1, PWM_FRACTION_TO_WIDTH(&BACKLIGHT_PWM_DRIVER, 0xFFFF, duty)); 163 chSysUnlockFromISR(); 164 } 165 166 // TODO: integrate generic pulse solution 167 void breathing_pulse(void) { 168 backlight_set(is_backlight_enabled() ? 0 : BACKLIGHT_LEVELS); 169 wait_ms(10); 170 backlight_set(is_backlight_enabled() ? get_backlight_level() : 0); 171 } 172 173 #endif