1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
|
// Emisar D3AA helper functions
// Copyright (C) 2023 Selene ToyKeeper
// SPDX-License-Identifier: GPL-3.0-or-later
#pragma once
#include "fsm/chan-rgbaux.c"
#include "fsm/ramping.h"
#include "ui/anduril/misc.h"
void set_level_zero();
void set_level_main(uint8_t level);
bool gradual_tick_main(uint8_t gt);
Channel channels[] = {
{ // main LEDs
.set_level = set_level_main,
.gradual_tick = gradual_tick_main
},
RGB_AUX_CHANNELS
};
void set_level_zero() {
DAC_LVL = 0; // DAC off
DAC_VREF = V10; // low Vref
HDR_ENABLE_PORT &= ~(1 << HDR_ENABLE_PIN); // HDR off
// prevent post-off flash
IN_NFET_ENABLE_PORT |= (1 << IN_NFET_ENABLE_PIN);
delay_4ms(IN_NFET_DELAY_TIME/4);
IN_NFET_ENABLE_PORT &= ~(1 << IN_NFET_ENABLE_PIN);
// turn off boost last
BST_ENABLE_PORT &= ~(1 << BST_ENABLE_PIN); // BST off
}
// single set of LEDs with 1 regulated power channel
// and low/high HDR plus low/high Vref as different "gears"
void set_level_main(uint8_t level) {
uint8_t noflash = 0;
// when turning on from off, use IN_NFET to prevent a flash
if ((! actual_level) && (level < HDR_ENABLE_LEVEL_MIN)) {
noflash = 1;
IN_NFET_ENABLE_PORT |= (1 << IN_NFET_ENABLE_PIN);
}
// BST on first, to give it a few extra microseconds to spin up
BST_ENABLE_PORT |= (1 << BST_ENABLE_PIN);
// pre-load ramp data so it can be assigned faster later
// DAC level register is left-aligned
PWM1_DATATYPE dac_lvl = PWM1_GET(level) << 6;
PWM2_DATATYPE dac_vref = PWM2_GET(level);
// enable HDR on top half of ramp
if (level >= (HDR_ENABLE_LEVEL_MIN-1))
HDR_ENABLE_PORT |= (1 << HDR_ENABLE_PIN);
else
HDR_ENABLE_PORT &= ~(1 << HDR_ENABLE_PIN);
// set these in successive clock cycles to avoid getting out of sync
// (minimizes ramp bumps when changing gears)
DAC_LVL = dac_lvl;
DAC_VREF = dac_vref;
if (noflash) {
// wait for flash prevention to finish
delay_4ms(IN_NFET_DELAY_TIME/4);
IN_NFET_ENABLE_PORT &= ~(1 << IN_NFET_ENABLE_PIN);
}
}
bool gradual_tick_main(uint8_t gt) {
// if HDR and Vref "engine gear" is the same, do a small adjustment...
// otherwise, simply jump to the next ramp level
// and let set_level() handle any gear changes
// different gear = full adjustment
PWM2_DATATYPE vref_next = PWM2_GET(gt);
if (vref_next != DAC_VREF) return true; // let parent set_level() for us
// same gear = small adjustment
PWM1_DATATYPE dac_now = DAC_LVL >> 6; // register is left-aligned
PWM1_DATATYPE dac_next = PWM1_GET(gt);
// only adjust 1 dac level, max is 1023
// (but speed it up with "#define GRADUAL_ADJUST_SPEED 4" elsewhere)
GRADUAL_ADJUST_SIMPLE(dac_next, dac_now);
DAC_LVL = dac_now << 6;
if (dac_next == dac_now) return true; // done
return false; // not done yet
}
#ifdef USE_VOLTAGE_DIVIDER
uint8_t voltage_raw2cooked(uint16_t measurement) {
// In : 65535 * BATTLVL / 1.024V
// Out: uint8_t: Vbat * 40
// BATTLVL = Vbat * (100.0/(330+100)) = Vbat / 4.3
// So, Out = In * 4.3 / 1600
// (plus a bit of fudging to fix the slope and offset,
// based on measuring actual hardware)
uint8_t result = (uint32_t)(measurement + (65535 * 4 / 1024))
* 43 / 16000;
return result;
}
#endif
#ifdef USE_WEAK_BATTERY_PROTECTION
uint8_t quick_volt_measurement() {
// wait for next hardware measurement
irq_adc = 0;
while (! irq_adc) {}
uint16_t m = adc_raw[0];
return voltage_raw2cooked(m);
}
void detect_weak_battery() {
// guess at the cell strength with a load test...
// - measure voltage while LEDs off
// - measure again with LEDs on
// - determine how much to limit power
// - blink to indicate weak battery mode, if active
ramp_level_hard_limit = 0;
uint16_t resting, loaded;
// baseline unloaded measurement
set_level(0);
for (uint8_t i=0; i<32; i++) { delay_zero(); } // wait about 10ms
//resting = voltage_raw2cooked(adc_smooth[0]); // probably not settled yet
resting = quick_volt_measurement();
// set thresholds per cell type
uint8_t sag_limit, crit_voltage;
if (resting > DUAL_VOLTAGE_FLOOR) {
sag_limit = WEAK_BATTERY_SAG_THRESHOLD_LIION;
crit_voltage = VOLTAGE_LOW;
} else {
sag_limit = WEAK_BATTERY_SAG_THRESHOLD_AA;
crit_voltage = DUAL_VOLTAGE_LOW_LOW;
}
// progressively turn up the power until sag threshold is hit,
// or critical voltage, or max testing level is reached
for (uint8_t l=1; l<WEAK_BATTERY_TEST_MAX_LEVEL; l++) {
set_level(l);
loaded = quick_volt_measurement();
int16_t sag = resting - loaded;
if ( (loaded <= crit_voltage) || (sag > sag_limit) ) {
// battery empty or weak
ramp_level_hard_limit = l;
break;
}
}
set_level(0);
// TODO? limit NiMH to ~half power, even if it passed the sag test?
// (and if so, blink 2X for NiMH, 3X for alkaline)
uint8_t extra_blinks = 0;
if (ramp_level_hard_limit) extra_blinks ++;
for (uint8_t i=0; i<extra_blinks; i++) {
delay_4ms(300/4);
blink_once();
}
if (ramp_level_hard_limit) {
delay_4ms(255);
// not booted far enough for this to work yet
//blink_num(ramp_level_hard_limit);
uint8_t tens, ones;
tens = ramp_level_hard_limit / 10;
ones = ramp_level_hard_limit % 10;
for (uint8_t i=0; i<tens; i++) {
delay_4ms(300/4);
blink_once();
}
delay_4ms(600/4);
for (uint8_t i=0; i<ones; i++) {
delay_4ms(300/4);
blink_once();
}
}
}
#endif // ifdef USE_WEAK_BATTERY_PROTECTION
|
