FreeCalypso > hg > fc-tourmaline

comparison src/cs/drivers/drv_app/fchg/fchg_process.c @ 61:75067af48bfd

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
FCHG updates for Tourmaline UI integration
author Mychaela Falconia <falcon@freecalypso.org>
date Thu, 22 Oct 2020 22:30:49 +0000
parents 4e78acac3d88
children 3c790d29748e
comparison
equal deleted inserted replaced
60:48f280c19e16 61:75067af48bfd
32 UINT16 i; 32 UINT16 i;
33 char trace[64]; 33 char trace[64];
34 34
35 /* first we need to find the current threshold we are at */ 35 /* first we need to find the current threshold we are at */
36 i = pwr_ctrl->curr_disch_thresh; 36 i = pwr_ctrl->curr_disch_thresh;
37 /* is there one below? */ 37 /* are we at the bottom? */
38 if (++i == pwr_ctrl->nb_thresholds) 38 if ((i + 1) == pwr_ctrl->nb_percent_thresh)
39 return; 39 return;
40 /* are we crossing it? */ 40 /* are we crossing our current threshold? */
41 if (pwr_ctrl->batt_mv >= pwr_ctrl->batt_thresholds[i].bat_voltage) 41 if (pwr_ctrl->batt_mv >= pwr_ctrl->batt.percent_thresh[i].bat_voltage)
42 return; 42 return;
43 /* yes, we crossed it - see if we fell even further down */ 43 /* yes, we crossed it - see if we fell even further down */
44 while (i < pwr_ctrl->nb_thresholds && 44 while (i < pwr_ctrl->nb_percent_thresh-1 &&
45 pwr_ctrl->batt_mv < pwr_ctrl->batt_thresholds[i].bat_voltage) 45 pwr_ctrl->batt_mv < pwr_ctrl->batt.percent_thresh[i].bat_voltage)
46 i++; 46 i++;
47 /* the last one was it */ 47 /* the last one was it */
48 i--;
49 pwr_ctrl->curr_disch_thresh = i; 48 pwr_ctrl->curr_disch_thresh = i;
50 sprintf(trace, "Battery fell through %u%% mark", 49 sprintf(trace, "Battery fell through %u%% mark",
51 pwr_ctrl->batt_thresholds[i].remain_capa); 50 pwr_ctrl->batt.percent_thresh[i-1].remain_capa);
52 rvf_send_trace(trace, strlen(trace), NULL_PARAM, 51 rvf_send_trace(trace, strlen(trace), NULL_PARAM,
53 RV_TRACE_LEVEL_WARNING, FCHG_USE_ID); 52 RV_TRACE_LEVEL_WARNING, FCHG_USE_ID);
53 if (pwr_ctrl->event_handler)
54 pwr_ctrl->event_handler(FCHG_EVENT_DISCHARGE);
54 } 55 }
55 56
56 static void start_i2v_cal(void) 57 static void start_i2v_cal(void)
57 { 58 {
58 UINT16 bciconf; 59 UINT16 bciconf;
84 pwr_ctrl->config.ci_current + pwr_ctrl->i2v_offset); 85 pwr_ctrl->config.ci_current + pwr_ctrl->i2v_offset);
85 /* Enable the charger */ 86 /* Enable the charger */
86 ABB_Write_Register_on_page(PAGE0, BCICTL2, 0x0003 | LEDC); 87 ABB_Write_Register_on_page(PAGE0, BCICTL2, 0x0003 | LEDC);
87 /* The total charging time starts now */ 88 /* The total charging time starts now */
88 pwr_ctrl->start_time = rvf_get_tick_count(); 89 pwr_ctrl->start_time = rvf_get_tick_count();
90 if (pwr_ctrl->event_handler)
91 pwr_ctrl->event_handler(FCHG_EVENT_CHARGING_START);
89 } 92 }
90 93
91 static void start_cv_charging(void) 94 static void start_cv_charging(void)
92 { 95 {
93 UINT16 code; 96 UINT16 code;
130 133
131 static void ci_progress_trace(UINT16 ichg) 134 static void ci_progress_trace(UINT16 ichg)
132 { 135 {
133 char trace[64]; 136 char trace[64];
134 137
138 pwr_ctrl->ci_ichg = ichg;
135 sprintf(trace, "CI charging: Vbat=%u Ichg=%u i2v=%u", 139 sprintf(trace, "CI charging: Vbat=%u Ichg=%u i2v=%u",
136 pwr_ctrl->batt_mv, ichg, pwr_ctrl->i2v_offset); 140 pwr_ctrl->batt_mv, ichg, pwr_ctrl->i2v_offset);
137 rvf_send_trace(trace, strlen(trace), NULL_PARAM, 141 rvf_send_trace(trace, strlen(trace), NULL_PARAM,
138 RV_TRACE_LEVEL_DEBUG_LOW, FCHG_USE_ID); 142 RV_TRACE_LEVEL_DEBUG_LOW, FCHG_USE_ID);
139 } 143 }
178 rvf_send_trace("Stopping charge by low current condition", 40, 182 rvf_send_trace("Stopping charge by low current condition", 40,
179 NULL_PARAM, RV_TRACE_LEVEL_DEBUG_HIGH, FCHG_USE_ID); 183 NULL_PARAM, RV_TRACE_LEVEL_DEBUG_HIGH, FCHG_USE_ID);
180 ABB_Write_Register_on_page(PAGE0, BCICTL2, 0); 184 ABB_Write_Register_on_page(PAGE0, BCICTL2, 0);
181 pwr_init_discharge(); 185 pwr_init_discharge();
182 pwr_ctrl->state = FCHG_STATE_READY_TO_RECHARGE; 186 pwr_ctrl->state = FCHG_STATE_READY_TO_RECHARGE;
187 if (pwr_ctrl->event_handler)
188 pwr_ctrl->event_handler(FCHG_EVENT_CHARGING_COMPLETE);
183 return 1; 189 return 1;
184 } 190 }
185 191
186 static int overvoltage_end_charge_check(void) 192 static int overvoltage_end_charge_check(void)
187 { 193 {
193 rvf_send_trace("Stopping charge by overvoltage condition", 40, 199 rvf_send_trace("Stopping charge by overvoltage condition", 40,
194 NULL_PARAM, RV_TRACE_LEVEL_WARNING, FCHG_USE_ID); 200 NULL_PARAM, RV_TRACE_LEVEL_WARNING, FCHG_USE_ID);
195 ABB_Write_Register_on_page(PAGE0, BCICTL2, 0); 201 ABB_Write_Register_on_page(PAGE0, BCICTL2, 0);
196 pwr_init_discharge(); 202 pwr_init_discharge();
197 pwr_ctrl->state = FCHG_STATE_READY_TO_RECHARGE; 203 pwr_ctrl->state = FCHG_STATE_READY_TO_RECHARGE;
204 if (pwr_ctrl->event_handler)
205 pwr_ctrl->event_handler(FCHG_EVENT_CHARGING_COMPLETE);
198 return 1; 206 return 1;
199 } 207 }
200 208
201 static void cv_ctrl_loop_high_check(void) 209 static void cv_ctrl_loop_high_check(void)
202 { 210 {
245 NULL_PARAM, RV_TRACE_LEVEL_WARNING, FCHG_USE_ID); 253 NULL_PARAM, RV_TRACE_LEVEL_WARNING, FCHG_USE_ID);
246 ABB_Write_Register_on_page(PAGE0, BCICTL2, 0); 254 ABB_Write_Register_on_page(PAGE0, BCICTL2, 0);
247 pwr_init_discharge(); 255 pwr_init_discharge();
248 pwr_ctrl->state = FCHG_STATE_RECHARGE_TIMER; 256 pwr_ctrl->state = FCHG_STATE_RECHARGE_TIMER;
249 pwr_ctrl->start_time = rvf_get_tick_count(); 257 pwr_ctrl->start_time = rvf_get_tick_count();
258 if (pwr_ctrl->event_handler)
259 pwr_ctrl->event_handler(FCHG_EVENT_CHARGING_TIMEOUT);
250 return 1; 260 return 1;
251 } 261 }
252 262
253 void pwr_process_adc(struct pwr_adc_ind_s *msg) 263 void pwr_process_adc(struct pwr_adc_ind_s *msg)
254 { 264 {
383 } else { 393 } else {
384 rvf_send_trace("Charger plug, ready to charge", 29, NULL_PARAM, 394 rvf_send_trace("Charger plug, ready to charge", 29, NULL_PARAM,
385 RV_TRACE_LEVEL_DEBUG_HIGH, FCHG_USE_ID); 395 RV_TRACE_LEVEL_DEBUG_HIGH, FCHG_USE_ID);
386 pwr_ctrl->state = FCHG_STATE_READY_TO_CHARGE; 396 pwr_ctrl->state = FCHG_STATE_READY_TO_CHARGE;
387 } 397 }
398 if (pwr_ctrl->event_handler)
399 pwr_ctrl->event_handler(FCHG_EVENT_CHARGER_PLUG);
388 } 400 }
389 401
390 void pwr_charger_unplug(void) 402 void pwr_charger_unplug(void)
391 { 403 {
392 switch (pwr_ctrl->state) { 404 switch (pwr_ctrl->state) {
393 case FCHG_STATE_NO_EXT_PWR: 405 case FCHG_STATE_NO_EXT_PWR:
394 rvf_send_trace("Charger unplug, already handled", 31, 406 rvf_send_trace("Charger unplug, already handled", 31,
395 NULL_PARAM, RV_TRACE_LEVEL_DEBUG_LOW, 407 NULL_PARAM, RV_TRACE_LEVEL_DEBUG_LOW,
396 FCHG_USE_ID); 408 FCHG_USE_ID);
397 /* nothing to do */ 409 /* nothing to do */
398 return; 410 break;
399 case FCHG_STATE_PWR_PLUG_TIMER: 411 case FCHG_STATE_PWR_PLUG_TIMER:
400 case FCHG_STATE_READY_TO_CHARGE: 412 case FCHG_STATE_READY_TO_CHARGE:
401 case FCHG_STATE_READY_TO_RECHARGE: 413 case FCHG_STATE_READY_TO_RECHARGE:
402 case FCHG_STATE_I2V_CAL_1: 414 case FCHG_STATE_I2V_CAL_1:
403 case FCHG_STATE_RECHARGE_TIMER: 415 case FCHG_STATE_RECHARGE_TIMER:
404 case FCHG_STATE_NO_CHARGING: 416 case FCHG_STATE_NO_CHARGING:
405 rvf_send_trace("Charger unplug", 14, NULL_PARAM, 417 rvf_send_trace("Charger unplug", 14, NULL_PARAM,
406 RV_TRACE_LEVEL_DEBUG_LOW, FCHG_USE_ID); 418 RV_TRACE_LEVEL_DEBUG_LOW, FCHG_USE_ID);
407 pwr_ctrl->state = FCHG_STATE_NO_EXT_PWR; 419 pwr_ctrl->state = FCHG_STATE_NO_EXT_PWR;
408 return; 420 break;
409 case FCHG_STATE_I2V_CAL_2: 421 case FCHG_STATE_I2V_CAL_2:
410 case FCHG_STATE_CI_CHARGING: 422 case FCHG_STATE_CI_CHARGING:
411 case FCHG_STATE_CV_CHARGING: 423 case FCHG_STATE_CV_CHARGING:
412 ABB_Write_Register_on_page(PAGE0, BCICTL2, 0); 424 ABB_Write_Register_on_page(PAGE0, BCICTL2, 0);
413 rvf_send_trace("Charger unplug, charging stopped", 32, 425 rvf_send_trace("Charger unplug, charging stopped", 32,
414 NULL_PARAM, RV_TRACE_LEVEL_DEBUG_HIGH, 426 NULL_PARAM, RV_TRACE_LEVEL_DEBUG_HIGH,
415 FCHG_USE_ID); 427 FCHG_USE_ID);
416 pwr_ctrl->state = FCHG_STATE_NO_EXT_PWR; 428 pwr_ctrl->state = FCHG_STATE_NO_EXT_PWR;
417 pwr_init_discharge(); 429 pwr_init_discharge();
418 return; 430 break;
419 default: 431 default:
420 rvf_send_trace("Invalid state in pwr_charger_unplug()", 35, 432 rvf_send_trace("Invalid state in pwr_charger_unplug()", 35,
421 pwr_ctrl->state, RV_TRACE_LEVEL_ERROR, 433 pwr_ctrl->state, RV_TRACE_LEVEL_ERROR,
422 FCHG_USE_ID); 434 FCHG_USE_ID);
423 } 435 }
436 if (pwr_ctrl->event_handler)
437 pwr_ctrl->event_handler(FCHG_EVENT_CHARGER_UNPLUG);
424 } 438 }
425 439
426 void pwr_charge_start_req(void) 440 void pwr_charge_start_req(void)
427 { 441 {
428 switch (pwr_ctrl->state) { 442 switch (pwr_ctrl->state) {
486 rvf_send_trace("Charging stopped by user request", 32, 500 rvf_send_trace("Charging stopped by user request", 32,
487 NULL_PARAM, RV_TRACE_LEVEL_DEBUG_HIGH, 501 NULL_PARAM, RV_TRACE_LEVEL_DEBUG_HIGH,
488 FCHG_USE_ID); 502 FCHG_USE_ID);
489 pwr_ctrl->state = FCHG_STATE_NO_CHARGING; 503 pwr_ctrl->state = FCHG_STATE_NO_CHARGING;
490 pwr_init_discharge(); 504 pwr_init_discharge();
505 if (pwr_ctrl->event_handler)
506 pwr_ctrl->event_handler(FCHG_EVENT_CHARGING_STOPPED);
491 return; 507 return;
492 default: 508 default:
493 rvf_send_trace("Invalid state in pwr_charge_stop_req()", 36, 509 rvf_send_trace("Invalid state in pwr_charge_stop_req()", 36,
494 pwr_ctrl->state, RV_TRACE_LEVEL_ERROR, 510 pwr_ctrl->state, RV_TRACE_LEVEL_ERROR,
495 FCHG_USE_ID); 511 FCHG_USE_ID);