← Back to branch summary

~toykeeper/flashlight-firmware/trunk

« back to all changes in this revision

Viewing changes to ToyKeeper/spaghetti-monster/fsm-ramping.c

  • Committer: Selene Scriven
  • Date: 2020-07-06 20:24:28 UTC
  • mfrom: (188.1.294 fsm)
  • Revision ID: bzr@toykeeper.net-20200706202428-7pyen2ow9q2rtd9p
merged nearly a year of updates from the fsm branch, including the new product map

Show diffs side-by-side

added added

removed removed

Lines of Context:
ToyKeeper/spaghetti-monster/fsm-ramping.c
46
46
            #endif
47
47
            #ifdef USE_AUX_RGB_LEDS
48
48
                rgb_led_set(0);
 
49
                #ifdef USE_BUTTON_LED
 
50
                    button_led_set((level > 0) + (level > MAX_1x7135));
 
51
                #endif
49
52
            #endif
50
53
        }
51
54
        #endif
65
68
        #if PWM_CHANNELS >= 4
66
69
        PWM4_LVL = 0;
67
70
        #endif
 
71
        // disable the power channel, if relevant
 
72
        #ifdef LED_ENABLE_PIN
 
73
        LED_ENABLE_PORT &= ~(1 << LED_ENABLE_PIN);
 
74
        #endif
 
75
        #ifdef LED_ENABLE2_PIN
 
76
        LED_ENABLE2_PORT &= ~(1 << LED_ENABLE2_PIN);
 
77
        #endif
68
78
    } else {
69
79
        level --;
70
80
 
 
81
        // enable the power channel, if relevant
 
82
        #ifdef LED_ENABLE_PIN
 
83
        LED_ENABLE_PORT |= (1 << LED_ENABLE_PIN);
 
84
        #endif
 
85
        #ifdef LED_ENABLE2_PIN
 
86
        LED_ENABLE2_PORT |= (1 << LED_ENABLE2_PIN);
 
87
        #endif
 
88
 
71
89
        #ifdef USE_TINT_RAMPING
 
90
        #ifndef TINT_RAMPING_CORRECTION
 
91
        #define TINT_RAMPING_CORRECTION 26  // 140% brightness at middle tint
 
92
        #endif
72
93
        // calculate actual PWM levels based on a single-channel ramp
73
94
        // and a global tint value
74
 
        uint8_t brightness = pgm_read_byte(pwm1_levels + level);
 
95
        uint8_t brightness = PWM_GET(pwm1_levels, level);
75
96
        uint8_t warm_PWM, cool_PWM;
76
97
 
77
98
        // auto-tint modes
93
114
        // correction is only necessary when PWM is fast
94
115
        if (level > HALFSPEED_LEVEL) {
95
116
            base_PWM = brightness
96
 
                     + ((((uint16_t)brightness) * 26 / 64) * triangle_wave(mytint) / 255);
 
117
                     + ((((uint16_t)brightness) * TINT_RAMPING_CORRECTION / 64) * triangle_wave(mytint) / 255);
97
118
        }
98
119
 
99
120
        cool_PWM = (((uint16_t)mytint * (uint16_t)base_PWM) + 127) / 255;
104
125
        #else
105
126
 
106
127
        #if PWM_CHANNELS >= 1
107
 
        PWM1_LVL = pgm_read_byte(pwm1_levels + level);
 
128
        PWM1_LVL = PWM_GET(pwm1_levels, level);
108
129
        #endif
109
130
        #if PWM_CHANNELS >= 2
110
 
        PWM2_LVL = pgm_read_byte(pwm2_levels + level);
 
131
        PWM2_LVL = PWM_GET(pwm2_levels, level);
111
132
        #endif
112
133
        #if PWM_CHANNELS >= 3
113
 
        PWM3_LVL = pgm_read_byte(pwm3_levels + level);
 
134
        PWM3_LVL = PWM_GET(pwm3_levels, level);
114
135
        #endif
115
136
        #if PWM_CHANNELS >= 4
116
 
        PWM4_LVL = pgm_read_byte(pwm4_levels + level);
 
137
        PWM4_LVL = PWM_GET(pwm4_levels, level);
117
138
        #endif
118
139
 
119
140
        #endif  // ifdef USE_TINT_RAMPING
137
158
 
138
159
    gt --;  // convert 1-based number to 0-based
139
160
 
140
 
    uint8_t target;
 
161
    PWM_DATATYPE target;
141
162
 
142
163
    #if PWM_CHANNELS >= 1
143
 
    target = pgm_read_byte(pwm1_levels + gt);
 
164
    target = PWM_GET(pwm1_levels, gt);
144
165
    if ((gt < actual_level)     // special case for FET-only turbo
145
166
            && (PWM1_LVL == 0)  // (bypass adjustment period for first step)
146
 
            && (target == 255)) PWM1_LVL = 255;
 
167
            && (target == PWM_TOP)) PWM1_LVL = PWM_TOP;
147
168
    else if (PWM1_LVL < target) PWM1_LVL ++;
148
169
    else if (PWM1_LVL > target) PWM1_LVL --;
149
170
    #endif
150
171
    #if PWM_CHANNELS >= 2
151
 
    target = pgm_read_byte(pwm2_levels + gt);
 
172
    target = PWM_GET(pwm2_levels, gt);
152
173
    if (PWM2_LVL < target) PWM2_LVL ++;
153
174
    else if (PWM2_LVL > target) PWM2_LVL --;
154
175
    #endif
155
176
    #if PWM_CHANNELS >= 3
156
 
    target = pgm_read_byte(pwm3_levels + gt);
 
177
    target = PWM_GET(pwm3_levels, gt);
157
178
    if (PWM3_LVL < target) PWM3_LVL ++;
158
179
    else if (PWM3_LVL > target) PWM3_LVL --;
159
180
    #endif
160
181
    #if PWM_CHANNELS >= 4
161
 
    target = pgm_read_byte(pwm4_levels + gt);
 
182
    target = PWM_GET(pwm4_levels, gt);
162
183
    if (PWM4_LVL < target) PWM4_LVL ++;
163
184
    else if (PWM4_LVL > target) PWM4_LVL --;
164
185
    #endif
165
186
 
166
187
    // did we go far enough to hit the next defined ramp level?
167
188
    // if so, update the main ramp level tracking var
168
 
    if ((PWM1_LVL == pgm_read_byte(pwm1_levels + gt))
 
189
    if ((PWM1_LVL == PWM_GET(pwm1_levels, gt))
169
190
        #if PWM_CHANNELS >= 2
170
 
            && (PWM2_LVL == pgm_read_byte(pwm2_levels + gt))
 
191
            && (PWM2_LVL == PWM_GET(pwm2_levels, gt))
171
192
        #endif
172
193
        #if PWM_CHANNELS >= 3
173
 
            && (PWM3_LVL == pgm_read_byte(pwm3_levels + gt))
 
194
            && (PWM3_LVL == PWM_GET(pwm3_levels, gt))
174
195
        #endif
175
196
        #if PWM_CHANNELS >= 4
176
 
            && (PWM4_LVL == pgm_read_byte(pwm4_levels + gt))
 
197
            && (PWM4_LVL == PWM_GET(pwm4_levels, gt))
177
198
        #endif
178
199
        )
179
200
    {