FreeCalypso > hg > fc-tourmaline

comparison src/cs/drivers/drv_app/fchg/fchg_process.c @ 253:769cf6273fe4

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
FCHG: beginning of battery simulation mode
author Mychaela Falconia <falcon@freecalypso.org>
date Wed, 12 May 2021 11:14:51 +0000
parents 305d3bb691a5
children 1a4413c4eb7e
comparison
equal deleted inserted replaced
252:27f17fbf0657 253:769cf6273fe4
275 if (pwr_ctrl->event_handler) 275 if (pwr_ctrl->event_handler)
276 pwr_ctrl->event_handler(FCHG_EVENT_CHARGING_TIMEOUT); 276 pwr_ctrl->event_handler(FCHG_EVENT_CHARGING_TIMEOUT);
277 return 1; 277 return 1;
278 } 278 }
279 279
280 void pwr_process_adc(struct pwr_adc_ind_s *msg) 280 static void process_adc_regular(struct pwr_adc_ind_s *msg)
281 { 281 {
282 pwr_ctrl->batt_mv = madc_vbat_2_physical(msg->data[0]);
283 if (!fchg_first_vbat)
284 capture_first_vbat();
285
286 switch (pwr_ctrl->state) { 282 switch (pwr_ctrl->state) {
287 case FCHG_STATE_NO_EXT_PWR: 283 case FCHG_STATE_NO_EXT_PWR:
288 case FCHG_STATE_PWR_PLUG_TIMER: 284 case FCHG_STATE_PWR_PLUG_TIMER:
289 case FCHG_STATE_NO_CHARGING: 285 case FCHG_STATE_NO_CHARGING:
290 handle_discharge(); 286 handle_discharge();
291 break; 287 return;
292 case FCHG_STATE_READY_TO_CHARGE: 288 case FCHG_STATE_READY_TO_CHARGE:
293 handle_discharge(); 289 handle_discharge();
294 if (!(msg->data[9] & CHGPRES)) { 290 if (!(msg->data[9] & CHGPRES)) {
295 pwr_ctrl->state = FCHG_STATE_NO_EXT_PWR; 291 pwr_ctrl->state = FCHG_STATE_NO_EXT_PWR;
296 break; 292 return;
297 } 293 }
298 if (pwr_ctrl->batt_mv < pwr_ctrl->config.start_thresh) 294 if (pwr_ctrl->batt_mv < pwr_ctrl->config.start_thresh)
299 start_charge_condition_met(); 295 start_charge_condition_met();
300 break; 296 return;
301 case FCHG_STATE_READY_TO_RECHARGE: 297 case FCHG_STATE_READY_TO_RECHARGE:
302 handle_discharge(); 298 handle_discharge();
303 if (!(msg->data[9] & CHGPRES)) { 299 if (!(msg->data[9] & CHGPRES)) {
304 pwr_ctrl->state = FCHG_STATE_NO_EXT_PWR; 300 pwr_ctrl->state = FCHG_STATE_NO_EXT_PWR;
305 break; 301 return;
306 } 302 }
307 if (pwr_ctrl->batt_mv < pwr_ctrl->config.restart_thresh) 303 if (pwr_ctrl->batt_mv < pwr_ctrl->config.restart_thresh)
308 start_charge_condition_met(); 304 start_charge_condition_met();
309 break; 305 return;
310 case FCHG_STATE_I2V_CAL_1: 306 case FCHG_STATE_I2V_CAL_1:
311 if (!(msg->data[9] & CHGPRES)) { 307 if (!(msg->data[9] & CHGPRES)) {
312 pwr_ctrl->state = FCHG_STATE_NO_EXT_PWR; 308 pwr_ctrl->state = FCHG_STATE_NO_EXT_PWR;
313 break; 309 return;
314 } 310 }
315 if (pwr_ctrl->config.bciconf) 311 if (pwr_ctrl->config.bciconf)
316 start_i2v_cal(); 312 start_i2v_cal();
317 else { 313 else {
318 pwr_ctrl->i2v_offset = 0; 314 pwr_ctrl->i2v_offset = 0;
319 start_ci_charging(); 315 start_ci_charging();
320 } 316 }
321 break; 317 return;
322 case FCHG_STATE_I2V_CAL_2: 318 case FCHG_STATE_I2V_CAL_2:
323 pwr_ctrl->i2v_offset = msg->data[2]; 319 pwr_ctrl->i2v_offset = msg->data[2];
324 ABB_Write_Register_on_page(PAGE0, BCICTL2, 0); 320 ABB_Write_Register_on_page(PAGE0, BCICTL2, 0);
325 rvf_send_trace("i2v offset (MADC code) ", 23, 321 rvf_send_trace("i2v offset (MADC code) ", 23,
326 pwr_ctrl->i2v_offset, 322 pwr_ctrl->i2v_offset,
327 RV_TRACE_LEVEL_DEBUG_LOW, FCHG_USE_ID); 323 RV_TRACE_LEVEL_DEBUG_LOW, FCHG_USE_ID);
328 if (!(msg->data[9] & CHGPRES)) { 324 if (!(msg->data[9] & CHGPRES)) {
329 pwr_ctrl->state = FCHG_STATE_NO_EXT_PWR; 325 pwr_ctrl->state = FCHG_STATE_NO_EXT_PWR;
330 pwr_init_discharge(); 326 pwr_init_discharge();
331 break; 327 return;
332 } 328 }
333 start_ci_charging(); 329 start_ci_charging();
334 break; 330 return;
335 case FCHG_STATE_CI_CHARGING: 331 case FCHG_STATE_CI_CHARGING:
336 ci_progress_trace(msg->data[2]); 332 ci_progress_trace(msg->data[2]);
337 if (!(msg->data[9] & CHGPRES)) { 333 if (!(msg->data[9] & CHGPRES)) {
338 ABB_Write_Register_on_page(PAGE0, BCICTL2, 0); 334 ABB_Write_Register_on_page(PAGE0, BCICTL2, 0);
339 pwr_ctrl->state = FCHG_STATE_NO_EXT_PWR; 335 pwr_ctrl->state = FCHG_STATE_NO_EXT_PWR;
340 pwr_init_discharge(); 336 pwr_init_discharge();
341 break; 337 return;
342 } 338 }
343 if (charging_time_limit_check()) 339 if (charging_time_limit_check())
344 break; 340 return;
345 if (pwr_ctrl->batt_mv >= pwr_ctrl->config.ci2cv_thresh) 341 if (pwr_ctrl->batt_mv >= pwr_ctrl->config.ci2cv_thresh)
346 start_cv_charging(); 342 start_cv_charging();
347 break; 343 return;
348 case FCHG_STATE_CV_CHARGING: 344 case FCHG_STATE_CV_CHARGING:
349 if (!(msg->data[9] & CHGPRES)) { 345 if (!(msg->data[9] & CHGPRES)) {
350 ABB_Write_Register_on_page(PAGE0, BCICTL2, 0); 346 ABB_Write_Register_on_page(PAGE0, BCICTL2, 0);
351 pwr_ctrl->state = FCHG_STATE_NO_EXT_PWR; 347 pwr_ctrl->state = FCHG_STATE_NO_EXT_PWR;
352 pwr_init_discharge(); 348 pwr_init_discharge();
353 break; 349 return;
354 } 350 }
355 if (cv_ichg_process(msg->data[2])) 351 if (cv_ichg_process(msg->data[2]))
356 break; 352 return;
357 if (overvoltage_end_charge_check()) 353 if (overvoltage_end_charge_check())
358 break; 354 return;
359 if (charging_time_limit_check()) 355 if (charging_time_limit_check())
360 break; 356 return;
361 cv_ctrl_loop_high_check(); 357 cv_ctrl_loop_high_check();
362 cv_ctrl_loop_low_check(); 358 cv_ctrl_loop_low_check();
363 break; 359 return;
364 case FCHG_STATE_RECHARGE_TIMER: 360 case FCHG_STATE_RECHARGE_TIMER:
365 handle_discharge(); 361 handle_discharge();
366 if ((rvf_get_tick_count() - pwr_ctrl->start_time) < 362 if ((rvf_get_tick_count() - pwr_ctrl->start_time) <
367 RVF_SECS_TO_TICKS(pwr_ctrl->config.recharge_delay)) 363 RVF_SECS_TO_TICKS(pwr_ctrl->config.recharge_delay))
368 break; 364 return;
369 rvf_send_trace("Restart time met, allowing new charging", 39, 365 rvf_send_trace("Restart time met, allowing new charging", 39,
370 NULL_PARAM, RV_TRACE_LEVEL_DEBUG_HIGH, 366 NULL_PARAM, RV_TRACE_LEVEL_DEBUG_HIGH,
371 FCHG_USE_ID); 367 FCHG_USE_ID);
372 pwr_ctrl->state = FCHG_STATE_READY_TO_RECHARGE; 368 pwr_ctrl->state = FCHG_STATE_READY_TO_RECHARGE;
373 break; 369 return;
374 default: 370 default:
375 rvf_send_trace("Invalid state in pwr_process_adc()", 32, 371 rvf_send_trace("Invalid state in pwr_process_adc()", 34,
376 pwr_ctrl->state, RV_TRACE_LEVEL_ERROR, 372 pwr_ctrl->state, RV_TRACE_LEVEL_ERROR,
377 FCHG_USE_ID); 373 FCHG_USE_ID);
378 } 374 }
375 }
376
377 static void process_adc_bsim(struct pwr_adc_ind_s *msg)
378 {
379 switch (pwr_ctrl->state) {
380 case FCHG_STATE_READY_TO_CHARGE:
381 if (!pwr_ctrl->bsim.start_enable)
382 return;
383 rvf_send_trace("BSIM: simulated charging auto-start", 35,
384 NULL_PARAM, RV_TRACE_LEVEL_DEBUG_MEDIUM,
385 FCHG_USE_ID);
386 pwr_ctrl->state = FCHG_STATE_I2V_CAL_1;
387 return;
388 case FCHG_STATE_I2V_CAL_1:
389 rvf_send_trace("BSIM: advancing from I2V_CAL_1 to I2V_CAL_2",
390 43, NULL_PARAM, RV_TRACE_LEVEL_DEBUG_LOW,
391 FCHG_USE_ID);
392 pwr_ctrl->state = FCHG_STATE_I2V_CAL_2;
393 return;
394 case FCHG_STATE_I2V_CAL_2:
395 rvf_send_trace("BSIM: advancing from I2V_CAL_2 to CI charging",
396 45, NULL_PARAM, RV_TRACE_LEVEL_DEBUG_LOW,
397 FCHG_USE_ID);
398 pwr_ctrl->state = FCHG_STATE_CI_CHARGING;
399 return;
400 default:
401 /* remaining states require no action in BSIM */
402 return;
403 }
404 }
405
406 void pwr_process_adc(struct pwr_adc_ind_s *msg)
407 {
408 pwr_ctrl->batt_mv = madc_vbat_2_physical(msg->data[0]);
409 if (!fchg_first_vbat)
410 capture_first_vbat();
411 if (pwr_ctrl->bsim_mode)
412 process_adc_bsim(msg);
413 else
414 process_adc_regular(msg);
379 } 415 }
380 416
381 void pwr_handle_timer(void) 417 void pwr_handle_timer(void)
382 { 418 {
383 if (pwr_ctrl->state != FCHG_STATE_PWR_PLUG_TIMER) 419 if (pwr_ctrl->state != FCHG_STATE_PWR_PLUG_TIMER)
391 { 427 {
392 if (pwr_ctrl->state != FCHG_STATE_NO_EXT_PWR) { 428 if (pwr_ctrl->state != FCHG_STATE_NO_EXT_PWR) {
393 rvf_send_trace("Charger plug event in unexpected state", 38, 429 rvf_send_trace("Charger plug event in unexpected state", 38,
394 pwr_ctrl->state, RV_TRACE_LEVEL_ERROR, 430 pwr_ctrl->state, RV_TRACE_LEVEL_ERROR,
395 FCHG_USE_ID); 431 FCHG_USE_ID);
432 return;
433 }
434 if (pwr_ctrl->bsim_mode) {
435 rvf_send_trace("Charger plug in BSIM mode", 25, NULL_PARAM,
436 RV_TRACE_LEVEL_DEBUG_HIGH, FCHG_USE_ID);
437 pwr_ctrl->state = FCHG_STATE_READY_TO_CHARGE;
438 if (pwr_ctrl->event_handler)
439 pwr_ctrl->event_handler(FCHG_EVENT_CHARGER_PLUG);
396 return; 440 return;
397 } 441 }
398 if (!pwr_ctrl->config_present) { 442 if (!pwr_ctrl->config_present) {
399 rvf_send_trace( 443 rvf_send_trace(
400 "Charger plugged in, but no config: won't charge", 47, 444 "Charger plugged in, but no config: won't charge", 47,
446 FCHG_USE_ID); 490 FCHG_USE_ID);
447 pwr_ctrl->state = FCHG_STATE_NO_EXT_PWR; 491 pwr_ctrl->state = FCHG_STATE_NO_EXT_PWR;
448 pwr_init_discharge(); 492 pwr_init_discharge();
449 break; 493 break;
450 default: 494 default:
451 rvf_send_trace("Invalid state in pwr_charger_unplug()", 35, 495 rvf_send_trace("Invalid state in pwr_charger_unplug()", 37,
452 pwr_ctrl->state, RV_TRACE_LEVEL_ERROR, 496 pwr_ctrl->state, RV_TRACE_LEVEL_ERROR,
453 FCHG_USE_ID); 497 FCHG_USE_ID);
454 } 498 }
455 if (pwr_ctrl->event_handler) 499 if (pwr_ctrl->event_handler)
456 pwr_ctrl->event_handler(FCHG_EVENT_CHARGER_UNPLUG); 500 pwr_ctrl->event_handler(FCHG_EVENT_CHARGER_UNPLUG);
462 case FCHG_STATE_NO_EXT_PWR: 506 case FCHG_STATE_NO_EXT_PWR:
463 rvf_send_trace("Cannot charge without a power source", 36, 507 rvf_send_trace("Cannot charge without a power source", 36,
464 NULL_PARAM, RV_TRACE_LEVEL_ERROR, FCHG_USE_ID); 508 NULL_PARAM, RV_TRACE_LEVEL_ERROR, FCHG_USE_ID);
465 return; 509 return;
466 case FCHG_STATE_NO_CHARGING: 510 case FCHG_STATE_NO_CHARGING:
467 if (!pwr_ctrl->config_present) { 511 if (!pwr_ctrl->config_present && !pwr_ctrl->bsim_mode) {
468 rvf_send_trace("No config set, cannot charge", 28, 512 rvf_send_trace("No config set, cannot charge", 28,
469 NULL_PARAM, RV_TRACE_LEVEL_ERROR, 513 NULL_PARAM, RV_TRACE_LEVEL_ERROR,
470 FCHG_USE_ID); 514 FCHG_USE_ID);
471 return; 515 return;
472 } 516 }
487 rvf_send_trace( 531 rvf_send_trace(
488 "Charging already in progress, start request ignored", 532 "Charging already in progress, start request ignored",
489 51, NULL_PARAM, RV_TRACE_LEVEL_WARNING, FCHG_USE_ID); 533 51, NULL_PARAM, RV_TRACE_LEVEL_WARNING, FCHG_USE_ID);
490 return; 534 return;
491 default: 535 default:
492 rvf_send_trace("Invalid state in pwr_charge_start_req()", 37, 536 rvf_send_trace("Invalid state in pwr_charge_start_req()", 39,
493 pwr_ctrl->state, RV_TRACE_LEVEL_ERROR, 537 pwr_ctrl->state, RV_TRACE_LEVEL_ERROR,
494 FCHG_USE_ID); 538 FCHG_USE_ID);
495 } 539 }
496 } 540 }
497 541
523 pwr_init_discharge(); 567 pwr_init_discharge();
524 if (pwr_ctrl->event_handler) 568 if (pwr_ctrl->event_handler)
525 pwr_ctrl->event_handler(FCHG_EVENT_CHARGING_STOPPED); 569 pwr_ctrl->event_handler(FCHG_EVENT_CHARGING_STOPPED);
526 return; 570 return;
527 default: 571 default:
528 rvf_send_trace("Invalid state in pwr_charge_stop_req()", 36, 572 rvf_send_trace("Invalid state in pwr_charge_stop_req()", 38,
529 pwr_ctrl->state, RV_TRACE_LEVEL_ERROR, 573 pwr_ctrl->state, RV_TRACE_LEVEL_ERROR,
530 FCHG_USE_ID); 574 FCHG_USE_ID);
531 } 575 }
532 } 576 }