Crash_Override/OVMS3
2
0
Fork 0
Code Issues 5 Pull requests Projects Releases 4 Wiki Activity
OVMS3/OVMS.V3/components/vehicle/vehicle.h

785 lines
40 KiB
C
Raw Normal View History

Initial commit, fork from original Project
2022-04-05 22:04:46 +00:00
/*
; 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.
*/
#ifndef __VEHICLE_H__
#define __VEHICLE_H__
#include <map>
#include <vector>
#include <string>
#include "can.h"
#include "ovms_events.h"
#include "ovms_config.h"
#include "ovms_metrics.h"
#include "ovms_command.h"
#include "metrics_standard.h"
#include "ovms_mutex.h"
#include "ovms_semaphore.h"
using namespace std;
struct DashboardConfig;
// ISO TP:
// (see https://en.wikipedia.org/wiki/ISO_15765-2)
#define ISOTP_FT_SINGLE 0
#define ISOTP_FT_FIRST 1
#define ISOTP_FT_CONSECUTIVE 2
#define ISOTP_FT_FLOWCTRL 3
// Protocol variant:
#define ISOTP_STD 0 // standard addressing (11 bit IDs)
#define ISOTP_EXTADR 1 // extended addressing (19 bit IDs)
#define ISOTP_EXTFRAME 2 // extended frame mode (29 bit IDs)
#define VWTP_16 16 // VW/VAG Transport Protocol 1.6 (placeholder, unsupported)
#define VWTP_20 20 // VW/VAG Transport Protocol 2.0
// Argument tag:
#define POLL_TXDATA 0xff // poll_pid_t using xargs for external payload up to 4095 bytes
// OBD2/UDS Polling types supported:
// (see https://en.wikipedia.org/wiki/OBD-II_PIDs
// and https://en.wikipedia.org/wiki/Unified_Diagnostic_Services)
//
// Depending on the poll type, the response may or may not echo the PID (parameter ID / subtype).
// If no echo is present, the poller will only validate the type.
//
// Depending on the poll type, you may also need to pass additional arguments. These can be set
// alternatively to the single PID in the poll_pid_t.args field, which extends the pid by a data
// length and up to 6 data bytes. A common example is reading a DTC info, the service has an
// 8 bit PID (subtype) and depending on the subtype 1-4 additional parameter bytes:
// { TXID, RXID, POLLTYPE, {.args={ PID, DATALEN, DATA1, … }}, {…TIMES…}, 0, ISOTP_STD }
//
// Since version 3.2.016-140 the poller supports multi-frame requests and adds a more versatile way
// to pass additional arguments / TX data of up to 4095 bytes using the new 'xargs' union member,
// which takes a data length and a pointer to an uint8_t array. The xargs.tag member needs to
// be set to POLL_TXDATA for this.
//
// Use the utility macro POLL_PID_DATA (see below) to create poll_pid_t entries like this:
// { TXID, RXID, POLLTYPE, POLL_PID_DATA(PID, DATASTRING), {…TIMES…}, 0, ISOTP_STD }
//
// DATASTRING is a C string for ease of use, the terminating NUL char is excluded by the macro.
// To pass hexadecimal values, simply define them by '\x..', example:
// POLL_PID_DATA(0x21D4, "\x0F\x02\0x00\xAB\xCD")
//
// The poller automatically uses a single or multi frame request as needed.
//
// See OvmsVehicle::PollSingleRequest() on how to send dynamic requests with additional arguments.
//
// VWTP_20: this protocol implements the VW (VAG) specific "TP 2.0", which establishes
// OSI layer 5 communication channels to devices (ECU modules) via a CAN gateway.
// On VWTP_20 poll entries, simply set the TXID to the gateway base ID (normally 0x200)
// and the RXID to the logical 8 bit ECU ID you want to address.
// TP 2.0 transports standard OBD/UDS requests, so everything else works the same way
// as with ISO-TP.
//
// VW TP 2.0 poll entry examples:
// // TXID, RXID, TYPE, PID, TIMES, BUS, PROT
// { 0x200, 0x1f, 0x10, 0x89, {…times…}, 0, VWTP_20 }
// { 0x200, 0x1f, 0x22, 0x04a1, {…times…}, 0 , VWTP_20 }
//
// VW gateways currently do not support multiple open channels. To minimize connection
// overhead for successive polls to an ECU, the VWTP_20 engine keeps an idle connection open
// until the keepalive timeout occurs. So you should try to arrange your polls in interval
// blocks/sequences to the same devices if possible.
//
// To explicitly close a VWTP_20 channel, send a poll (any type) to RXID 0, that just
// closes the channel (ECU ID 0 is an invalid destination):
// { 0x200, 0, 0, 0, {…times…}, 0 , VWTP_20 }
#define VEHICLE_POLL_TYPE_NONE 0x00
// OBD (ISO 15031) service identifiers supported:
#define VEHICLE_POLL_TYPE_OBDIICURRENT 0x01 // Mode 01 "current data" (8 bit PID)
#define VEHICLE_POLL_TYPE_OBDIIFREEZE 0x02 // Mode 02 "freeze frame data" (8 bit PID)
#define VEHICLE_POLL_TYPE_READ_ERDTC 0x03 // Mode 03 read emission-related DTC (no PID)
#define VEHICLE_POLL_TYPE_CLEAR_ERDTC 0x04 // Mode 04 clear/reset emission-related DTC (no PID)
#define VEHICLE_POLL_TYPE_READOXSTEST 0x05 // Mode 05 read oxygen sensor monitoring test results (16 bit PID)
#define VEHICLE_POLL_TYPE_READOBMTEST 0x06 // Mode 06 read on-board monitoring test results (8 bit PID)
#define VEHICLE_POLL_TYPE_READ_DCERDTC 0x07 // Mode 07 read driving cycle emission-related DTC (no PID)
#define VEHICLE_POLL_TYPE_REQOBUCTRL 0x08 // Mode 08 request on-board unit control (8 bit PID)
#define VEHICLE_POLL_TYPE_OBDIIVEHICLE 0x09 // Mode 09 "vehicle information" (8 bit PID)
#define VEHICLE_POLL_TYPE_READ_PERMDTC 0x0A // Mode 0A read permanent (cleared) DTC (no PID)
// UDS (ISO 14229) service identifiers supported:
#define VEHICLE_POLL_TYPE_OBDIISESSION 0x10 // UDS: Diagnostic Session Control (8 bit PID)
#define VEHICLE_POLL_TYPE_TESTERPRESENT 0x3E // UDS: TesterPresent (8 bit PID)
#define VEHICLE_POLL_TYPE_SECACCESS 0x27 // UDS: SecurityAccess (8 bit PID)
#define VEHICLE_POLL_TYPE_COMCONTROL 0x28 // UDS: CommunicationControl (8 bit PID)
#define VEHICLE_POLL_TYPE_ECURESET 0x11 // UDS: ECUReset (8 bit PID)
#define VEHICLE_POLL_TYPE_CLEARDTC 0x14 // UDS: ClearDiagnosticInformation (no PID)
#define VEHICLE_POLL_TYPE_READDTC 0x19 // UDS: ReadDTCInformation (8 bit PID)
#define VEHICLE_POLL_TYPE_OBDIIEXTENDED 0x22 // UDS: ReadDataByIdentifier (16 bit PID) (legacy alias for READDATA)
#define VEHICLE_POLL_TYPE_READDATA 0x22 // UDS: ReadDataByIdentifier (16 bit PID)
#define VEHICLE_POLL_TYPE_READMEMORY 0x23 // UDS: ReadMemoryByAddress (no PID)
#define VEHICLE_POLL_TYPE_READSCALING 0x24 // UDS: ReadScalingDataByIdentifier (16 bit PID)
#define VEHICLE_POLL_TYPE_WRITEDATA 0x2E // UDS: WriteDataByIdentifier (16 bit PID)
#define VEHICLE_POLL_TYPE_ROUTINECONTROL 0x31 // UDS: Routine Control (8 bit PID)
#define VEHICLE_POLL_TYPE_WRITEMEMORY 0x3D // UDS: WriteMemoryByAddress (8 bit PID)
#define VEHICLE_POLL_TYPE_IOCONTROL 0x2F // UDS: InputOutputControlByIdentifier (16 bit PID)
// Other service identifiers supported:
#define VEHICLE_POLL_TYPE_OBDII_18 0x18 // Custom: VW request type 18 (no PID)
#define VEHICLE_POLL_TYPE_OBDII_1A 0x1A // Custom: Mode 1A (8 bit PID)
#define VEHICLE_POLL_TYPE_OBDIIGROUP 0x21 // Custom: Read data by 8 bit PID
#define VEHICLE_POLL_TYPE_OBDII_32 0x32 // Custom: VW routine control extension (8 bit PID)
// A note on "PID" and their sizes here:
// By "PID" for the service types we mean the part of the request parameters
// after the service type that is reflected in _every_ valid response to the request.
// That part is used to validate the response by the poller, if it doesn't match,
// the response won't be forwarded to the application.
// Some requests require additional parameters as specified in ISO 14229, but implementations
// may differ. For example, a 31b8 request on a VW ECU does not necessarily copy the routine
// ID in the response (e.g. with 0000), so the routine ID isn't part of our "PID" here.
// Utils:
#define POLL_TYPE_HAS_16BIT_PID(type) \
((type) == VEHICLE_POLL_TYPE_READDATA || \
(type) == VEHICLE_POLL_TYPE_READSCALING || \
(type) == VEHICLE_POLL_TYPE_WRITEDATA || \
(type) == VEHICLE_POLL_TYPE_IOCONTROL || \
(type) == VEHICLE_POLL_TYPE_READOXSTEST)
#define POLL_TYPE_HAS_NO_PID(type) \
((type) == VEHICLE_POLL_TYPE_CLEARDTC || \
(type) == VEHICLE_POLL_TYPE_READMEMORY || \
(type) == VEHICLE_POLL_TYPE_READ_ERDTC || \
(type) == VEHICLE_POLL_TYPE_CLEAR_ERDTC || \
(type) == VEHICLE_POLL_TYPE_READ_DCERDTC || \
(type) == VEHICLE_POLL_TYPE_READ_PERMDTC || \
(type) == VEHICLE_POLL_TYPE_OBDII_18)
#define POLL_TYPE_HAS_8BIT_PID(type) \
(!POLL_TYPE_HAS_NO_PID(type) && !POLL_TYPE_HAS_16BIT_PID(type))
// OBD/UDS Negative Response Code
#define UDS_RESP_TYPE_NRC 0x7F // see ISO 14229 Annex A.1
#define UDS_RESP_NRC_RCRRP 0x78 // … requestCorrectlyReceived-ResponsePending
// Number of polling states supported
#define VEHICLE_POLL_NSTATES 4
// Macro for poll_pid_t termination
#define POLL_LIST_END { 0, 0, 0x00, 0x00, { 0, 0, 0 }, 0, 0 }
// Poll list PID xargs utility (see info above):
#define POLL_PID_DATA(pid, datastring) \
{.xargs={ (pid), POLL_TXDATA, sizeof(datastring)-1, reinterpret_cast<const uint8_t*>(datastring) }}
// PollSingleRequest specific result codes:
#define POLLSINGLE_OK 0
#define POLLSINGLE_TIMEOUT -1
#define POLLSINGLE_TXFAILURE -2
// Standard MSG protocol commands:
#define CMD_QueryFeatures 1 // ()
#define CMD_SetFeature 2 // (feature number, value)
#define CMD_QueryParams 3 // ()
#define CMD_SetParam 4 // (param number, value)
#define CMD_Reboot 5 // ()
#define CMD_Alert 6 // ()
#define CMD_Execute 7 // (text command with arguments)
#define CMD_SetChargeMode 10 // (mode)
#define CMD_StartCharge 11 // ()
#define CMD_StopCharge 12 // ()
#define CMD_SetChargeCurrent 15 // (amps)
#define CMD_SetChargeModeAndCurrent 16 // (mode, amps)
#define CMD_SetChargeTimer 17 // (mode, start time)
#define CMD_WakeupCar 18 // ()
#define CMD_WakeupTempSystem 19 // ()
#define CMD_Lock 20 // (pin)
#define CMD_ValetOn 21 // (pin)
#define CMD_UnLock 22 // (pin)
#define CMD_ValetOff 23 // (pin)
#define CMD_Homelink 24 // (button_nr)
#define CMD_CoolDown 25 // ()
#define CMD_ClimateControl 26 // (mode)
// 30-39 reserved for server commands
#define CMD_SendSMS 40 // (phone number, SMS message)
#define CMD_SendUSSD 41 // (USSD_CODE)
#define CMD_SendRawAT 49 // (raw AT command)
// 200+ reserved for custom commands
// BMS default deviation thresholds:
#define BMS_DEFTHR_VMAXGRAD 0.010 // [V]
#define BMS_DEFTHR_VMAXSDDEV 0.010 // [V]
#define BMS_DEFTHR_VWARN 0.020 // [V]
#define BMS_DEFTHR_VALERT 0.030 // [V]
#define BMS_DEFTHR_TWARN 2.00 // [°C]
#define BMS_DEFTHR_TALERT 3.00 // [°C]
// VWTP_20 channel states:
typedef enum
{
VWTP_Closed = 0, // Channel not connecting/connected
VWTP_ChannelClose, // Close request has been sent
VWTP_ChannelSetup, // Setup request has been sent
VWTP_ChannelParams, // Params request has been sent
VWTP_Idle, // Connection established, idle
VWTP_StartPoll, // Transit state: begin request transmission
VWTP_Transmit, // Request transmission phase
VWTP_Receive, // Response reception phase
VWTP_AbortXfer, // Transit state: abort request/response
} vwtp_channelstate_t;
// VWTP_20 channel:
typedef struct
{
vwtp_channelstate_t state; // VWTP channel state
canbus* bus; // CAN bus
uint16_t baseid; // Protocol base CAN MsgID (usually 0x200)
uint8_t moduleid; // Logical address (ID) of destination module
uint16_t txid; // CAN MsgID we transmit on
uint16_t rxid; // CAN MsgID we listen to
uint8_t blocksize; // Number of blocks (data frames) to send between ACKs
uint32_t acktime; // Max time [us] to wait for ACK (not yet implemented)
uint32_t septime; // Min separation time [us] between blocks (data frames)
uint32_t txseqnr; // TX packet sequence number
uint32_t rxseqnr; // RX packet sequence number
uint32_t lastused; // Timestamp of last channel access
} vwtp_channel_t;
class OvmsVehicle : public InternalRamAllocated
{
friend class OvmsVehicleFactory;
public:
OvmsVehicle();
virtual ~OvmsVehicle();
virtual const char* VehicleShortName();
virtual const char* VehicleType();
protected:
QueueHandle_t m_rxqueue;
TaskHandle_t m_rxtask;
bool m_registeredlistener;
bool m_autonotifications;
bool m_ready;
public:
canbus* m_can1;
canbus* m_can2;
canbus* m_can3;
canbus* m_can4;
private:
void VehicleTicker1(std::string event, void* data);
void VehicleConfigChanged(std::string event, void* data);
void PollerSend(bool fromTicker);
void PollerReceive(CAN_frame_t* frame, uint32_t msgid);
protected:
virtual void IncomingFrameCan1(CAN_frame_t* p_frame);
virtual void IncomingFrameCan2(CAN_frame_t* p_frame);
virtual void IncomingFrameCan3(CAN_frame_t* p_frame);
virtual void IncomingFrameCan4(CAN_frame_t* p_frame);
protected:
virtual void PollerStateTicker();
virtual void IncomingPollReply(canbus* bus, uint16_t type, uint16_t pid, uint8_t* data, uint8_t length, uint16_t mlremain);
virtual void IncomingPollError(canbus* bus, uint16_t type, uint16_t pid, uint16_t code);
protected:
int m_minsoc; // The minimum SOC level before alert
int m_minsoc_triggered; // The triggered minimum SOC level to alert at
protected:
float m_accel_refspeed; // Acceleration calculation: last speed measured (m/s)
uint32_t m_accel_reftime; // … timestamp for refspeed (ms)
float m_accel_smoothing; // … smoothing factor (samples, 0 = none, default 2.0)
void CalculateAcceleration(); // Call after ms_v_pos_speed update to derive acceleration
protected:
float m_batpwr_smoothing; // … smoothing factor (samples, 0 = none, default 2.0) …
float m_batpwr_smoothed; // … and smoothed value of ms_v_bat_power
protected:
bool m_brakelight_enable; // Regen brake light enable (default no)
int m_brakelight_port; // … MAX7317 output port number (1, 3…9, default 1 = SW_12V)
float m_brakelight_on; // … activation threshold (deceleration in m/s², default 1.3)
float m_brakelight_off; // … deactivation threshold (deceleration in m/s², default 0.7)
float m_brakelight_basepwr; // … base power area (+/- from 0 in kW, default 0)
bool m_brakelight_ignftbrk; // … ignore foot brake (default no)
uint32_t m_brakelight_start; // … activation start time
virtual void CheckBrakelight(); // … check vehicle metrics for regen braking state (override to customize)
virtual bool SetBrakelight(int on); // … hardware control method (override for non MAX7317 control)
protected:
virtual void CalculateRangeSpeed(); // Derive momentary range gain/loss speed in kph
protected:
int m_last_drivetime; // duration of current/most recent drive [s]
int m_last_parktime; // duration of current/most recent parking period [s]
int m_last_chargetime; // duration of current/most recent charge [s]
int m_last_gentime; // duration of current/most recent generator run [s]
float m_drive_startsoc; // SOC at drive start (vehicle.on)
float m_drive_startrange; // Range estimation at drive start (vehicle.on)
float m_drive_startaltitude; // Altitude at drive start (vehicle.on)
uint32_t m_drive_speedcnt; // Driving speed average data
double m_drive_speedsum; // Driving speed average data
uint32_t m_drive_accelcnt; // Driving acceleration average data
double m_drive_accelsum; // Driving acceleration average data
uint32_t m_drive_decelcnt; // Driving deceleration average data
double m_drive_decelsum; // Driving deceleration average data
double m_inv_energyused; // Driving motor energy sum
double m_inv_energyrecd; // Driving recupered energy sum
uint32_t m_inv_reftime; // last time inverter(motor) power was measured
float m_inv_refpower; // last inverter(motor) power
protected:
uint32_t m_ticker;
int m_12v_ticker;
int m_chargestate_ticker;
int m_vehicleon_ticker;
int m_vehicleoff_ticker;
int m_idle_ticker;
virtual void Ticker1(uint32_t ticker);
virtual void Ticker10(uint32_t ticker);
virtual void Ticker60(uint32_t ticker);
virtual void Ticker300(uint32_t ticker);
virtual void Ticker600(uint32_t ticker);
virtual void Ticker3600(uint32_t ticker);
protected:
virtual void NotifyChargeState();
virtual void NotifyChargeStart();
virtual void NotifyChargeTopOff();
virtual void NotifyHeatingStart();
virtual void NotifyChargeStopped();
virtual void NotifyChargeDone();
virtual void NotifyValetEnabled();
virtual void NotifyValetDisabled();
virtual void NotifyValetHood();
virtual void NotifyValetTrunk();
virtual void NotifyAlarmSounding();
virtual void NotifyAlarmStopped();
virtual void Notify12vCritical();
virtual void Notify12vRecovered();
virtual void NotifyMinSocCritical();
virtual void NotifyVehicleIdling();
virtual void NotifyVehicleOn();
virtual void NotifyVehicleOff();
protected:
virtual void NotifyGenState();
protected:
virtual void NotifyGridLog();
virtual void NotifyTripLog();
virtual void NotifyTripReport();
protected:
virtual int GetNotifyVehicleStateDelay(const std::string& state) { return 3; }
virtual int GetNotifyChargeStateDelay(const char* state) { return 3; }
protected:
virtual void NotifiedVehicleOn() {}
virtual void NotifiedVehicleOff() {}
virtual void NotifiedVehicleAwake() {}
virtual void NotifiedVehicleAsleep() {}
virtual void NotifiedVehicleChargeStart() {}
virtual void NotifiedVehicleChargeStop() {}
virtual void NotifiedVehicleChargePrepare() {}
virtual void NotifiedVehicleChargeFinish() {}
virtual void NotifiedVehicleChargePilotOn() {}
virtual void NotifiedVehicleChargePilotOff() {}
virtual void NotifiedVehicleChargeTimermodeOn() {}
virtual void NotifiedVehicleChargeTimermodeOff() {}
virtual void NotifiedVehicleAux12vOn() {}
virtual void NotifiedVehicleAux12vOff() {}
virtual void NotifiedVehicleCharge12vStart() {}
virtual void NotifiedVehicleCharge12vStop() {}
virtual void NotifiedVehicleLocked() {}
virtual void NotifiedVehicleUnlocked() {}
virtual void NotifiedVehicleValetOn() {}
virtual void NotifiedVehicleValetOff() {}
virtual void NotifiedVehicleHeadlightsOn() {}
virtual void NotifiedVehicleHeadlightsOff() {}
virtual void NotifiedVehicleAlarmOn() {}
virtual void NotifiedVehicleAlarmOff() {}
virtual void NotifiedVehicleGear(int gear) {}
virtual void NotifiedVehicleDrivemode(int drivemode) {}
virtual void NotifiedVehicleChargeMode(const char* m) {}
virtual void NotifiedVehicleChargeState(const char* s) {}
virtual void NotifiedVehicleGenState(const std::string& state) {}
protected:
virtual void ConfigChanged(OvmsConfigParam* param);
virtual void MetricModified(OvmsMetric* metric);
virtual void CalculateEfficiency();
public:
#ifdef CONFIG_OVMS_COMP_WEBSERVER
virtual void GetDashboardConfig(DashboardConfig& cfg);
#endif // #ifdef CONFIG_OVMS_COMP_WEBSERVER
virtual void Status(int verbosity, OvmsWriter* writer);
protected:
void RegisterCanBus(int bus, CAN_mode_t mode, CAN_speed_t speed, dbcfile* dbcfile = NULL);
bool PinCheck(char* pin);
public:
virtual void RxTask();
public:
typedef enum
{
NotImplemented = 0,
Success,
Fail
} vehicle_command_t;
typedef enum
{
Standard = 0,
Storage = 1,
Range = 3,
Performance = 4
} vehicle_mode_t;
public:
vehicle_mode_t VehicleModeKey(const std::string code);
public:
virtual vehicle_command_t CommandSetChargeMode(vehicle_mode_t mode);
virtual vehicle_command_t CommandSetChargeCurrent(uint16_t limit);
virtual vehicle_command_t CommandStartCharge();
virtual vehicle_command_t CommandStopCharge();
virtual vehicle_command_t CommandSetChargeTimer(bool timeron, uint16_t timerstart);
virtual vehicle_command_t CommandCooldown(bool cooldownon);
virtual vehicle_command_t CommandWakeup();
virtual vehicle_command_t CommandClimateControl(bool enable);
virtual vehicle_command_t CommandLock(const char* pin);
virtual vehicle_command_t CommandUnlock(const char* pin);
virtual vehicle_command_t CommandActivateValet(const char* pin);
virtual vehicle_command_t CommandDeactivateValet(const char* pin);
virtual vehicle_command_t CommandHomelink(int button, int durationms=1000);
#ifdef CONFIG_OVMS_COMP_TPMS
public:
virtual bool TPMSRead(std::vector<uint32_t> *tpms);
virtual bool TPMSWrite(std::vector<uint32_t> &tpms);
#endif // #ifdef CONFIG_OVMS_COMP_TPMS
public:
virtual std::vector<std::string> GetTpmsLayout();
protected:
uint32_t m_tpms_lastcheck; // monotonictime of last TPMS alert check
std::vector<short> m_tpms_laststate; // last TPMS alert state for change detection
protected:
virtual void NotifyTpmsAlerts();
public:
virtual vehicle_command_t CommandStat(int verbosity, OvmsWriter* writer);
virtual vehicle_command_t CommandStatTrip(int verbosity, OvmsWriter* writer);
virtual vehicle_command_t ProcessMsgCommand(std::string &result, int command, const char* args);
public:
virtual bool SetFeature(int key, const char* value);
virtual const std::string GetFeature(int key);
public:
typedef struct
{
uint32_t txmoduleid; // transmission CAN ID (address), 0x7df = OBD2 broadcast
uint32_t rxmoduleid; // expected response CAN ID or 0 for broadcasts
uint16_t type; // UDS poll type / OBD2 "mode", see VEHICLE_POLL_TYPE_…
union
{
Revert back to unit16 PID like original, misinterpreted addresses
2022-04-12 17:53:42 +00:00
uint16_t pid; // PID (shortcut for requests w/o payload)
Initial commit, fork from original Project
2022-04-05 22:04:46 +00:00
struct
{
uint16_t pid; // PID for requests with additional payload
uint8_t datalen; // payload length (bytes)
uint8_t data[6]; // inline payload data (single frame request)
} args;
struct
{
uint16_t pid; // PID for requests with additional payload
uint8_t tag; // needs to be POLL_TXDATA
uint16_t datalen; // payload length (bytes, max 4095)
const uint8_t* data; // pointer to payload data (single/multi frame request)
} xargs;
};
uint16_t polltime[VEHICLE_POLL_NSTATES]; // poll intervals in seconds for used poll states
uint8_t pollbus; // 0 = default CAN bus from PollSetPidList(), 1…4 = specific
uint8_t protocol; // ISOTP_STD / ISOTP_EXTADR / ISOTP_EXTFRAME / VWTP_20
} poll_pid_t;
protected:
OvmsRecMutex m_poll_mutex; // Concurrency protection for recursive calls
uint8_t m_poll_state; // Current poll state
canbus* m_poll_bus; // Bus to poll on
canbus* m_poll_bus_default; // Bus default to poll on
const poll_pid_t* m_poll_plist; // Head of poll list
const poll_pid_t* m_poll_plcur; // Poll list loop cursor
poll_pid_t m_poll_entry; // Currently processed entry of poll list (copy)
uint32_t m_poll_ticker; // Polling ticker
uint8_t m_poll_protocol; // ISOTP_STD / ISOTP_EXTADR / ISOTP_EXTFRAME / VWTP_20
uint32_t m_poll_moduleid_sent; // ModuleID last sent
uint32_t m_poll_moduleid_low; // Expected response moduleid low mark
uint32_t m_poll_moduleid_high; // Expected response moduleid high mark
uint16_t m_poll_type; // Expected type
uint16_t m_poll_pid; // Expected PID
const uint8_t* m_poll_tx_data; // Payload data for multi frame request
uint16_t m_poll_tx_remain; // Payload bytes remaining for multi frame request
uint16_t m_poll_tx_offset; // Payload offset of multi frame request
uint16_t m_poll_tx_frame; // Frame number for multi frame request
uint16_t m_poll_ml_remain; // Bytes remaining for multi frame response
uint16_t m_poll_ml_offset; // Offset of multi frame response
uint16_t m_poll_ml_frame; // Frame number for multi frame response
uint8_t m_poll_wait; // Wait counter for a reply from a sent poll or bytes remaining.
// Gets set = 2 when a poll is sent OR when bytes are remaining after receiving.
// Gets set = 0 when a poll is received.
// Gets decremented with every second/tick in PollerSend().
// PollerSend() aborts when > 0.
// Why set = 2: When a poll gets send just before the next ticker occurs
// PollerSend() decrements to 1 and doesn't send the next poll.
// Only when the reply doesn't get in until the next ticker occurs
// PollserSend() decrements to 0 and abandons the outstanding reply (=timeout)
private:
uint8_t m_poll_sequence_max; // Polls allowed to be sent in sequence per time tick (second), default 1, 0 = no limit
uint8_t m_poll_sequence_cnt; // Polls already sent in the current time tick (second)
uint8_t m_poll_fc_septime; // Flow control separation time for multi frame responses
uint16_t m_poll_ch_keepalive; // Seconds to keep an inactive channel (e.g. VWTP) alive (default: 60)
private:
OvmsRecMutex m_poll_single_mutex; // PollSingleRequest() concurrency protection
std::string* m_poll_single_rxbuf; // … response buffer
int m_poll_single_rxerr; // … response error code (NRC) / TX failure code
OvmsSemaphore m_poll_single_rxdone; // … response done (ok/error)
protected:
vwtp_channel_t m_poll_vwtp; // VWTP channel state
protected:
void PollSetPidList(canbus* bus, const poll_pid_t* plist);
void PollSetState(uint8_t state);
void PollSetThrottling(uint8_t sequence_max);
void PollSetResponseSeparationTime(uint8_t septime);
void PollSetChannelKeepalive(uint16_t keepalive_seconds);
int PollSingleRequest(canbus* bus, uint32_t txid, uint32_t rxid,
std::string request, std::string& response,
int timeout_ms=3000, uint8_t protocol=ISOTP_STD);
int PollSingleRequest(canbus* bus, uint32_t txid, uint32_t rxid,
uint8_t polltype, uint16_t pid, std::string& response,
int timeout_ms=3000, uint8_t protocol=ISOTP_STD);
const char* PollResultCodeName(int code);
private:
void PollerISOTPStart(bool fromTicker);
bool PollerISOTPReceive(CAN_frame_t* frame, uint32_t msgid);
private:
void PollerVWTPStart(bool fromTicker);
bool PollerVWTPReceive(CAN_frame_t* frame, uint32_t msgid);
void PollerVWTPEnter(vwtp_channelstate_t state);
void PollerVWTPTicker();
void PollerVWTPTxCallback(const CAN_frame_t* frame, bool success);
private:
CanFrameCallback m_poll_txcallback; // Poller CAN TxCallback
uint32_t m_poll_txmsgid; // Poller last TX CAN ID (frame MsgID)
private:
void PollerTxCallback(const CAN_frame_t* frame, bool success);
protected:
virtual void IncomingPollTxCallback(canbus* bus, uint32_t txid, uint16_t type, uint16_t pid, bool success);
// BMS helpers
protected:
float* m_bms_voltages; // BMS voltages (current value)
float* m_bms_vmins; // BMS minimum voltages seen (since reset)
float* m_bms_vmaxs; // BMS maximum voltages seen (since reset)
float* m_bms_vdevmaxs; // BMS maximum voltage deviations seen (since reset)
short* m_bms_valerts; // BMS voltage deviation alerts (since reset)
int m_bms_valerts_new; // BMS new voltage alerts since last notification
int m_bms_vstddev_cnt; // BMS internal stddev counter
float m_bms_vstddev_avg; // BMS internal stddev average
bool m_bms_has_voltages; // True if BMS has a complete set of voltage values
float* m_bms_temperatures; // BMS temperatures (celcius current value)
float* m_bms_tmins; // BMS minimum temperatures seen (since reset)
float* m_bms_tmaxs; // BMS maximum temperatures seen (since reset)
float* m_bms_tdevmaxs; // BMS maximum temperature deviations seen (since reset)
short* m_bms_talerts; // BMS temperature deviation alerts (since reset)
int m_bms_talerts_new; // BMS new temperature alerts since last notification
bool m_bms_has_temperatures; // True if BMS has a complete set of temperature values
std::vector<bool> m_bms_bitset_v; // BMS tracking: true if corresponding voltage set
std::vector<bool> m_bms_bitset_t; // BMS tracking: true if corresponding temperature set
int m_bms_bitset_cv; // BMS tracking: count of unique voltage values set
int m_bms_bitset_ct; // BMS tracking: count of unique temperature values set
int m_bms_readings_v; // Number of BMS voltage readings expected
int m_bms_readingspermodule_v; // Number of BMS voltage readings per module
int m_bms_readings_t; // Number of BMS temperature readings expected
int m_bms_readingspermodule_t; // Number of BMS temperature readings per module
float m_bms_limit_tmin; // Minimum temperature limit (for sanity checking)
float m_bms_limit_tmax; // Maximum temperature limit (for sanity checking)
float m_bms_limit_vmin; // Minimum voltage limit (for sanity checking)
float m_bms_limit_vmax; // Maximum voltage limit (for sanity checking)
float m_bms_defthr_vmaxgrad; // Default voltage deviation max valid gradient [V]
float m_bms_defthr_vmaxsddev; // Default voltage deviation max valid stddev deviation [V]
float m_bms_defthr_vwarn; // Default voltage deviation warn threshold [V]
float m_bms_defthr_valert; // Default voltage deviation alert threshold [V]
float m_bms_defthr_twarn; // Default temperature deviation warn threshold [°C]
float m_bms_defthr_talert; // Default temperature deviation alert threshold [°C]
uint32_t m_bms_vlog_last; // Last log time for voltages
uint32_t m_bms_tlog_last; // Last log time for temperatures
protected:
void BmsSetCellArrangementVoltage(int readings, int readingspermodule);
void BmsSetCellArrangementTemperature(int readings, int readingspermodule);
void BmsSetCellDefaultThresholdsVoltage(float warn, float alert, float maxgrad=-1, float maxsddev=-1);
void BmsSetCellDefaultThresholdsTemperature(float warn, float alert);
void BmsSetCellLimitsVoltage(float min, float max);
void BmsSetCellLimitsTemperature(float min, float max);
void BmsSetCellVoltage(int index, float value);
void BmsResetCellVoltages(bool full = false);
void BmsSetCellTemperature(int index, float value);
void BmsResetCellTemperatures(bool full = false);
void BmsRestartCellVoltages();
void BmsRestartCellTemperatures();
void BmsTicker();
virtual void NotifyBmsAlerts();
public:
int BmsGetCellArangementVoltage(int* readings=NULL, int* readingspermodule=NULL);
int BmsGetCellArangementTemperature(int* readings=NULL, int* readingspermodule=NULL);
void BmsGetCellDefaultThresholdsVoltage(float* warn, float* alert, float* maxgrad=NULL, float* maxsddev=NULL);
void BmsGetCellDefaultThresholdsTemperature(float* warn, float* alert);
void BmsResetCellStats();
virtual void BmsStatus(int verbosity, OvmsWriter* writer);
virtual bool FormatBmsAlerts(int verbosity, OvmsWriter* writer, bool show_warnings);
};
template<typename Type> OvmsVehicle* CreateVehicle()
{
return new Type;
}
class OvmsVehicleFactory
{
public:
OvmsVehicleFactory();
~OvmsVehicleFactory();
public:
typedef OvmsVehicle* (*FactoryFuncPtr)();
typedef struct
{
FactoryFuncPtr construct;
const char* name;
} vehicle_t;
typedef CNameMap<vehicle_t> map_vehicle_t;
OvmsVehicle *m_currentvehicle;
std::string m_currentvehicletype;
map_vehicle_t m_vmap;
public:
template<typename Type>
short RegisterVehicle(const char* VehicleType, const char* VehicleName = "")
{
FactoryFuncPtr function = &CreateVehicle<Type>;
m_vmap.insert(std::make_pair(VehicleType, (vehicle_t){ function, VehicleName }));
return 0;
};
OvmsVehicle* NewVehicle(const char* VehicleType);
void ClearVehicle();
void SetVehicle(const char* type);
void AutoInit();
OvmsVehicle* ActiveVehicle();
const char* ActiveVehicleType();
const char* ActiveVehicleName();
const char* ActiveVehicleShortName();
// Shell commands:
protected:
static int vehicle_validate(OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv, bool complete);
static void vehicle_module(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv);
static void vehicle_list(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv);
static void vehicle_status(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv);
static void vehicle_wakeup(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv);
static void vehicle_homelink(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv);
static void vehicle_climatecontrol(int verbosity, OvmsWriter* writer, bool on);
static void vehicle_climatecontrol_on(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv);
static void vehicle_climatecontrol_off(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv);
static void vehicle_lock(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv);
static void vehicle_unlock(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv);
static void vehicle_valet(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv);
static void vehicle_unvalet(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv);
static void vehicle_charge_mode(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv);
static void vehicle_charge_current(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv);
static void vehicle_charge_start(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv);
static void vehicle_charge_stop(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv);
static void vehicle_charge_cooldown(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv);
static void vehicle_stat(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv);
static void vehicle_stat_trip(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv);
static void bms_status(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv);
static void bms_reset(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv);
static void bms_alerts(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv);
static void obdii_request(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv);
#ifdef CONFIG_OVMS_SC_JAVASCRIPT_DUKTAPE
protected:
static duk_ret_t DukOvmsVehicleType(duk_context *ctx);
static duk_ret_t DukOvmsVehicleWakeup(duk_context *ctx);
static duk_ret_t DukOvmsVehicleHomelink(duk_context *ctx);
static duk_ret_t DukOvmsVehicleClimateControl(duk_context *ctx);
static duk_ret_t DukOvmsVehicleLock(duk_context *ctx);
static duk_ret_t DukOvmsVehicleUnlock(duk_context *ctx);
static duk_ret_t DukOvmsVehicleValet(duk_context *ctx);
static duk_ret_t DukOvmsVehicleUnvalet(duk_context *ctx);
static duk_ret_t DukOvmsVehicleSetChargeMode(duk_context *ctx);
static duk_ret_t DukOvmsVehicleSetChargeCurrent(duk_context *ctx);
static duk_ret_t DukOvmsVehicleSetChargeTimer(duk_context *ctx);
static duk_ret_t DukOvmsVehicleStartCharge(duk_context *ctx);
static duk_ret_t DukOvmsVehicleStopCharge(duk_context *ctx);
static duk_ret_t DukOvmsVehicleStartCooldown(duk_context *ctx);
static duk_ret_t DukOvmsVehicleStopCooldown(duk_context *ctx);
static duk_ret_t DukOvmsVehicleObdRequest(duk_context *ctx);
#endif // CONFIG_OVMS_SC_JAVASCRIPT_DUKTAPE
};
extern OvmsVehicleFactory MyVehicleFactory;
#endif //#ifndef __VEHICLE_H__
Reference in a new issue Copy permalink