2067 lines
65 KiB
C++
2067 lines
65 KiB
C++
/*
|
|
; Project: Open Vehicle Monitor System
|
|
; Date: 14th March 2017
|
|
;
|
|
; Changes:
|
|
; 1.0 Initial release
|
|
;
|
|
; (C) 2011 Michael Stegen / Stegen Electronics
|
|
; (C) 2011-2017 Mark Webb-Johnson
|
|
; (C) 2011 Sonny Chen @ EPRO/DX
|
|
;
|
|
; Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
; of this software and associated documentation files (the "Software"), to deal
|
|
; in the Software without restriction, including without limitation the rights
|
|
; to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
; copies of the Software, and to permit persons to whom the Software is
|
|
; furnished to do so, subject to the following conditions:
|
|
;
|
|
; The above copyright notice and this permission notice shall be included in
|
|
; all copies or substantial portions of the Software.
|
|
;
|
|
; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
; IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
; FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
; AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
; LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
; THE SOFTWARE.
|
|
*/
|
|
|
|
#include "ovms_log.h"
|
|
static const char *TAG = "vehicle";
|
|
|
|
#include <stdio.h>
|
|
#include <algorithm>
|
|
#include <iostream>
|
|
#include <sstream>
|
|
#include <iomanip>
|
|
#include <ovms_command.h>
|
|
#include <ovms_script.h>
|
|
#include <ovms_metrics.h>
|
|
#include <ovms_notify.h>
|
|
#include <metrics_standard.h>
|
|
#ifdef CONFIG_OVMS_COMP_WEBSERVER
|
|
#include <ovms_webserver.h>
|
|
#endif // #ifdef CONFIG_OVMS_COMP_WEBSERVER
|
|
#include <ovms_peripherals.h>
|
|
#include <string_writer.h>
|
|
#include "vehicle.h"
|
|
|
|
|
|
OvmsVehicleFactory MyVehicleFactory __attribute__ ((init_priority (2000)));
|
|
|
|
|
|
OvmsVehicleFactory::OvmsVehicleFactory()
|
|
{
|
|
ESP_LOGI(TAG, "Initialising VEHICLE Factory (2000)");
|
|
|
|
m_currentvehicle = NULL;
|
|
m_currentvehicletype.clear();
|
|
|
|
OvmsCommand* cmd_vehicle = MyCommandApp.RegisterCommand("vehicle","Vehicle framework", vehicle_status, "", 0, 0, false);
|
|
cmd_vehicle->RegisterCommand("module","Set (or clear) vehicle module",vehicle_module,"<type>",0,1,true,vehicle_validate);
|
|
cmd_vehicle->RegisterCommand("list","Show list of available vehicle modules",vehicle_list);
|
|
cmd_vehicle->RegisterCommand("status","Show vehicle module status",vehicle_status);
|
|
|
|
MyCommandApp.RegisterCommand("wakeup","Wake up vehicle",vehicle_wakeup);
|
|
MyCommandApp.RegisterCommand("homelink","Activate specified homelink button",vehicle_homelink,"<homelink> [<duration=1000ms>]",1,2);
|
|
OvmsCommand* cmd_climate = MyCommandApp.RegisterCommand("climatecontrol","(De)Activate Climate Control");
|
|
cmd_climate->RegisterCommand("on","Activate Climate Control",vehicle_climatecontrol_on);
|
|
cmd_climate->RegisterCommand("off","Deactivate Climate Control",vehicle_climatecontrol_off);
|
|
MyCommandApp.RegisterCommand("lock","Lock vehicle",vehicle_lock,"<pin>",1,1);
|
|
MyCommandApp.RegisterCommand("unlock","Unlock vehicle",vehicle_unlock,"<pin>",1,1);
|
|
MyCommandApp.RegisterCommand("valet","Activate valet mode",vehicle_valet,"<pin>",1,1);
|
|
MyCommandApp.RegisterCommand("unvalet","Deactivate valet mode",vehicle_unvalet,"<pin>",1,1);
|
|
|
|
OvmsCommand* cmd_charge = MyCommandApp.RegisterCommand("charge","Charging framework");
|
|
OvmsCommand* cmd_chargemode = cmd_charge->RegisterCommand("mode","Set vehicle charge mode");
|
|
cmd_chargemode->RegisterCommand("standard","Set vehicle standard charge mode",vehicle_charge_mode);
|
|
cmd_chargemode->RegisterCommand("storage","Set vehicle standard charge mode",vehicle_charge_mode);
|
|
cmd_chargemode->RegisterCommand("range","Set vehicle standard charge mode",vehicle_charge_mode);
|
|
cmd_chargemode->RegisterCommand("performance","Set vehicle standard charge mode",vehicle_charge_mode);
|
|
cmd_charge->RegisterCommand("start","Start a vehicle charge",vehicle_charge_start);
|
|
cmd_charge->RegisterCommand("stop","Stop a vehicle charge",vehicle_charge_stop);
|
|
cmd_charge->RegisterCommand("current","Limit charge current",vehicle_charge_current,"<amps>",1,1);
|
|
cmd_charge->RegisterCommand("cooldown","Start a vehicle cooldown",vehicle_charge_cooldown);
|
|
|
|
OvmsCommand* cmd_stat = MyCommandApp.RegisterCommand("stat","Show vehicle status",vehicle_stat);
|
|
cmd_stat->RegisterCommand("trip","Show trip status",vehicle_stat_trip);
|
|
|
|
OvmsCommand* cmd_bms = MyCommandApp.RegisterCommand("bms","BMS framework", bms_status, "", 0, 0, false);
|
|
cmd_bms->RegisterCommand("status","Show BMS status",bms_status);
|
|
cmd_bms->RegisterCommand("temp","Show BMS temperature status",bms_status);
|
|
cmd_bms->RegisterCommand("volt","Show BMS voltage status",bms_status);
|
|
cmd_bms->RegisterCommand("reset","Reset BMS statistics",bms_reset);
|
|
cmd_bms->RegisterCommand("alerts","Show BMS alerts",bms_alerts);
|
|
|
|
OvmsCommand* cmd_obdii = MyCommandApp.RegisterCommand("obdii", "OBDII framework");
|
|
for (int k=1; k <= 4; k++)
|
|
{
|
|
static const char* name[4] = { "can1", "can2", "can3", "can4" };
|
|
OvmsCommand* cmd_canx = cmd_obdii->RegisterCommand(name[k-1], "select bus");
|
|
|
|
OvmsCommand* cmd_obdreq = cmd_canx->RegisterCommand(
|
|
"request", "Send OBD2/UDS request, output response");
|
|
cmd_obdreq->RegisterCommand(
|
|
"device", "Send OBD2/ISOTP request to a device", obdii_request,
|
|
"[-e|-E|-v] [-t<timeout_ms>] <txid> <rxid> <request>\n"
|
|
"Give <txid> and <rxid> as hexadecimal CAN IDs,"
|
|
" add -e to use ISO-TP extended addressing (19 bit IDs via standard frames)\n"
|
|
" or -E to use ISO-TP via extended frames (29 bit IDs)\n"
|
|
" or -v to use VW-TP 2.0 (VW/VAG specific transport protocol, txid=200, rxid=ECUID).\n"
|
|
"<request> is the hex string of the request type + arguments,"
|
|
" e.g. '223a4b' = read data from PID 0x3a4b.\n"
|
|
"Default timeout is 3000 ms.",
|
|
3, 5);
|
|
cmd_obdreq->RegisterCommand(
|
|
"broadcast", "Send OBD2/UDS request as broadcast", obdii_request,
|
|
"[-t<timeout_ms>] <request>\n"
|
|
"Sends the request to broadcast ID 7df, listens on IDs 7e8-7ef.\n"
|
|
"Note: only the first response will be shown, enable CAN log to check for more.\n"
|
|
"<request> is the hex string of the request type + arguments,"
|
|
" e.g. '223a4b' = read data from PID 0x3a4b.\n"
|
|
"Default timeout is 3000 ms.",
|
|
1, 2);
|
|
}
|
|
|
|
#ifdef CONFIG_OVMS_SC_JAVASCRIPT_DUKTAPE
|
|
DuktapeObjectRegistration* dto = new DuktapeObjectRegistration("OvmsVehicle");
|
|
dto->RegisterDuktapeFunction(DukOvmsVehicleType, 0, "Type");
|
|
dto->RegisterDuktapeFunction(DukOvmsVehicleWakeup, 0, "Wakeup");
|
|
dto->RegisterDuktapeFunction(DukOvmsVehicleHomelink, 2, "Homelink");
|
|
dto->RegisterDuktapeFunction(DukOvmsVehicleClimateControl, 1, "ClimateControl");
|
|
dto->RegisterDuktapeFunction(DukOvmsVehicleLock, 1, "Lock");
|
|
dto->RegisterDuktapeFunction(DukOvmsVehicleUnlock, 1, "Unlock");
|
|
dto->RegisterDuktapeFunction(DukOvmsVehicleValet, 1, "Valet");
|
|
dto->RegisterDuktapeFunction(DukOvmsVehicleUnvalet, 1, "Unvalet");
|
|
dto->RegisterDuktapeFunction(DukOvmsVehicleSetChargeMode, 1, "SetChargeMode");
|
|
dto->RegisterDuktapeFunction(DukOvmsVehicleSetChargeCurrent, 1, "SetChargeCurrent");
|
|
dto->RegisterDuktapeFunction(DukOvmsVehicleSetChargeTimer, 2, "SetChargeTimer");
|
|
dto->RegisterDuktapeFunction(DukOvmsVehicleStopCharge, 0, "StopCharge");
|
|
dto->RegisterDuktapeFunction(DukOvmsVehicleStartCharge, 0, "StartCharge");
|
|
dto->RegisterDuktapeFunction(DukOvmsVehicleStartCooldown, 0, "StartCooldown");
|
|
dto->RegisterDuktapeFunction(DukOvmsVehicleStopCooldown, 0, "StopCooldown");
|
|
dto->RegisterDuktapeFunction(DukOvmsVehicleObdRequest, 1, "ObdRequest");
|
|
MyDuktape.RegisterDuktapeObject(dto);
|
|
#endif // #ifdef CONFIG_OVMS_SC_JAVASCRIPT_DUKTAPE
|
|
}
|
|
|
|
OvmsVehicleFactory::~OvmsVehicleFactory()
|
|
{
|
|
if (m_currentvehicle)
|
|
{
|
|
m_currentvehicle->m_ready = false;
|
|
delete m_currentvehicle;
|
|
m_currentvehicle = NULL;
|
|
m_currentvehicletype.clear();
|
|
}
|
|
}
|
|
|
|
OvmsVehicle* OvmsVehicleFactory::NewVehicle(const char* VehicleType)
|
|
{
|
|
OvmsVehicleFactory::map_vehicle_t::iterator iter = m_vmap.find(VehicleType);
|
|
if (iter != m_vmap.end())
|
|
{
|
|
return iter->second.construct();
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
void OvmsVehicleFactory::ClearVehicle()
|
|
{
|
|
if (m_currentvehicle)
|
|
{
|
|
m_currentvehicle->m_ready = false;
|
|
delete m_currentvehicle;
|
|
m_currentvehicle = NULL;
|
|
m_currentvehicletype.clear();
|
|
StandardMetrics.ms_v_type->SetValue("");
|
|
MyEvents.SignalEvent("vehicle.type.cleared", NULL);
|
|
}
|
|
}
|
|
|
|
void OvmsVehicleFactory::SetVehicle(const char* type)
|
|
{
|
|
if (m_currentvehicle)
|
|
{
|
|
m_currentvehicle->m_ready = false;
|
|
delete m_currentvehicle;
|
|
m_currentvehicle = NULL;
|
|
m_currentvehicletype.clear();
|
|
MyEvents.SignalEvent("vehicle.type.cleared", NULL);
|
|
}
|
|
m_currentvehicle = NewVehicle(type);
|
|
if (m_currentvehicle)
|
|
{
|
|
m_currentvehicle->m_ready = true;
|
|
}
|
|
m_currentvehicletype = std::string(type);
|
|
StandardMetrics.ms_v_type->SetValue(m_currentvehicle ? type : "");
|
|
MyEvents.SignalEvent("vehicle.type.set", (void*)type, strlen(type)+1);
|
|
}
|
|
|
|
void OvmsVehicleFactory::AutoInit()
|
|
{
|
|
std::string type = MyConfig.GetParamValue("auto", "vehicle.type");
|
|
if (!type.empty())
|
|
SetVehicle(type.c_str());
|
|
}
|
|
|
|
OvmsVehicle* OvmsVehicleFactory::ActiveVehicle()
|
|
{
|
|
return m_currentvehicle;
|
|
}
|
|
|
|
const char* OvmsVehicleFactory::ActiveVehicleType()
|
|
{
|
|
return m_currentvehicletype.c_str();
|
|
}
|
|
|
|
const char* OvmsVehicleFactory::ActiveVehicleName()
|
|
{
|
|
map_vehicle_t::iterator it = m_vmap.find(m_currentvehicletype.c_str());
|
|
if (it != m_vmap.end())
|
|
return it->second.name;
|
|
return "";
|
|
}
|
|
|
|
const char* OvmsVehicleFactory::ActiveVehicleShortName()
|
|
{
|
|
return m_currentvehicle ? m_currentvehicle->VehicleShortName() : "";
|
|
}
|
|
|
|
static void OvmsVehicleRxTask(void *pvParameters)
|
|
{
|
|
OvmsVehicle *me = (OvmsVehicle*)pvParameters;
|
|
me->RxTask();
|
|
}
|
|
|
|
OvmsVehicle::OvmsVehicle()
|
|
{
|
|
using std::placeholders::_1;
|
|
using std::placeholders::_2;
|
|
|
|
m_can1 = NULL;
|
|
m_can2 = NULL;
|
|
m_can3 = NULL;
|
|
m_can4 = NULL;
|
|
|
|
m_last_chargetime = 0;
|
|
m_last_drivetime = 0;
|
|
m_last_gentime = 0;
|
|
m_last_parktime = 0;
|
|
|
|
m_drive_startsoc = StdMetrics.ms_v_bat_soc->AsFloat();
|
|
m_drive_startrange = StdMetrics.ms_v_bat_range_est->AsFloat();
|
|
m_drive_startaltitude = StdMetrics.ms_v_pos_altitude->AsFloat();
|
|
m_drive_speedcnt = 0;
|
|
m_drive_speedsum = 0;
|
|
m_drive_accelcnt = 0;
|
|
m_drive_accelsum = 0;
|
|
m_drive_decelcnt = 0;
|
|
m_drive_decelsum = 0;
|
|
|
|
m_ticker = 0;
|
|
m_12v_ticker = 0;
|
|
m_chargestate_ticker = 0;
|
|
m_vehicleon_ticker = 0;
|
|
m_vehicleoff_ticker = 0;
|
|
m_idle_ticker = 0;
|
|
m_registeredlistener = false;
|
|
m_autonotifications = true;
|
|
m_ready = false;
|
|
|
|
m_poll_state = 0;
|
|
m_poll_bus = NULL;
|
|
m_poll_bus_default = NULL;
|
|
m_poll_txcallback = std::bind(&OvmsVehicle::PollerTxCallback, this, _1, _2);
|
|
m_poll_plist = NULL;
|
|
m_poll_plcur = NULL;
|
|
m_poll_entry = {};
|
|
m_poll_vwtp = {};
|
|
m_poll_ticker = 0;
|
|
m_poll_single_rxbuf = NULL;
|
|
m_poll_single_rxerr = 0;
|
|
m_poll_moduleid_sent = 0;
|
|
m_poll_moduleid_low = 0;
|
|
m_poll_moduleid_high = 0;
|
|
m_poll_type = 0;
|
|
m_poll_pid = 0;
|
|
m_poll_ml_remain = 0;
|
|
m_poll_ml_offset = 0;
|
|
m_poll_ml_frame = 0;
|
|
m_poll_wait = 0;
|
|
m_poll_sequence_max = 1;
|
|
m_poll_sequence_cnt = 0;
|
|
m_poll_fc_septime = 25; // response default timing: 25 milliseconds
|
|
m_poll_ch_keepalive = 60; // channel keepalive default: 60 seconds
|
|
|
|
m_bms_voltages = NULL;
|
|
m_bms_vmins = NULL;
|
|
m_bms_vmaxs = NULL;
|
|
m_bms_vdevmaxs = NULL;
|
|
m_bms_valerts = NULL;
|
|
m_bms_valerts_new = 0;
|
|
m_bms_vstddev_cnt = 0;
|
|
m_bms_vstddev_avg = 0;
|
|
m_bms_has_voltages = false;
|
|
|
|
m_bms_temperatures = NULL;
|
|
m_bms_tmins = NULL;
|
|
m_bms_tmaxs = NULL;
|
|
m_bms_tdevmaxs = NULL;
|
|
m_bms_talerts = NULL;
|
|
m_bms_talerts_new = 0;
|
|
m_bms_has_temperatures = false;
|
|
|
|
m_bms_bitset_v.clear();
|
|
m_bms_bitset_t.clear();
|
|
m_bms_bitset_cv = 0;
|
|
m_bms_bitset_ct = 0;
|
|
m_bms_readings_v = 0;
|
|
m_bms_readingspermodule_v = 0;
|
|
m_bms_readings_t = 0;
|
|
m_bms_readingspermodule_t = 0;
|
|
|
|
m_bms_limit_tmin = -1000;
|
|
m_bms_limit_tmax = 1000;
|
|
m_bms_limit_vmin = -1000;
|
|
m_bms_limit_vmax = 1000;
|
|
|
|
m_bms_defthr_vmaxgrad = BMS_DEFTHR_VMAXGRAD;
|
|
m_bms_defthr_vmaxsddev = BMS_DEFTHR_VMAXSDDEV;
|
|
m_bms_defthr_vwarn = BMS_DEFTHR_VWARN;
|
|
m_bms_defthr_valert = BMS_DEFTHR_VALERT;
|
|
m_bms_defthr_twarn = BMS_DEFTHR_TWARN;
|
|
m_bms_defthr_talert = BMS_DEFTHR_TALERT;
|
|
|
|
m_bms_vlog_last = 0;
|
|
m_bms_tlog_last = 0;
|
|
|
|
m_minsoc = 0;
|
|
m_minsoc_triggered = 0;
|
|
|
|
m_accel_refspeed = 0;
|
|
m_accel_reftime = 0;
|
|
m_accel_smoothing = 2.0;
|
|
|
|
m_batpwr_smoothing = 2.0;
|
|
m_batpwr_smoothed = 0;
|
|
|
|
m_brakelight_enable = false;
|
|
m_brakelight_on = 1.3;
|
|
m_brakelight_off = 0.7;
|
|
m_brakelight_port = 1;
|
|
m_brakelight_start = 0;
|
|
m_brakelight_basepwr = 0;
|
|
m_brakelight_ignftbrk = false;
|
|
|
|
m_tpms_lastcheck = 0;
|
|
|
|
m_rxqueue = xQueueCreate(CONFIG_OVMS_VEHICLE_CAN_RX_QUEUE_SIZE,sizeof(CAN_frame_t));
|
|
xTaskCreatePinnedToCore(OvmsVehicleRxTask, "OVMS Vehicle",
|
|
CONFIG_OVMS_VEHICLE_RXTASK_STACK, (void*)this, 10, &m_rxtask, CORE(1));
|
|
|
|
MyEvents.RegisterEvent(TAG, "ticker.1", std::bind(&OvmsVehicle::VehicleTicker1, this, _1, _2));
|
|
MyEvents.RegisterEvent(TAG, "config.changed", std::bind(&OvmsVehicle::VehicleConfigChanged, this, _1, _2));
|
|
MyEvents.RegisterEvent(TAG, "config.mounted", std::bind(&OvmsVehicle::VehicleConfigChanged, this, _1, _2));
|
|
VehicleConfigChanged("config.mounted", NULL);
|
|
|
|
MyMetrics.RegisterListener(TAG, "*", std::bind(&OvmsVehicle::MetricModified, this, _1));
|
|
}
|
|
|
|
OvmsVehicle::~OvmsVehicle()
|
|
{
|
|
if (m_can1) m_can1->SetPowerMode(Off);
|
|
if (m_can2) m_can2->SetPowerMode(Off);
|
|
if (m_can3) m_can3->SetPowerMode(Off);
|
|
if (m_can4) m_can4->SetPowerMode(Off);
|
|
|
|
if (m_bms_voltages != NULL)
|
|
{
|
|
delete [] m_bms_voltages;
|
|
m_bms_voltages = NULL;
|
|
}
|
|
if (m_bms_vmins != NULL)
|
|
{
|
|
delete [] m_bms_vmins;
|
|
m_bms_vmins = NULL;
|
|
}
|
|
if (m_bms_vmaxs != NULL)
|
|
{
|
|
delete [] m_bms_vmaxs;
|
|
m_bms_vmaxs = NULL;
|
|
}
|
|
if (m_bms_vdevmaxs != NULL)
|
|
{
|
|
delete [] m_bms_vdevmaxs;
|
|
m_bms_vdevmaxs = NULL;
|
|
}
|
|
if (m_bms_valerts != NULL)
|
|
{
|
|
delete [] m_bms_valerts;
|
|
m_bms_valerts = NULL;
|
|
}
|
|
|
|
if (m_bms_temperatures != NULL)
|
|
{
|
|
delete [] m_bms_temperatures;
|
|
m_bms_temperatures = NULL;
|
|
}
|
|
if (m_bms_tmins != NULL)
|
|
{
|
|
delete [] m_bms_tmins;
|
|
m_bms_tmins = NULL;
|
|
}
|
|
if (m_bms_tmaxs != NULL)
|
|
{
|
|
delete [] m_bms_tmaxs;
|
|
m_bms_tmaxs = NULL;
|
|
}
|
|
if (m_bms_tdevmaxs != NULL)
|
|
{
|
|
delete [] m_bms_tdevmaxs;
|
|
m_bms_tdevmaxs = NULL;
|
|
}
|
|
if (m_bms_talerts != NULL)
|
|
{
|
|
delete [] m_bms_talerts;
|
|
m_bms_talerts = NULL;
|
|
}
|
|
|
|
if (m_registeredlistener)
|
|
{
|
|
MyCan.DeregisterListener(m_rxqueue);
|
|
m_registeredlistener = false;
|
|
}
|
|
|
|
vQueueDelete(m_rxqueue);
|
|
vTaskDelete(m_rxtask);
|
|
|
|
MyEvents.DeregisterEvent(TAG);
|
|
MyMetrics.DeregisterListener(TAG);
|
|
}
|
|
|
|
const char* OvmsVehicle::VehicleShortName()
|
|
{
|
|
return MyVehicleFactory.ActiveVehicleName();
|
|
}
|
|
|
|
const char* OvmsVehicle::VehicleType()
|
|
{
|
|
return MyVehicleFactory.ActiveVehicleType();
|
|
}
|
|
|
|
void OvmsVehicle::RxTask()
|
|
{
|
|
CAN_frame_t frame;
|
|
|
|
while(1)
|
|
{
|
|
if (xQueueReceive(m_rxqueue, &frame, (portTickType)portMAX_DELAY)==pdTRUE)
|
|
{
|
|
if (!m_ready)
|
|
continue;
|
|
|
|
// Pass frame to poller protocol handlers:
|
|
if (frame.origin == m_poll_vwtp.bus && frame.MsgID == m_poll_vwtp.rxid)
|
|
{
|
|
PollerVWTPReceive(&frame, frame.MsgID);
|
|
}
|
|
else if (m_poll_wait && frame.origin == m_poll_bus && m_poll_plist)
|
|
{
|
|
uint32_t msgid;
|
|
if (m_poll_protocol == ISOTP_EXTADR)
|
|
msgid = frame.MsgID << 8 | frame.data.u8[0];
|
|
else
|
|
msgid = frame.MsgID;
|
|
if (msgid >= m_poll_moduleid_low && msgid <= m_poll_moduleid_high)
|
|
{
|
|
PollerISOTPReceive(&frame, msgid);
|
|
}
|
|
}
|
|
|
|
// Pass frame to standard handlers:
|
|
if (m_can1 == frame.origin) IncomingFrameCan1(&frame);
|
|
else if (m_can2 == frame.origin) IncomingFrameCan2(&frame);
|
|
else if (m_can3 == frame.origin) IncomingFrameCan3(&frame);
|
|
else if (m_can4 == frame.origin) IncomingFrameCan4(&frame);
|
|
}
|
|
}
|
|
}
|
|
|
|
void OvmsVehicle::IncomingFrameCan1(CAN_frame_t* p_frame)
|
|
{
|
|
}
|
|
|
|
void OvmsVehicle::IncomingFrameCan2(CAN_frame_t* p_frame)
|
|
{
|
|
}
|
|
|
|
void OvmsVehicle::IncomingFrameCan3(CAN_frame_t* p_frame)
|
|
{
|
|
}
|
|
|
|
void OvmsVehicle::IncomingFrameCan4(CAN_frame_t* p_frame)
|
|
{
|
|
}
|
|
|
|
void OvmsVehicle::Status(int verbosity, OvmsWriter* writer)
|
|
{
|
|
writer->printf("Vehicle module '%s' (code %s) loaded and running\n", VehicleShortName(), VehicleType());
|
|
}
|
|
|
|
void OvmsVehicle::RegisterCanBus(int bus, CAN_mode_t mode, CAN_speed_t speed, dbcfile* dbcfile)
|
|
{
|
|
switch (bus)
|
|
{
|
|
case 1:
|
|
m_can1 = (canbus*)MyPcpApp.FindDeviceByName("can1");
|
|
m_can1->SetPowerMode(On);
|
|
m_can1->Start(mode,speed,dbcfile);
|
|
break;
|
|
case 2:
|
|
m_can2 = (canbus*)MyPcpApp.FindDeviceByName("can2");
|
|
m_can2->SetPowerMode(On);
|
|
m_can2->Start(mode,speed,dbcfile);
|
|
break;
|
|
case 3:
|
|
m_can3 = (canbus*)MyPcpApp.FindDeviceByName("can3");
|
|
m_can3->SetPowerMode(On);
|
|
m_can3->Start(mode,speed,dbcfile);
|
|
break;
|
|
case 4:
|
|
m_can4 = (canbus*)MyPcpApp.FindDeviceByName("can4");
|
|
m_can4->SetPowerMode(On);
|
|
m_can4->Start(mode,speed,dbcfile);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (!m_registeredlistener)
|
|
{
|
|
m_registeredlistener = true;
|
|
MyCan.RegisterListener(m_rxqueue);
|
|
}
|
|
}
|
|
|
|
bool OvmsVehicle::PinCheck(char* pin)
|
|
{
|
|
if (!MyConfig.IsDefined("password","pin")) return false;
|
|
|
|
std::string vpin = MyConfig.GetParamValue("password","pin");
|
|
return (strcmp(vpin.c_str(),pin)==0);
|
|
}
|
|
|
|
void OvmsVehicle::VehicleTicker1(std::string event, void* data)
|
|
{
|
|
if (!m_ready)
|
|
return;
|
|
|
|
m_ticker++;
|
|
|
|
PollerStateTicker();
|
|
PollerSend(true);
|
|
|
|
Ticker1(m_ticker);
|
|
if ((m_ticker % 10) == 0) Ticker10(m_ticker);
|
|
if ((m_ticker % 60) == 0) Ticker60(m_ticker);
|
|
if ((m_ticker % 300) == 0) Ticker300(m_ticker);
|
|
if ((m_ticker % 600) == 0) Ticker600(m_ticker);
|
|
if ((m_ticker % 3600) == 0) Ticker3600(m_ticker);
|
|
|
|
if (StandardMetrics.ms_v_env_on->AsBool())
|
|
{
|
|
StandardMetrics.ms_v_env_parktime->SetValue(0);
|
|
m_last_drivetime = StandardMetrics.ms_v_env_drivetime->AsInt() + 1;
|
|
StandardMetrics.ms_v_env_drivetime->SetValue(m_last_drivetime);
|
|
}
|
|
else
|
|
{
|
|
StandardMetrics.ms_v_env_drivetime->SetValue(0);
|
|
m_last_parktime = StandardMetrics.ms_v_env_parktime->AsInt() + 1;
|
|
StandardMetrics.ms_v_env_parktime->SetValue(m_last_parktime);
|
|
}
|
|
|
|
if (StandardMetrics.ms_v_charge_inprogress->AsBool())
|
|
{
|
|
m_last_chargetime = StandardMetrics.ms_v_charge_time->AsInt() + 1;
|
|
StandardMetrics.ms_v_charge_time->SetValue(m_last_chargetime);
|
|
}
|
|
else
|
|
{
|
|
StandardMetrics.ms_v_charge_time->SetValue(0);
|
|
}
|
|
|
|
if (StandardMetrics.ms_v_gen_inprogress->AsBool())
|
|
{
|
|
m_last_gentime = StandardMetrics.ms_v_gen_time->AsInt() + 1;
|
|
StandardMetrics.ms_v_gen_time->SetValue(m_last_gentime);
|
|
}
|
|
else
|
|
{
|
|
StandardMetrics.ms_v_gen_time->SetValue(0);
|
|
}
|
|
|
|
if (m_chargestate_ticker > 0 && --m_chargestate_ticker == 0)
|
|
NotifyChargeState();
|
|
if (m_vehicleon_ticker > 0 && --m_vehicleon_ticker == 0)
|
|
NotifyVehicleOn();
|
|
if (m_vehicleoff_ticker > 0 && --m_vehicleoff_ticker == 0)
|
|
NotifyVehicleOff();
|
|
|
|
CalculateEfficiency();
|
|
|
|
// 12V battery monitor:
|
|
if (StandardMetrics.ms_v_env_charging12v->AsBool() == true)
|
|
{
|
|
// add two seconds calmdown per second charging, max 15 minutes:
|
|
if (m_12v_ticker < 15*60)
|
|
m_12v_ticker += 2;
|
|
}
|
|
else if (m_12v_ticker > 0)
|
|
{
|
|
--m_12v_ticker;
|
|
if (m_12v_ticker == 0)
|
|
{
|
|
// take 12V reference voltage:
|
|
StandardMetrics.ms_v_bat_12v_voltage_ref->SetValue(StandardMetrics.ms_v_bat_12v_voltage->AsFloat());
|
|
}
|
|
}
|
|
|
|
if ((m_ticker % 60) == 0)
|
|
{
|
|
// check 12V voltage:
|
|
float volt = StandardMetrics.ms_v_bat_12v_voltage->AsFloat();
|
|
// …against the maximum of default and measured reference voltage, so alerts will also
|
|
// be triggered if the measured ref follows a degrading battery:
|
|
float dref = MyConfig.GetParamValueFloat("vehicle", "12v.ref", 12.6);
|
|
float vref = MAX(StandardMetrics.ms_v_bat_12v_voltage_ref->AsFloat(), dref);
|
|
bool alert_on = StandardMetrics.ms_v_bat_12v_voltage_alert->AsBool();
|
|
float alert_threshold = MyConfig.GetParamValueFloat("vehicle", "12v.alert", 1.6);
|
|
if (!alert_on && volt > 0 && vref > 0 && vref-volt > alert_threshold)
|
|
{
|
|
StandardMetrics.ms_v_bat_12v_voltage_alert->SetValue(true);
|
|
MyEvents.SignalEvent("vehicle.alert.12v.on", NULL);
|
|
if (m_autonotifications) Notify12vCritical();
|
|
}
|
|
else if (alert_on && volt > 0 && vref > 0 && vref-volt < alert_threshold*0.6)
|
|
{
|
|
StandardMetrics.ms_v_bat_12v_voltage_alert->SetValue(false);
|
|
MyEvents.SignalEvent("vehicle.alert.12v.off", NULL);
|
|
if (m_autonotifications) Notify12vRecovered();
|
|
}
|
|
}
|
|
|
|
if ((m_ticker % 10)==0)
|
|
{
|
|
// Check MINSOC
|
|
int soc = (int) ceil(StandardMetrics.ms_v_bat_soc->AsFloat());
|
|
m_minsoc = MyConfig.GetParamValueInt("vehicle", "minsoc", 0);
|
|
if (m_minsoc <= 0)
|
|
{
|
|
m_minsoc_triggered = 0;
|
|
}
|
|
else if (soc >= m_minsoc+2)
|
|
{
|
|
m_minsoc_triggered = m_minsoc;
|
|
}
|
|
if ((m_minsoc_triggered > 0) && (soc <= m_minsoc_triggered))
|
|
{
|
|
// We have reached the minimum SOC level
|
|
if (m_autonotifications) NotifyMinSocCritical();
|
|
if (soc > 1)
|
|
m_minsoc_triggered = soc - 1;
|
|
else
|
|
m_minsoc_triggered = 0;
|
|
}
|
|
}
|
|
|
|
// BMS ticker:
|
|
BmsTicker();
|
|
|
|
// TPMS alerts:
|
|
if (StdMetrics.ms_v_tpms_alert->LastModified() > m_tpms_lastcheck)
|
|
{
|
|
m_tpms_lastcheck = StdMetrics.ms_v_tpms_alert->LastModified();
|
|
auto tpms_state = StdMetrics.ms_v_tpms_alert->AsVector();
|
|
m_tpms_laststate.resize(tpms_state.size());
|
|
bool notify = false;
|
|
for (int i = 0; i < tpms_state.size(); i++)
|
|
{
|
|
if (tpms_state[i] > m_tpms_laststate[i])
|
|
notify = true;
|
|
m_tpms_laststate[i] = tpms_state[i];
|
|
}
|
|
if (notify)
|
|
{
|
|
MyEvents.SignalEvent("vehicle.alert.tpms", NULL);
|
|
if (m_autonotifications && MyConfig.GetParamValueBool("vehicle", "tpms.alerts.enabled", true))
|
|
NotifyTpmsAlerts();
|
|
}
|
|
}
|
|
|
|
// Idle alert:
|
|
if (!StdMetrics.ms_v_env_awake->AsBool() || StdMetrics.ms_v_pos_speed->AsFloat() > 0)
|
|
{
|
|
m_idle_ticker = 15 * 60; // first alert after 15 minutes
|
|
}
|
|
else if (m_idle_ticker > 0 && --m_idle_ticker == 0)
|
|
{
|
|
NotifyVehicleIdling();
|
|
m_idle_ticker = 60 * 60; // successive alerts every 60 minutes
|
|
}
|
|
} // VehicleTicker1()
|
|
|
|
void OvmsVehicle::Ticker1(uint32_t ticker)
|
|
{
|
|
}
|
|
|
|
void OvmsVehicle::Ticker10(uint32_t ticker)
|
|
{
|
|
}
|
|
|
|
void OvmsVehicle::Ticker60(uint32_t ticker)
|
|
{
|
|
}
|
|
|
|
void OvmsVehicle::Ticker300(uint32_t ticker)
|
|
{
|
|
}
|
|
|
|
void OvmsVehicle::Ticker600(uint32_t ticker)
|
|
{
|
|
}
|
|
|
|
void OvmsVehicle::Ticker3600(uint32_t ticker)
|
|
{
|
|
}
|
|
|
|
void OvmsVehicle::NotifyChargeStart()
|
|
{
|
|
StringWriter buf(200);
|
|
CommandStat(COMMAND_RESULT_NORMAL, &buf);
|
|
MyNotify.NotifyString("info","charge.started",buf.c_str());
|
|
}
|
|
|
|
void OvmsVehicle::NotifyChargeTopOff()
|
|
{
|
|
StringWriter buf(200);
|
|
CommandStat(COMMAND_RESULT_NORMAL, &buf);
|
|
MyNotify.NotifyString("info","charge.toppingoff",buf.c_str());
|
|
}
|
|
|
|
void OvmsVehicle::NotifyHeatingStart()
|
|
{
|
|
StringWriter buf(200);
|
|
CommandStat(COMMAND_RESULT_NORMAL, &buf);
|
|
MyNotify.NotifyString("info","heating.started",buf.c_str());
|
|
}
|
|
|
|
void OvmsVehicle::NotifyChargeStopped()
|
|
{
|
|
StringWriter buf(200);
|
|
CommandStat(COMMAND_RESULT_NORMAL, &buf);
|
|
if (StdMetrics.ms_v_charge_substate->AsString() == "scheduledstop" ||
|
|
StdMetrics.ms_v_charge_substate->AsString() == "timerwait" ||
|
|
StdMetrics.ms_v_charge_substate->AsString() == "onrequest")
|
|
MyNotify.NotifyString("info","charge.stopped",buf.c_str());
|
|
else
|
|
MyNotify.NotifyString("alert","charge.stopped",buf.c_str());
|
|
}
|
|
|
|
void OvmsVehicle::NotifyChargeDone()
|
|
{
|
|
StringWriter buf(200);
|
|
CommandStat(COMMAND_RESULT_NORMAL, &buf);
|
|
MyNotify.NotifyString("info","charge.done",buf.c_str());
|
|
}
|
|
|
|
void OvmsVehicle::NotifyValetEnabled()
|
|
{
|
|
MyNotify.NotifyString("info", "valet.enabled", "Valet mode enabled");
|
|
}
|
|
|
|
void OvmsVehicle::NotifyValetDisabled()
|
|
{
|
|
MyNotify.NotifyString("info", "valet.disabled", "Valet mode disabled");
|
|
}
|
|
|
|
void OvmsVehicle::NotifyValetHood()
|
|
{
|
|
MyNotify.NotifyString("alert", "valet.hood", "Vehicle hood opened while in valet mode");
|
|
}
|
|
|
|
void OvmsVehicle::NotifyValetTrunk()
|
|
{
|
|
MyNotify.NotifyString("alert", "valet.trunk", "Vehicle trunk opened while in valet mode");
|
|
}
|
|
|
|
void OvmsVehicle::NotifyAlarmSounding()
|
|
{
|
|
MyNotify.NotifyString("alert", "alarm.sounding", "Vehicle alarm is sounding");
|
|
}
|
|
|
|
void OvmsVehicle::NotifyAlarmStopped()
|
|
{
|
|
MyNotify.NotifyString("alert", "alarm.stopped", "Vehicle alarm has stopped");
|
|
}
|
|
|
|
void OvmsVehicle::Notify12vCritical()
|
|
{
|
|
float volt = StandardMetrics.ms_v_bat_12v_voltage->AsFloat();
|
|
float dref = MyConfig.GetParamValueFloat("vehicle", "12v.ref", 12.6);
|
|
float vref = MAX(StandardMetrics.ms_v_bat_12v_voltage_ref->AsFloat(), dref);
|
|
|
|
MyNotify.NotifyStringf("alert", "batt.12v.alert", "12V Battery critical: %.1fV (ref=%.1fV)", volt, vref);
|
|
}
|
|
|
|
void OvmsVehicle::Notify12vRecovered()
|
|
{
|
|
float volt = StandardMetrics.ms_v_bat_12v_voltage->AsFloat();
|
|
float dref = MyConfig.GetParamValueFloat("vehicle", "12v.ref", 12.6);
|
|
float vref = MAX(StandardMetrics.ms_v_bat_12v_voltage_ref->AsFloat(), dref);
|
|
|
|
MyNotify.NotifyStringf("alert", "batt.12v.recovered", "12V Battery restored: %.1fV (ref=%.1fV)", volt, vref);
|
|
}
|
|
|
|
void OvmsVehicle::NotifyMinSocCritical()
|
|
{
|
|
float soc = StandardMetrics.ms_v_bat_soc->AsFloat();
|
|
|
|
MyNotify.NotifyStringf("alert", "batt.soc.alert", "Battery SOC critical: %.1f%% (alert<=%d%%)", soc, m_minsoc);
|
|
}
|
|
|
|
void OvmsVehicle::NotifyVehicleIdling()
|
|
{
|
|
MyNotify.NotifyString("alert", "vehicle.idle", "Vehicle is idling / stopped turned on");
|
|
}
|
|
|
|
std::vector<std::string> OvmsVehicle::GetTpmsLayout()
|
|
{
|
|
return { "FL", "FR", "RL", "RR" };
|
|
}
|
|
|
|
void OvmsVehicle::NotifyTpmsAlerts()
|
|
{
|
|
int maxlevel = 0;
|
|
for (int i = 0; i < m_tpms_laststate.size(); i++)
|
|
{
|
|
if (m_tpms_laststate[i] > maxlevel)
|
|
maxlevel = m_tpms_laststate[i];
|
|
}
|
|
if (maxlevel == 0)
|
|
return;
|
|
|
|
StringWriter buf(200);
|
|
std::vector<std::string> wheels = GetTpmsLayout();
|
|
const char* alertlevel[] = { "OK", "WARNING", "ALERT" };
|
|
|
|
buf.printf("TPMS %s:\n", maxlevel == 1 ? "INFO" : "ALERT");
|
|
|
|
for (int i = 0; i < m_tpms_laststate.size(); i++)
|
|
{
|
|
if (m_tpms_laststate[i])
|
|
{
|
|
buf.printf("%s wheel %s:", wheels[i].c_str(), alertlevel[m_tpms_laststate[i]]);
|
|
if (StdMetrics.ms_v_tpms_health->IsDefined())
|
|
buf.printf(" Health=%s", StdMetrics.ms_v_tpms_health->ElemAsUnitString(i, "", Native, 0).c_str());
|
|
if (StdMetrics.ms_v_tpms_pressure->IsDefined())
|
|
buf.printf(" Pressure=%s", StdMetrics.ms_v_tpms_pressure->ElemAsUnitString(i, "", Native, 1).c_str());
|
|
if (StdMetrics.ms_v_tpms_temp->IsDefined())
|
|
buf.printf(" Temp=%sC", StdMetrics.ms_v_tpms_temp->ElemAsString(i, "", Native, 1).c_str());
|
|
buf.append("\n");
|
|
}
|
|
}
|
|
|
|
if (maxlevel == 1)
|
|
MyNotify.NotifyString("info", "tpms.warning", buf.c_str());
|
|
else
|
|
MyNotify.NotifyString("alert", "tpms.alert", buf.c_str());
|
|
}
|
|
|
|
// Default efficiency calculation by speed & power per second, average smoothed over 5 seconds.
|
|
// Override if your vehicle provides more detail.
|
|
void OvmsVehicle::CalculateEfficiency()
|
|
{
|
|
float consumption = 0;
|
|
if (StdMetrics.ms_v_pos_speed->AsFloat() >= 5)
|
|
consumption = StdMetrics.ms_v_bat_power->AsFloat(0, Watts) / StdMetrics.ms_v_pos_speed->AsFloat();
|
|
StdMetrics.ms_v_bat_consumption->SetValue(
|
|
TRUNCPREC((StdMetrics.ms_v_bat_consumption->AsFloat() * 4 + consumption) / 5, 1));
|
|
}
|
|
|
|
OvmsVehicle::vehicle_command_t OvmsVehicle::CommandSetChargeMode(vehicle_mode_t mode)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
OvmsVehicle::vehicle_command_t OvmsVehicle::CommandSetChargeCurrent(uint16_t limit)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
OvmsVehicle::vehicle_command_t OvmsVehicle::CommandStartCharge()
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
OvmsVehicle::vehicle_command_t OvmsVehicle::CommandStopCharge()
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
OvmsVehicle::vehicle_command_t OvmsVehicle::CommandSetChargeTimer(bool timeron, uint16_t timerstart)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
OvmsVehicle::vehicle_command_t OvmsVehicle::CommandCooldown(bool cooldownon)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
OvmsVehicle::vehicle_command_t OvmsVehicle::CommandClimateControl(bool climatecontrolon)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
OvmsVehicle::vehicle_command_t OvmsVehicle::CommandWakeup()
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
OvmsVehicle::vehicle_command_t OvmsVehicle::CommandLock(const char* pin)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
OvmsVehicle::vehicle_command_t OvmsVehicle::CommandUnlock(const char* pin)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
OvmsVehicle::vehicle_command_t OvmsVehicle::CommandActivateValet(const char* pin)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
OvmsVehicle::vehicle_command_t OvmsVehicle::CommandDeactivateValet(const char* pin)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
OvmsVehicle::vehicle_command_t OvmsVehicle::CommandHomelink(int button, int durationms)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
#ifdef CONFIG_OVMS_COMP_TPMS
|
|
|
|
bool OvmsVehicle::TPMSRead(std::vector<uint32_t> *tpms)
|
|
{
|
|
ESP_LOGE(TAG, "TPMS tyre IDs not implemented in this vehicle");
|
|
return false;
|
|
}
|
|
|
|
bool OvmsVehicle::TPMSWrite(std::vector<uint32_t> &tpms)
|
|
{
|
|
ESP_LOGE(TAG, "TPMS tyre IDs not implemented in this vehicle");
|
|
return false;
|
|
}
|
|
|
|
#endif // #ifdef CONFIG_OVMS_COMP_TPMS
|
|
|
|
/**
|
|
* CommandStat: default implementation of vehicle status output
|
|
*/
|
|
OvmsVehicle::vehicle_command_t OvmsVehicle::CommandStat(int verbosity, OvmsWriter* writer)
|
|
{
|
|
metric_unit_t rangeUnit = (MyConfig.GetParamValue("vehicle", "units.distance") == "M") ? Miles : Kilometers;
|
|
|
|
bool chargeport_open = StdMetrics.ms_v_door_chargeport->AsBool();
|
|
std::string charge_state = StdMetrics.ms_v_charge_state->AsString();
|
|
if (chargeport_open && charge_state != "")
|
|
{
|
|
std::string charge_mode = StdMetrics.ms_v_charge_mode->AsString();
|
|
bool show_details = !(charge_state == "done" || charge_state == "stopped");
|
|
|
|
// Translate mode codes:
|
|
if (charge_mode == "standard")
|
|
charge_mode = "Standard";
|
|
else if (charge_mode == "storage")
|
|
charge_mode = "Storage";
|
|
else if (charge_mode == "range")
|
|
charge_mode = "Range";
|
|
else if (charge_mode == "performance")
|
|
charge_mode = "Performance";
|
|
|
|
// Translate state codes:
|
|
if (charge_state == "charging")
|
|
charge_state = "Charging";
|
|
else if (charge_state == "topoff")
|
|
charge_state = "Topping off";
|
|
else if (charge_state == "done")
|
|
charge_state = "Charge Done";
|
|
else if (charge_state == "preparing")
|
|
charge_state = "Preparing";
|
|
else if (charge_state == "heating")
|
|
charge_state = "Charging, Heating";
|
|
else if (charge_state == "stopped")
|
|
charge_state = "Charge Stopped";
|
|
else if (charge_state == "timerwait")
|
|
charge_state = "Charge Stopped, Timer On";
|
|
|
|
if (charge_mode != "")
|
|
writer->printf("%s - ", charge_mode.c_str());
|
|
writer->printf("%s\n", charge_state.c_str());
|
|
|
|
if (show_details)
|
|
{
|
|
// Voltage & current:
|
|
bool show_vc = (StdMetrics.ms_v_charge_voltage->AsFloat() > 0 || StdMetrics.ms_v_charge_current->AsFloat() > 0);
|
|
if (show_vc)
|
|
{
|
|
writer->printf("%s/%s ",
|
|
(char*) StdMetrics.ms_v_charge_voltage->AsUnitString("-", Native, 1).c_str(),
|
|
(char*) StdMetrics.ms_v_charge_current->AsUnitString("-", Native, 1).c_str());
|
|
}
|
|
|
|
// Charge speed:
|
|
if (StdMetrics.ms_v_bat_range_speed->AsFloat() != 0)
|
|
{
|
|
metric_unit_t speedUnit = (rangeUnit == Miles) ? Mph : Kph;
|
|
writer->printf("%s\n", StdMetrics.ms_v_bat_range_speed->AsUnitString("-", speedUnit, 1).c_str());
|
|
}
|
|
else if (show_vc)
|
|
{
|
|
writer->puts("");
|
|
}
|
|
|
|
// Estimated time(s) remaining:
|
|
int duration_full = StdMetrics.ms_v_charge_duration_full->AsInt();
|
|
if (duration_full > 0)
|
|
writer->printf("Full: %d:%02dh\n", duration_full / 60, duration_full % 60);
|
|
|
|
int duration_soc = StdMetrics.ms_v_charge_duration_soc->AsInt();
|
|
if (duration_soc > 0)
|
|
writer->printf("%s: %d:%02dh\n",
|
|
(char*) StdMetrics.ms_v_charge_limit_soc->AsUnitString("SOC", Native, 0).c_str(),
|
|
duration_soc / 60, duration_soc % 60);
|
|
|
|
int duration_range = StdMetrics.ms_v_charge_duration_range->AsInt();
|
|
if (duration_range > 0)
|
|
writer->printf("%s: %d:%02dh\n",
|
|
(char*) StdMetrics.ms_v_charge_limit_range->AsUnitString("Range", rangeUnit, 0).c_str(),
|
|
duration_range / 60, duration_range % 60);
|
|
}
|
|
|
|
// Energy sums:
|
|
if (StdMetrics.ms_v_charge_kwh_grid->IsDefined())
|
|
{
|
|
writer->printf("Drawn: %s\n",
|
|
StdMetrics.ms_v_charge_kwh_grid->AsUnitString("-", Native, 1).c_str());
|
|
}
|
|
if (StdMetrics.ms_v_charge_kwh->IsDefined())
|
|
{
|
|
writer->printf("Charged: %s\n",
|
|
StdMetrics.ms_v_charge_kwh->AsUnitString("-", Native, 1).c_str());
|
|
}
|
|
}
|
|
else
|
|
{
|
|
writer->puts("Not charging");
|
|
}
|
|
|
|
writer->printf("SOC: %s\n", (char*) StdMetrics.ms_v_bat_soc->AsUnitString("-", Native, 1).c_str());
|
|
|
|
if (StdMetrics.ms_v_bat_range_ideal->IsDefined())
|
|
{
|
|
const std::string& range_ideal = StdMetrics.ms_v_bat_range_ideal->AsUnitString("-", rangeUnit, 0);
|
|
writer->printf("Ideal range: %s\n", range_ideal.c_str());
|
|
}
|
|
|
|
if (StdMetrics.ms_v_bat_range_est->IsDefined())
|
|
{
|
|
const std::string& range_est = StdMetrics.ms_v_bat_range_est->AsUnitString("-", rangeUnit, 0);
|
|
writer->printf("Est. range: %s\n", range_est.c_str());
|
|
}
|
|
|
|
if (StdMetrics.ms_v_pos_odometer->IsDefined())
|
|
{
|
|
const std::string& odometer = StdMetrics.ms_v_pos_odometer->AsUnitString("-", rangeUnit, 1);
|
|
writer->printf("ODO: %s\n", odometer.c_str());
|
|
}
|
|
|
|
if (StdMetrics.ms_v_bat_cac->IsDefined())
|
|
{
|
|
const std::string& cac = StdMetrics.ms_v_bat_cac->AsUnitString("-", Native, 1);
|
|
writer->printf("CAC: %s\n", cac.c_str());
|
|
}
|
|
|
|
if (StdMetrics.ms_v_bat_soh->IsDefined())
|
|
{
|
|
const std::string& soh = StdMetrics.ms_v_bat_soh->AsUnitString("-", Native, 0);
|
|
writer->printf("SOH: %s\n", soh.c_str());
|
|
}
|
|
|
|
return Success;
|
|
}
|
|
|
|
/**
|
|
* CommandStatTrip: default implementation of vehicle trip status report
|
|
*/
|
|
OvmsVehicle::vehicle_command_t OvmsVehicle::CommandStatTrip(int verbosity, OvmsWriter* writer)
|
|
{
|
|
metric_unit_t rangeUnit = (MyConfig.GetParamValue("vehicle", "units.distance") == "M") ? Miles : Kilometers;
|
|
metric_unit_t speedUnit = (rangeUnit == Miles) ? Mph : Kph;
|
|
metric_unit_t accelUnit = (rangeUnit == Miles) ? MphPS : KphPS;
|
|
metric_unit_t consumUnit = (rangeUnit == Miles) ? WattHoursPM : WattHoursPK;
|
|
metric_unit_t energyUnit = kWh;
|
|
metric_unit_t altitudeUnit = (rangeUnit == Miles) ? Feet : Meters;
|
|
const char* rangeUnitLabel = OvmsMetricUnitLabel(rangeUnit);
|
|
const char* speedUnitLabel = OvmsMetricUnitLabel(speedUnit);
|
|
const char* accelUnitLabel = OvmsMetricUnitLabel(accelUnit);
|
|
const char* consumUnitLabel = OvmsMetricUnitLabel(consumUnit);
|
|
const char* energyUnitLabel = OvmsMetricUnitLabel(energyUnit);
|
|
const char* altitudeUnitLabel = OvmsMetricUnitLabel(altitudeUnit);
|
|
|
|
float trip_length = StdMetrics.ms_v_pos_trip->AsFloat(0, rangeUnit);
|
|
|
|
float speed_avg = (m_drive_speedcnt > 0)
|
|
? UnitConvert(Kph, speedUnit, (float)(m_drive_speedsum / m_drive_speedcnt))
|
|
: 0;
|
|
float accel_avg = (m_drive_accelcnt > 0)
|
|
? UnitConvert(MetersPSS, accelUnit, (float)(m_drive_accelsum / m_drive_accelcnt))
|
|
: 0;
|
|
float decel_avg = (m_drive_decelcnt > 0)
|
|
? UnitConvert(MetersPSS, accelUnit, (float)(m_drive_decelsum / m_drive_decelcnt))
|
|
: 0;
|
|
float energy_recup_perc = (m_inv_energyused > 0) ? m_inv_energyrecd / m_inv_energyused * 100 : 0;
|
|
|
|
float energy_used = StdMetrics.ms_v_bat_energy_used->AsFloat();
|
|
float energy_recd = StdMetrics.ms_v_bat_energy_recd->AsFloat();
|
|
float energy_recd_perc = (energy_used > 0) ? energy_recd / energy_used * 100 : 0;
|
|
float wh_per_rangeunit = (trip_length > 0) ? (energy_used - energy_recd) * 1000 / trip_length : 0;
|
|
|
|
float soc = StdMetrics.ms_v_bat_soc->AsFloat();
|
|
float soc_diff = soc - m_drive_startsoc;
|
|
float range = StdMetrics.ms_v_bat_range_est->AsFloat();
|
|
float range_diff = range - m_drive_startrange;
|
|
float alt = StdMetrics.ms_v_pos_altitude->AsFloat();
|
|
float alt_diff = UnitConvert(Meters, altitudeUnit, alt - m_drive_startaltitude);
|
|
|
|
std::ostringstream buf;
|
|
buf
|
|
<< "Trip "
|
|
<< std::fixed
|
|
<< std::setprecision(1)
|
|
<< trip_length << rangeUnitLabel
|
|
<< " Avg "
|
|
<< std::setprecision(0)
|
|
<< speed_avg << speedUnitLabel
|
|
<< " Alt "
|
|
<< ((alt_diff >= 0) ? "+" : "")
|
|
<< alt_diff << altitudeUnitLabel
|
|
;
|
|
if (wh_per_rangeunit != 0)
|
|
{
|
|
buf
|
|
<< "\nEnergy "
|
|
<< wh_per_rangeunit << consumUnitLabel
|
|
<< ", "
|
|
<< energy_recd_perc << "% recd"
|
|
;
|
|
}
|
|
buf
|
|
<< std::setprecision(1)
|
|
<< "\nSOC "
|
|
<< ((soc_diff >= 0) ? "+" : "")
|
|
<< soc_diff << "%"
|
|
<< " = "
|
|
<< soc << "%"
|
|
<< "\nRange "
|
|
<< ((range_diff >= 0) ? "+" : "")
|
|
<< range_diff << rangeUnitLabel
|
|
<< " = "
|
|
<< range << rangeUnitLabel
|
|
;
|
|
if (accel_avg > 0)
|
|
{
|
|
buf
|
|
<< "\nAccel +"
|
|
<< accel_avg
|
|
<< " / "
|
|
<< decel_avg << accelUnitLabel
|
|
;
|
|
}
|
|
if (m_inv_energyused > 0)
|
|
{
|
|
buf
|
|
<< "\nMotor +"
|
|
<< std::setprecision(3)
|
|
<< m_inv_energyused
|
|
<< " / -"
|
|
<< m_inv_energyrecd << energyUnitLabel
|
|
<< std::setprecision(0)
|
|
<< " (" << energy_recup_perc << "% recd)"
|
|
;
|
|
}
|
|
|
|
writer->puts(buf.str().c_str());
|
|
|
|
return Success;
|
|
}
|
|
|
|
void OvmsVehicle::VehicleConfigChanged(std::string event, void* data)
|
|
{
|
|
OvmsConfigParam* param = (OvmsConfigParam*) data;
|
|
|
|
// read vehicle framework config:
|
|
if (!param || param->GetName() == "vehicle")
|
|
{
|
|
// acceleration calculation:
|
|
m_accel_smoothing = MyConfig.GetParamValueFloat("vehicle", "accel.smoothing", 2.0);
|
|
|
|
// brakelight battery power smoothing:
|
|
m_batpwr_smoothing = MyConfig.GetParamValueFloat("vehicle", "batpwr.smoothing", 2.0);
|
|
|
|
// brakelight control:
|
|
if (m_brakelight_enable)
|
|
{
|
|
SetBrakelight(0);
|
|
StdMetrics.ms_v_env_regenbrake->SetValue(false);
|
|
}
|
|
m_brakelight_enable = MyConfig.GetParamValueBool("vehicle", "brakelight.enable", false);
|
|
m_brakelight_on = MyConfig.GetParamValueFloat("vehicle", "brakelight.on", 1.3);
|
|
m_brakelight_off = MyConfig.GetParamValueFloat("vehicle", "brakelight.off", 0.7);
|
|
m_brakelight_port = MyConfig.GetParamValueInt("vehicle", "brakelight.port", 1);
|
|
m_brakelight_basepwr = MyConfig.GetParamValueFloat("vehicle", "brakelight.basepwr", 0);
|
|
m_brakelight_ignftbrk = MyConfig.GetParamValueBool("vehicle", "brakelight.ignftbrk", false);
|
|
m_brakelight_start = 0;
|
|
}
|
|
|
|
// read vehicle specific config:
|
|
ConfigChanged(param);
|
|
}
|
|
|
|
void OvmsVehicle::ConfigChanged(OvmsConfigParam* param)
|
|
{
|
|
}
|
|
|
|
void OvmsVehicle::MetricModified(OvmsMetric* metric)
|
|
{
|
|
if (metric == StandardMetrics.ms_v_env_on)
|
|
{
|
|
if (StandardMetrics.ms_v_env_on->AsBool())
|
|
{
|
|
m_drive_startsoc = StdMetrics.ms_v_bat_soc->AsFloat();
|
|
m_drive_startrange = StdMetrics.ms_v_bat_range_est->AsFloat();
|
|
m_drive_startaltitude = StdMetrics.ms_v_pos_altitude->AsFloat();
|
|
m_drive_speedcnt = 0;
|
|
m_drive_speedsum = 0;
|
|
m_drive_accelcnt = 0;
|
|
m_drive_accelsum = 0;
|
|
m_drive_decelcnt = 0;
|
|
m_drive_decelsum = 0;
|
|
m_inv_reftime = esp_log_timestamp();
|
|
m_inv_refpower = 0;
|
|
m_inv_energyused = 0;
|
|
m_inv_energyrecd = 0;
|
|
MyEvents.SignalEvent("vehicle.on",NULL);
|
|
if (m_autonotifications)
|
|
{
|
|
m_vehicleon_ticker = GetNotifyVehicleStateDelay("on");
|
|
if (m_vehicleon_ticker == 0)
|
|
NotifyVehicleOn();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (m_brakelight_enable && m_brakelight_start)
|
|
{
|
|
SetBrakelight(0);
|
|
m_brakelight_start = 0;
|
|
StdMetrics.ms_v_env_regenbrake->SetValue(false);
|
|
}
|
|
MyEvents.SignalEvent("vehicle.off",NULL);
|
|
if (m_autonotifications)
|
|
{
|
|
m_vehicleoff_ticker = GetNotifyVehicleStateDelay("off");
|
|
if (m_vehicleoff_ticker == 0)
|
|
NotifyVehicleOff();
|
|
}
|
|
}
|
|
}
|
|
else if (metric == StandardMetrics.ms_v_env_awake)
|
|
{
|
|
if (StandardMetrics.ms_v_env_awake->AsBool())
|
|
{
|
|
MyEvents.SignalEvent("vehicle.awake",NULL);
|
|
NotifiedVehicleAwake();
|
|
}
|
|
else
|
|
{
|
|
MyEvents.SignalEvent("vehicle.asleep",NULL);
|
|
NotifiedVehicleAsleep();
|
|
}
|
|
}
|
|
else if (metric == StandardMetrics.ms_v_charge_inprogress)
|
|
{
|
|
if (StandardMetrics.ms_v_charge_inprogress->AsBool())
|
|
{
|
|
MyEvents.SignalEvent("vehicle.charge.start",NULL);
|
|
NotifiedVehicleChargeStart();
|
|
}
|
|
else
|
|
{
|
|
MyEvents.SignalEvent("vehicle.charge.stop",NULL);
|
|
NotifiedVehicleChargeStop();
|
|
}
|
|
}
|
|
else if (metric == StandardMetrics.ms_v_door_chargeport)
|
|
{
|
|
if (StandardMetrics.ms_v_door_chargeport->AsBool())
|
|
{
|
|
MyEvents.SignalEvent("vehicle.charge.prepare",NULL);
|
|
NotifiedVehicleChargePrepare();
|
|
}
|
|
else
|
|
{
|
|
MyEvents.SignalEvent("vehicle.charge.finish",NULL);
|
|
NotifiedVehicleChargeFinish();
|
|
}
|
|
}
|
|
else if (metric == StandardMetrics.ms_v_charge_pilot)
|
|
{
|
|
if (StandardMetrics.ms_v_charge_pilot->AsBool())
|
|
{
|
|
MyEvents.SignalEvent("vehicle.charge.pilot.on",NULL);
|
|
NotifiedVehicleChargePilotOn();
|
|
}
|
|
else
|
|
{
|
|
MyEvents.SignalEvent("vehicle.charge.pilot.off",NULL);
|
|
NotifiedVehicleChargePilotOff();
|
|
}
|
|
}
|
|
else if (metric == StandardMetrics.ms_v_charge_timermode)
|
|
{
|
|
if (StandardMetrics.ms_v_charge_timermode->AsBool())
|
|
{
|
|
MyEvents.SignalEvent("vehicle.charge.timermode.on",NULL);
|
|
NotifiedVehicleChargeTimermodeOn();
|
|
}
|
|
else
|
|
{
|
|
MyEvents.SignalEvent("vehicle.charge.timermode.off",NULL);
|
|
NotifiedVehicleChargeTimermodeOff();
|
|
}
|
|
}
|
|
else if (metric == StandardMetrics.ms_v_env_aux12v)
|
|
{
|
|
if (StandardMetrics.ms_v_env_aux12v->AsBool())
|
|
{
|
|
MyEvents.SignalEvent("vehicle.aux.12v.on", NULL);
|
|
NotifiedVehicleAux12vOn();
|
|
}
|
|
else
|
|
{
|
|
MyEvents.SignalEvent("vehicle.aux.12v.off", NULL);
|
|
NotifiedVehicleAux12vOff();
|
|
}
|
|
}
|
|
else if (metric == StandardMetrics.ms_v_env_charging12v)
|
|
{
|
|
if (StandardMetrics.ms_v_env_charging12v->AsBool())
|
|
{
|
|
if (m_12v_ticker < 30)
|
|
m_12v_ticker = 30; // min calmdown time
|
|
MyEvents.SignalEvent("vehicle.charge.12v.start",NULL);
|
|
NotifiedVehicleCharge12vStart();
|
|
}
|
|
else
|
|
{
|
|
MyEvents.SignalEvent("vehicle.charge.12v.stop",NULL);
|
|
NotifiedVehicleCharge12vStop();
|
|
}
|
|
}
|
|
else if (metric == StandardMetrics.ms_v_env_locked)
|
|
{
|
|
if (StandardMetrics.ms_v_env_locked->AsBool())
|
|
{
|
|
MyEvents.SignalEvent("vehicle.locked",NULL);
|
|
NotifiedVehicleLocked();
|
|
}
|
|
else
|
|
{
|
|
MyEvents.SignalEvent("vehicle.unlocked",NULL);
|
|
NotifiedVehicleUnlocked();
|
|
}
|
|
}
|
|
else if (metric == StandardMetrics.ms_v_env_valet)
|
|
{
|
|
if (StandardMetrics.ms_v_env_valet->AsBool())
|
|
{
|
|
MyEvents.SignalEvent("vehicle.valet.on",NULL);
|
|
if (m_autonotifications) NotifyValetEnabled();
|
|
NotifiedVehicleValetOn();
|
|
}
|
|
else
|
|
{
|
|
MyEvents.SignalEvent("vehicle.valet.off",NULL);
|
|
if (m_autonotifications) NotifyValetDisabled();
|
|
NotifiedVehicleValetOff();
|
|
}
|
|
}
|
|
else if (metric == StandardMetrics.ms_v_env_headlights)
|
|
{
|
|
if (StandardMetrics.ms_v_env_headlights->AsBool())
|
|
{
|
|
MyEvents.SignalEvent("vehicle.headlights.on",NULL);
|
|
NotifiedVehicleHeadlightsOn();
|
|
}
|
|
else
|
|
{
|
|
MyEvents.SignalEvent("vehicle.headlights.off",NULL);
|
|
NotifiedVehicleHeadlightsOff();
|
|
}
|
|
}
|
|
else if (metric == StandardMetrics.ms_v_door_hood)
|
|
{
|
|
if (StandardMetrics.ms_v_door_hood->AsBool() &&
|
|
StandardMetrics.ms_v_env_valet->AsBool())
|
|
{
|
|
if (m_autonotifications) NotifyValetHood();
|
|
}
|
|
}
|
|
else if (metric == StandardMetrics.ms_v_door_trunk)
|
|
{
|
|
if (StandardMetrics.ms_v_door_trunk->AsBool() &&
|
|
StandardMetrics.ms_v_env_valet->AsBool())
|
|
{
|
|
if (m_autonotifications) NotifyValetTrunk();
|
|
}
|
|
}
|
|
else if (metric == StandardMetrics.ms_v_env_alarm)
|
|
{
|
|
if (StandardMetrics.ms_v_env_alarm->AsBool())
|
|
{
|
|
MyEvents.SignalEvent("vehicle.alarm.on",NULL);
|
|
if (m_autonotifications) NotifyAlarmSounding();
|
|
NotifiedVehicleAlarmOn();
|
|
}
|
|
else
|
|
{
|
|
MyEvents.SignalEvent("vehicle.alarm.off",NULL);
|
|
if (m_autonotifications) NotifyAlarmStopped();
|
|
NotifiedVehicleAlarmOff();
|
|
}
|
|
}
|
|
else if (metric == StandardMetrics.ms_v_env_gear)
|
|
{
|
|
int gear = StandardMetrics.ms_v_env_gear->AsInt();
|
|
if (gear < 0)
|
|
MyEvents.SignalEvent("vehicle.gear.reverse", NULL);
|
|
else if (gear > 0)
|
|
MyEvents.SignalEvent("vehicle.gear.forward", NULL);
|
|
else
|
|
MyEvents.SignalEvent("vehicle.gear.neutral", NULL);
|
|
NotifiedVehicleGear(gear);
|
|
}
|
|
else if (metric == StandardMetrics.ms_v_env_drivemode)
|
|
{
|
|
std::string event = "vehicle.drivemode." + StandardMetrics.ms_v_env_drivemode->AsString();
|
|
MyEvents.SignalEvent(event, NULL);
|
|
NotifiedVehicleDrivemode(StandardMetrics.ms_v_env_drivemode->AsInt());
|
|
}
|
|
else if (metric == StandardMetrics.ms_v_charge_mode)
|
|
{
|
|
std::string m = metric->AsString();
|
|
const char* mc = m.c_str();
|
|
MyEvents.SignalEvent("vehicle.charge.mode",(void*)mc, strlen(mc)+1);
|
|
NotifiedVehicleChargeMode(mc);
|
|
}
|
|
else if (metric == StandardMetrics.ms_v_charge_state)
|
|
{
|
|
std::string m = metric->AsString();
|
|
const char* mc = m.c_str();
|
|
MyEvents.SignalEvent("vehicle.charge.state",(void*)mc, strlen(mc)+1);
|
|
if (m == "done")
|
|
{
|
|
StandardMetrics.ms_v_charge_duration_full->SetValue(0);
|
|
StandardMetrics.ms_v_charge_duration_range->SetValue(0);
|
|
StandardMetrics.ms_v_charge_duration_soc->SetValue(0);
|
|
}
|
|
if (m_autonotifications)
|
|
{
|
|
m_chargestate_ticker = GetNotifyChargeStateDelay(mc);
|
|
if (m_chargestate_ticker == 0)
|
|
NotifyChargeState();
|
|
}
|
|
}
|
|
else if (metric == StandardMetrics.ms_v_gen_state)
|
|
{
|
|
std::string state = metric->AsString();
|
|
MyEvents.SignalEvent("vehicle.gen.state", (void*)state.c_str(), state.size()+1);
|
|
if (m_autonotifications)
|
|
NotifyGenState();
|
|
}
|
|
else if (metric == StandardMetrics.ms_v_pos_speed)
|
|
{
|
|
// Collect data for trip speed average:
|
|
const float min_speed = 5.0; // slow speed exclusion [kph]
|
|
float speed = StandardMetrics.ms_v_pos_speed->AsFloat();
|
|
if (speed > min_speed)
|
|
{
|
|
m_drive_speedcnt++;
|
|
m_drive_speedsum += speed;
|
|
}
|
|
}
|
|
else if (metric == StdMetrics.ms_v_inv_power)
|
|
// collect data for trip pos. and neg. (recuperated) motor energies
|
|
{
|
|
uint32_t now = esp_log_timestamp();
|
|
if (now > m_inv_reftime)
|
|
{
|
|
float invpower = StdMetrics.ms_v_inv_power->AsFloat();
|
|
float invenergy = (m_inv_refpower + invpower) * (now - m_inv_reftime) / (2*1000*3600); // average of last 2 values in kWh
|
|
if ( invenergy < 0 )
|
|
{
|
|
m_inv_energyrecd -= invenergy; // sum should be positive
|
|
}
|
|
else
|
|
{
|
|
m_inv_energyused += invenergy;
|
|
}
|
|
m_inv_refpower = invpower;
|
|
m_inv_reftime = now;
|
|
}
|
|
}
|
|
else if (metric == StandardMetrics.ms_v_pos_acceleration)
|
|
{
|
|
if (m_brakelight_enable)
|
|
CheckBrakelight();
|
|
|
|
// Collect data for trip acceleration/deceleration average:
|
|
const float min_accel = 2.5 / 3.6; // cruising range exclusion [m/s²]
|
|
float accel = StandardMetrics.ms_v_pos_acceleration->AsFloat();
|
|
if (accel > min_accel)
|
|
{
|
|
m_drive_accelcnt++;
|
|
m_drive_accelsum += accel;
|
|
}
|
|
else if (accel < -min_accel)
|
|
{
|
|
m_drive_decelcnt++;
|
|
m_drive_decelsum += accel;
|
|
}
|
|
}
|
|
else if (metric == StandardMetrics.ms_v_bat_power)
|
|
{
|
|
if (m_batpwr_smoothing > 0)
|
|
m_batpwr_smoothed = (m_batpwr_smoothed + metric->AsFloat() * m_batpwr_smoothing) / (m_batpwr_smoothing + 1);
|
|
else
|
|
m_batpwr_smoothed = metric->AsFloat();
|
|
}
|
|
else if (metric == StdMetrics.ms_v_bat_current || metric == StdMetrics.ms_v_bat_cac ||
|
|
metric == StdMetrics.ms_v_bat_range_full)
|
|
{
|
|
CalculateRangeSpeed();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* CalculateAcceleration: derive acceleration / deceleration level from speed change
|
|
* Note:
|
|
* IF you want to let the framework calculate acceleration, call this after your regular
|
|
* update to StdMetrics.ms_v_pos_speed. This is optional, you can set ms_v_pos_acceleration
|
|
* yourself if your vehicle provides this metric.
|
|
*/
|
|
void OvmsVehicle::CalculateAcceleration()
|
|
{
|
|
uint32_t now = esp_log_timestamp();
|
|
if (now > m_accel_reftime)
|
|
{
|
|
float speed = ABS(StdMetrics.ms_v_pos_speed->AsFloat(0, Kph)) * 1000 / 3600;
|
|
float accel = (speed - m_accel_refspeed) / (now - m_accel_reftime) * 1000;
|
|
// smooth out road bumps & gear box backlash:
|
|
if (m_accel_smoothing > 0)
|
|
accel = (accel + StdMetrics.ms_v_pos_acceleration->AsFloat() * m_accel_smoothing) / (m_accel_smoothing + 1);
|
|
StdMetrics.ms_v_pos_acceleration->SetValue(TRUNCPREC(accel, 3));
|
|
m_accel_refspeed = speed;
|
|
m_accel_reftime = now;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* CheckBrakelight: check for regenerative braking, control brakelight accordingly
|
|
* Notes:
|
|
* a) This depends on a regular and frequent speed update with <= 100 ms period. If the vehicle
|
|
* delivers speed values at too large intervals, the trigger will still work but come
|
|
* too late (reducing/deactivating acceleration smoothing may help).
|
|
* If the vehicle raw speed is already smoothed, reducing acceleration smoothing will
|
|
* provide a faster trigger. Same applies for the battery power level.
|
|
* b) The battery power regen threshold is defined at -[brakelight.basepwr] for activation
|
|
* and +[brakelight.basepwr] for deactivation. The config default is 0 as that works
|
|
* on vehicles without the battery power metric.
|
|
* c) To reduce flicker the brake light has a minimum hold time of currently fixed 500 ms.
|
|
* d) Normal operation is "regen light XOR foot brake light", set [brakelight.ignftbrk]
|
|
* to true to disable this.
|
|
* Override to customize.
|
|
*/
|
|
void OvmsVehicle::CheckBrakelight()
|
|
{
|
|
uint32_t now = esp_log_timestamp();
|
|
float speed = ABS(StdMetrics.ms_v_pos_speed->AsFloat(0, Kph)) * 1000 / 3600;
|
|
float accel = StdMetrics.ms_v_pos_acceleration->AsFloat();
|
|
bool car_on = StdMetrics.ms_v_env_on->AsBool();
|
|
bool footbrake = StdMetrics.ms_v_env_footbrake->AsFloat() > 0;
|
|
const uint32_t holdtime = 500;
|
|
|
|
// activate brake light?
|
|
if (car_on && accel < -m_brakelight_on && speed >= 1 && m_batpwr_smoothed <= -m_brakelight_basepwr
|
|
&& (m_brakelight_ignftbrk || !footbrake))
|
|
{
|
|
if (!m_brakelight_start)
|
|
{
|
|
if (SetBrakelight(1))
|
|
{
|
|
ESP_LOGD(TAG, "brakelight on at speed=%.2f m/s, accel=%.2f m/s^2", speed, accel);
|
|
m_brakelight_start = now;
|
|
StdMetrics.ms_v_env_regenbrake->SetValue(true);
|
|
}
|
|
else
|
|
ESP_LOGW(TAG, "can't activate brakelight");
|
|
}
|
|
else
|
|
m_brakelight_start = now;
|
|
}
|
|
// deactivate brake light?
|
|
else if (!car_on || accel >= -m_brakelight_off || speed < 1 || m_batpwr_smoothed > m_brakelight_basepwr
|
|
|| (!m_brakelight_ignftbrk && footbrake))
|
|
{
|
|
if (m_brakelight_start && now >= m_brakelight_start + holdtime)
|
|
{
|
|
if (SetBrakelight(0))
|
|
{
|
|
ESP_LOGD(TAG, "brakelight off at speed=%.2f m/s, accel=%.2f m/s^2", speed, accel);
|
|
m_brakelight_start = 0;
|
|
StdMetrics.ms_v_env_regenbrake->SetValue(false);
|
|
}
|
|
else
|
|
ESP_LOGW(TAG, "can't deactivate brakelight");
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* SetBrakelight: hardware brake light control method
|
|
* Override for custom control, e.g. CAN.
|
|
*/
|
|
bool OvmsVehicle::SetBrakelight(int on)
|
|
{
|
|
#ifdef CONFIG_OVMS_COMP_MAX7317
|
|
// port 2 = SN65 for esp32can
|
|
if (m_brakelight_port == 1 || (m_brakelight_port >= 3 && m_brakelight_port <= 9))
|
|
{
|
|
MyPeripherals->m_max7317->Output(m_brakelight_port, on);
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
ESP_LOGE(TAG, "SetBrakelight: invalid port configuration (valid: 1, 3..9)");
|
|
return false;
|
|
}
|
|
#else // CONFIG_OVMS_COMP_MAX7317
|
|
ESP_LOGE(TAG, "SetBrakelight: OVMS_COMP_MAX7317 missing");
|
|
return false;
|
|
#endif // CONFIG_OVMS_COMP_MAX7317
|
|
}
|
|
|
|
/**
|
|
* CalculateRangeSpeed: derive momentary charge gain/loss speed (range charged/discharged per hour)
|
|
*/
|
|
void OvmsVehicle::CalculateRangeSpeed()
|
|
{
|
|
float
|
|
bat_current = StdMetrics.ms_v_bat_current->AsFloat(),
|
|
bat_capacity = StdMetrics.ms_v_bat_cac->AsFloat(),
|
|
range_full = StdMetrics.ms_v_bat_range_full->AsFloat();
|
|
|
|
if (bat_capacity > 0 && range_full > 0)
|
|
{
|
|
*StdMetrics.ms_v_bat_range_speed = TRUNCPREC(-bat_current / bat_capacity * range_full, 1);
|
|
}
|
|
}
|
|
|
|
void OvmsVehicle::NotifyChargeState()
|
|
{
|
|
std::string m = StandardMetrics.ms_v_charge_state->AsString();
|
|
if (m == "done")
|
|
NotifyChargeDone();
|
|
else if (m == "stopped" || m == "timerwait")
|
|
NotifyChargeStopped();
|
|
else if (m == "charging")
|
|
NotifyChargeStart();
|
|
else if (m == "topoff")
|
|
NotifyChargeTopOff();
|
|
else if (m == "heating")
|
|
NotifyHeatingStart();
|
|
|
|
if (m != "")
|
|
NotifyGridLog();
|
|
|
|
NotifiedVehicleChargeState(m.c_str());
|
|
}
|
|
|
|
void OvmsVehicle::NotifyGenState()
|
|
{
|
|
std::string m = StandardMetrics.ms_v_gen_state->AsString();
|
|
// Generator states TBD
|
|
|
|
if (m != "")
|
|
NotifyGridLog();
|
|
|
|
NotifiedVehicleGenState(m);
|
|
}
|
|
|
|
void OvmsVehicle::NotifyGridLog()
|
|
{
|
|
// Send grid (charge/generator) session log
|
|
// History type "*-LOG-Grid"
|
|
// Notification type "data", subtype "log.grid"
|
|
|
|
int storetime_days = MyConfig.GetParamValueInt("notify", "log.grid.storetime", 0);
|
|
if (storetime_days <= 0)
|
|
return;
|
|
|
|
std::ostringstream buf;
|
|
buf
|
|
<< "*-LOG-Grid,1," << storetime_days * 86400 // V1, increment on additions
|
|
|
|
<< std::noboolalpha
|
|
<< "," << (StdMetrics.ms_v_pos_gpslock->AsBool() ? 1 : 0)
|
|
<< std::fixed
|
|
<< std::setprecision(8)
|
|
<< "," << StdMetrics.ms_v_pos_latitude->AsFloat()
|
|
<< "," << StdMetrics.ms_v_pos_longitude->AsFloat()
|
|
<< std::setprecision(1)
|
|
<< "," << StdMetrics.ms_v_pos_altitude->AsFloat()
|
|
<< "," << mp_encode(StdMetrics.ms_v_pos_location->AsString())
|
|
|
|
<< "," << mp_encode(StdMetrics.ms_v_charge_type->AsString())
|
|
<< "," << mp_encode(StdMetrics.ms_v_charge_state->AsString())
|
|
<< "," << mp_encode(StdMetrics.ms_v_charge_substate->AsString())
|
|
<< "," << mp_encode(StdMetrics.ms_v_charge_mode->AsString())
|
|
<< "," << StdMetrics.ms_v_charge_climit->AsFloat()
|
|
<< "," << StdMetrics.ms_v_charge_limit_range->AsFloat()
|
|
<< "," << StdMetrics.ms_v_charge_limit_soc->AsFloat()
|
|
|
|
<< "," << mp_encode(StdMetrics.ms_v_gen_type->AsString())
|
|
<< "," << mp_encode(StdMetrics.ms_v_gen_state->AsString())
|
|
<< "," << mp_encode(StdMetrics.ms_v_gen_substate->AsString())
|
|
<< "," << mp_encode(StdMetrics.ms_v_gen_mode->AsString())
|
|
<< "," << StdMetrics.ms_v_gen_climit->AsFloat()
|
|
<< "," << StdMetrics.ms_v_gen_limit_range->AsFloat()
|
|
<< "," << StdMetrics.ms_v_gen_limit_soc->AsFloat()
|
|
|
|
<< std::setprecision(3)
|
|
|
|
<< "," << m_last_chargetime
|
|
<< "," << StdMetrics.ms_v_charge_kwh->AsFloat()
|
|
<< "," << StdMetrics.ms_v_charge_kwh_grid->AsFloat()
|
|
<< "," << StdMetrics.ms_v_charge_kwh_grid_total->AsFloat()
|
|
|
|
<< "," << m_last_gentime
|
|
<< "," << StdMetrics.ms_v_gen_kwh->AsFloat()
|
|
<< "," << StdMetrics.ms_v_gen_kwh_grid->AsFloat()
|
|
<< "," << StdMetrics.ms_v_gen_kwh_grid_total->AsFloat()
|
|
|
|
<< std::setprecision(1)
|
|
|
|
<< "," << StdMetrics.ms_v_bat_soc->AsFloat()
|
|
<< "," << StdMetrics.ms_v_bat_range_est->AsFloat()
|
|
<< "," << StdMetrics.ms_v_bat_range_ideal->AsFloat()
|
|
<< "," << StdMetrics.ms_v_bat_range_full->AsFloat()
|
|
|
|
<< "," << StdMetrics.ms_v_bat_voltage->AsFloat()
|
|
<< "," << StdMetrics.ms_v_bat_temp->AsFloat()
|
|
|
|
<< "," << StdMetrics.ms_v_charge_temp->AsFloat()
|
|
<< "," << StdMetrics.ms_v_charge_12v_temp->AsFloat()
|
|
<< "," << StdMetrics.ms_v_env_temp->AsFloat()
|
|
<< "," << StdMetrics.ms_v_env_cabintemp->AsFloat()
|
|
|
|
<< std::setprecision(3)
|
|
|
|
<< "," << StdMetrics.ms_v_bat_soh->AsFloat()
|
|
<< "," << mp_encode(StdMetrics.ms_v_bat_health->AsString())
|
|
<< "," << StdMetrics.ms_v_bat_cac->AsFloat()
|
|
|
|
<< "," << StdMetrics.ms_v_bat_energy_used_total->AsFloat()
|
|
<< "," << StdMetrics.ms_v_bat_energy_recd_total->AsFloat()
|
|
<< "," << StdMetrics.ms_v_bat_coulomb_used_total->AsFloat()
|
|
<< "," << StdMetrics.ms_v_bat_coulomb_recd_total->AsFloat()
|
|
;
|
|
|
|
MyNotify.NotifyString("data", "log.grid", buf.str().c_str());
|
|
}
|
|
|
|
void OvmsVehicle::NotifyVehicleOn()
|
|
{
|
|
NotifyTripLog();
|
|
NotifiedVehicleOn();
|
|
}
|
|
|
|
void OvmsVehicle::NotifyVehicleOff()
|
|
{
|
|
float trip = StdMetrics.ms_v_pos_trip->AsFloat();
|
|
if (trip >= MyConfig.GetParamValueFloat("notify", "log.trip.minlength", 0.2))
|
|
NotifyTripLog();
|
|
if (trip >= MyConfig.GetParamValueFloat("notify", "report.trip.minlength", 0.2))
|
|
NotifyTripReport();
|
|
NotifiedVehicleOff();
|
|
}
|
|
|
|
void OvmsVehicle::NotifyTripLog()
|
|
{
|
|
// Send trip log
|
|
// History type "*-LOG-Trip"
|
|
// Notification type "data", subtype "log.trip"
|
|
|
|
int storetime_days = MyConfig.GetParamValueInt("notify", "log.trip.storetime", 0);
|
|
if (storetime_days <= 0)
|
|
return;
|
|
|
|
// Get min/max TPMS values:
|
|
const auto t_temp = StdMetrics.ms_v_tpms_temp->AsVector();
|
|
const auto t_prss = StdMetrics.ms_v_tpms_pressure->AsVector();
|
|
const auto t_hlth = StdMetrics.ms_v_tpms_health->AsVector();
|
|
const auto t_temp_minmax = std::minmax_element(t_temp.begin(), t_temp.end());
|
|
const auto t_prss_minmax = std::minmax_element(t_prss.begin(), t_prss.end());
|
|
const auto t_hlth_minmax = std::minmax_element(t_hlth.begin(), t_hlth.end());
|
|
|
|
std::ostringstream buf;
|
|
buf
|
|
<< "*-LOG-Trip,1," << storetime_days * 86400 // V1, increment on additions
|
|
|
|
<< std::noboolalpha
|
|
<< "," << (StdMetrics.ms_v_pos_gpslock->AsBool() ? 1 : 0)
|
|
<< std::fixed
|
|
<< std::setprecision(8)
|
|
<< "," << StdMetrics.ms_v_pos_latitude->AsFloat()
|
|
<< "," << StdMetrics.ms_v_pos_longitude->AsFloat()
|
|
<< std::setprecision(1)
|
|
<< "," << StdMetrics.ms_v_pos_altitude->AsFloat()
|
|
<< "," << mp_encode(StdMetrics.ms_v_pos_location->AsString())
|
|
|
|
<< "," << StdMetrics.ms_v_pos_odometer->AsFloat()
|
|
|
|
<< "," << StdMetrics.ms_v_pos_trip->AsFloat()
|
|
<< "," << m_last_drivetime
|
|
<< "," << StdMetrics.ms_v_env_drivemode->AsInt()
|
|
|
|
<< "," << StdMetrics.ms_v_bat_soc->AsFloat()
|
|
<< "," << StdMetrics.ms_v_bat_range_est->AsFloat()
|
|
<< "," << StdMetrics.ms_v_bat_range_ideal->AsFloat()
|
|
<< "," << StdMetrics.ms_v_bat_range_full->AsFloat()
|
|
|
|
<< std::setprecision(3)
|
|
|
|
<< "," << StdMetrics.ms_v_bat_energy_used->AsFloat()
|
|
<< "," << StdMetrics.ms_v_bat_energy_recd->AsFloat()
|
|
<< "," << StdMetrics.ms_v_bat_coulomb_used->AsFloat()
|
|
<< "," << StdMetrics.ms_v_bat_coulomb_recd->AsFloat()
|
|
|
|
<< "," << StdMetrics.ms_v_bat_soh->AsFloat()
|
|
<< "," << mp_encode(StdMetrics.ms_v_bat_health->AsString())
|
|
<< "," << StdMetrics.ms_v_bat_cac->AsFloat()
|
|
|
|
<< "," << StdMetrics.ms_v_bat_energy_used_total->AsFloat()
|
|
<< "," << StdMetrics.ms_v_bat_energy_recd_total->AsFloat()
|
|
<< "," << StdMetrics.ms_v_bat_coulomb_used_total->AsFloat()
|
|
<< "," << StdMetrics.ms_v_bat_coulomb_recd_total->AsFloat()
|
|
|
|
<< std::setprecision(1)
|
|
|
|
<< "," << StdMetrics.ms_v_env_temp->AsFloat()
|
|
<< "," << StdMetrics.ms_v_env_cabintemp->AsFloat()
|
|
<< "," << StdMetrics.ms_v_bat_temp->AsFloat()
|
|
<< "," << StdMetrics.ms_v_inv_temp->AsFloat()
|
|
<< "," << StdMetrics.ms_v_mot_temp->AsFloat()
|
|
<< "," << StdMetrics.ms_v_charge_12v_temp->AsFloat()
|
|
;
|
|
|
|
if (t_temp.empty())
|
|
buf << ",,";
|
|
else
|
|
buf << "," << *std::get<0>(t_temp_minmax) << "," << *std::get<1>(t_temp_minmax);
|
|
if (t_prss.empty())
|
|
buf << ",,";
|
|
else
|
|
buf << "," << *std::get<0>(t_prss_minmax) << "," << *std::get<1>(t_prss_minmax);
|
|
if (t_hlth.empty())
|
|
buf << ",,";
|
|
else
|
|
buf << "," << *std::get<0>(t_hlth_minmax) << "," << *std::get<1>(t_hlth_minmax);
|
|
|
|
MyNotify.NotifyString("data", "log.trip", buf.str().c_str());
|
|
}
|
|
|
|
void OvmsVehicle::NotifyTripReport()
|
|
{
|
|
// Send trip report notification
|
|
// Notification type "info", subtype "drive.trip.report"
|
|
bool send_report = MyConfig.GetParamValueBool("notify", "report.trip.enable", false);
|
|
if (send_report)
|
|
{
|
|
StringWriter buf(200);
|
|
CommandStatTrip(COMMAND_RESULT_NORMAL, &buf);
|
|
MyNotify.NotifyString("info", "drive.trip.report", buf.c_str());
|
|
}
|
|
}
|
|
|
|
OvmsVehicle::vehicle_mode_t OvmsVehicle::VehicleModeKey(const std::string code)
|
|
{
|
|
vehicle_mode_t key;
|
|
if (code == "standard") key = Standard;
|
|
else if (code == "storage") key = Storage;
|
|
else if (code == "range") key = Range;
|
|
else if (code == "performance") key = Performance;
|
|
else key = Standard;
|
|
return key;
|
|
}
|
|
|
|
|
|
/**
|
|
* SetFeature: V2 compatibility config wrapper
|
|
* Note: V2 only supported integer values, V3 values may be text
|
|
*/
|
|
bool OvmsVehicle::SetFeature(int key, const char *value)
|
|
{
|
|
switch (key)
|
|
{
|
|
case 8:
|
|
MyConfig.SetParamValue("vehicle", "stream", value);
|
|
return true;
|
|
case 9:
|
|
MyConfig.SetParamValue("vehicle", "minsoc", value);
|
|
return true;
|
|
case 14:
|
|
MyConfig.SetParamValue("vehicle", "carbits", value);
|
|
return true;
|
|
case 15:
|
|
MyConfig.SetParamValue("vehicle", "canwrite", value);
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* GetFeature: V2 compatibility config wrapper
|
|
* Note: V2 only supported integer values, V3 values may be text
|
|
*/
|
|
const std::string OvmsVehicle::GetFeature(int key)
|
|
{
|
|
switch (key)
|
|
{
|
|
case 8:
|
|
return MyConfig.GetParamValue("vehicle", "stream", "0");
|
|
case 9:
|
|
return MyConfig.GetParamValue("vehicle", "minsoc", "0");
|
|
case 14:
|
|
return MyConfig.GetParamValue("vehicle", "carbits", "0");
|
|
case 15:
|
|
return MyConfig.GetParamValue("vehicle", "canwrite", "0");
|
|
default:
|
|
return "0";
|
|
}
|
|
}
|
|
|
|
/**
|
|
* ProcessMsgCommand: V2 compatibility protocol message command processing
|
|
* result: optional payload or message to return to the caller with the command response
|
|
*/
|
|
OvmsVehicle::vehicle_command_t OvmsVehicle::ProcessMsgCommand(std::string &result, int command, const char* args)
|
|
{
|
|
return NotImplemented;
|
|
}
|
|
|
|
|
|
#ifdef CONFIG_OVMS_COMP_WEBSERVER
|
|
/**
|
|
* GetDashboardConfig: template / default configuration
|
|
* (override with vehicle specific configuration)
|
|
* see https://api.highcharts.com/highcharts/yAxis for details on options
|
|
*/
|
|
void OvmsVehicle::GetDashboardConfig(DashboardConfig& cfg)
|
|
{
|
|
cfg.gaugeset1 =
|
|
"yAxis: [{"
|
|
// Speed:
|
|
"min: 0, max: 200,"
|
|
"plotBands: ["
|
|
"{ from: 0, to: 120, className: 'green-band' },"
|
|
"{ from: 120, to: 160, className: 'yellow-band' },"
|
|
"{ from: 160, to: 200, className: 'red-band' }]"
|
|
"},{"
|
|
// Voltage:
|
|
"min: 310, max: 410,"
|
|
"plotBands: ["
|
|
"{ from: 310, to: 325, className: 'red-band' },"
|
|
"{ from: 325, to: 340, className: 'yellow-band' },"
|
|
"{ from: 340, to: 410, className: 'green-band' }]"
|
|
"},{"
|
|
// SOC:
|
|
"min: 0, max: 100,"
|
|
"plotBands: ["
|
|
"{ from: 0, to: 12.5, className: 'red-band' },"
|
|
"{ from: 12.5, to: 25, className: 'yellow-band' },"
|
|
"{ from: 25, to: 100, className: 'green-band' }]"
|
|
"},{"
|
|
// Efficiency:
|
|
"min: 0, max: 400,"
|
|
"plotBands: ["
|
|
"{ from: 0, to: 200, className: 'green-band' },"
|
|
"{ from: 200, to: 300, className: 'yellow-band' },"
|
|
"{ from: 300, to: 400, className: 'red-band' }]"
|
|
"},{"
|
|
// Power:
|
|
"min: -50, max: 200,"
|
|
"plotBands: ["
|
|
"{ from: -50, to: 0, className: 'violet-band' },"
|
|
"{ from: 0, to: 100, className: 'green-band' },"
|
|
"{ from: 100, to: 150, className: 'yellow-band' },"
|
|
"{ from: 150, to: 200, className: 'red-band' }]"
|
|
"},{"
|
|
// Charger temperature:
|
|
"min: 20, max: 80, tickInterval: 20,"
|
|
"plotBands: ["
|
|
"{ from: 20, to: 65, className: 'normal-band border' },"
|
|
"{ from: 65, to: 80, className: 'red-band border' }]"
|
|
"},{"
|
|
// Battery temperature:
|
|
"min: -15, max: 65, tickInterval: 25,"
|
|
"plotBands: ["
|
|
"{ from: -15, to: 0, className: 'red-band border' },"
|
|
"{ from: 0, to: 50, className: 'normal-band border' },"
|
|
"{ from: 50, to: 65, className: 'red-band border' }]"
|
|
"},{"
|
|
// Inverter temperature:
|
|
"min: 20, max: 80, tickInterval: 20,"
|
|
"plotBands: ["
|
|
"{ from: 20, to: 70, className: 'normal-band border' },"
|
|
"{ from: 70, to: 80, className: 'red-band border' }]"
|
|
"},{"
|
|
// Motor temperature:
|
|
"min: 50, max: 125, tickInterval: 25,"
|
|
"plotBands: ["
|
|
"{ from: 50, to: 110, className: 'normal-band border' },"
|
|
"{ from: 110, to: 125, className: 'red-band border' }]"
|
|
"}]";
|
|
}
|
|
#endif // #ifdef CONFIG_OVMS_COMP_WEBSERVER
|