Skip to content
Permalink
master
Switch branches/tags

Name already in use

A tag already exists with the provided branch name. Many Git commands accept both tag and branch names, so creating this branch may cause unexpected behavior. Are you sure you want to create this branch?
Go to file
 
 
Cannot retrieve contributors at this time
#include "obd2.h"
#include "can/canutil.h"
#include "util/timer.h"
#include "util/log.h"
#include "shared_handlers.h"
#include "config.h"
#include <limits.h>
namespace time = openxc::util::time;
using openxc::util::log::debug;
using openxc::diagnostics::DiagnosticsManager;
using openxc::diagnostics::ActiveDiagnosticRequest;
using openxc::config::getConfiguration;
using openxc::config::PowerManagement;
using openxc::config::RunLevel;
#define ENGINE_SPEED_PID 0xc
#define VEHICLE_SPEED_PID 0xd
static bool ENGINE_STARTED = false;
static bool VEHICLE_IN_MOTION = false;
static openxc::util::time::FrequencyClock IGNITION_STATUS_TIMER = {0.5, 0, NULL};
/* Private: A representation of an OBD-II PID.
*
* pid - The 1 byte PID.
* name - A human readable name to use for this PID when published.
* frequency - The frequency to request this PID if supported by the vehicle
* when automatic, recurring OBD-II requests are enabled.
*/
typedef struct {
uint8_t pid;
const char* name;
float frequency;
} Obd2Pid;
/* Private: Pre-defined OBD-II PIDs to query for if supported by the vehicle.
*/
const Obd2Pid OBD2_PIDS[] = {
{ pid: ENGINE_SPEED_PID, name: "engine_speed", frequency: 5 },
{ pid: VEHICLE_SPEED_PID, name: "vehicle_speed", frequency: 5 },
{ pid: 0x4, name: "engine_load", frequency: 5 },
{ pid: 0x5, name: "engine_coolant_temperature", frequency: 1 },
{ pid: 0x33, name: "barometric_pressure", frequency: 1 },
{ pid: 0x4c, name: "commanded_throttle_position", frequency: 1 },
{ pid: 0x27, name: "fuel_level", frequency: 1 },
{ pid: 0xf, name: "intake_air_temperature", frequency: 1 },
{ pid: 0xb, name: "intake_manifold_pressure", frequency: 1 },
{ pid: 0x1f, name: "running_time", frequency: 1 },
{ pid: 0x11, name: "throttle_position", frequency: 5 },
{ pid: 0xa, name: "fuel_pressure", frequency: 1 },
{ pid: 0x10, name: "mass_airflow", frequency: 5 },
{ pid: 0x5a, name: "accelerator_pedal_position", frequency: 5 },
{ pid: 0x52, name: "ethanol_fuel_percentage", frequency: 1 },
{ pid: 0x5c, name: "engine_oil_temperature", frequency: 1 },
{ pid: 0x63, name: "engine_torque", frequency: 1 },
};
static void checkIgnitionStatus(DiagnosticsManager* manager,
const ActiveDiagnosticRequest* request,
const DiagnosticResponse* response,
float parsedPayload) {
bool match = false;
if(response->pid == ENGINE_SPEED_PID) {
match = ENGINE_STARTED = parsedPayload != 0;
} else if(response->pid == VEHICLE_SPEED_PID) {
match = VEHICLE_IN_MOTION = parsedPayload != 0;
}
if(match) {
time::tick(&IGNITION_STATUS_TIMER);
}
}
static void requestIgnitionStatus(DiagnosticsManager* manager) {
if(manager->obd2Bus != NULL && (getConfiguration()->powerManagement ==
PowerManagement::OBD2_IGNITION_CHECK ||
getConfiguration()->recurringObd2Requests)) {
debug("Sending requests to check ignition status");
DiagnosticRequest request = {arbitration_id: OBD2_FUNCTIONAL_BROADCAST_ID,
mode: 0x1, has_pid: true, pid: ENGINE_SPEED_PID};
addRequest(manager, manager->obd2Bus, &request, "engine_speed", false,
NULL, checkIgnitionStatus);
request.pid = VEHICLE_SPEED_PID;
addRequest(manager, manager->obd2Bus, &request, "vehicle_speed", false,
NULL, checkIgnitionStatus);
time::tick(&IGNITION_STATUS_TIMER);
}
}
static void checkSupportedPids(DiagnosticsManager* manager,
const ActiveDiagnosticRequest* request,
const DiagnosticResponse* response,
float parsedPayload) {
if(manager->obd2Bus == NULL || !getConfiguration()->recurringObd2Requests) {
return;
}
debug("%s", "Querying for supported PIDs from vehicle");
for(int i = 0; i < response->payload_length; i++) {
for(int j = CHAR_BIT - 1; j >= 0; j--) {
if(response->payload[i] >> j & 0x1) {
uint16_t pid = response->pid + (i * CHAR_BIT) + j + 1;
debug("Vehicle supports PID 0x%02x", pid);
for(size_t i = 0; i < sizeof(OBD2_PIDS) / sizeof(Obd2Pid); i++) {
if(OBD2_PIDS[i].pid == pid) {
debug("Automatically adding recurring request for PID 0x%x", pid);
DiagnosticRequest request = {
arbitration_id: OBD2_FUNCTIONAL_BROADCAST_ID,
mode: 0x1, has_pid: true, pid: pid};
addRecurringRequest(manager, manager->obd2Bus, &request,
OBD2_PIDS[i].name, false,
openxc::diagnostics::obd2::handleObd2Pid,
checkIgnitionStatus, OBD2_PIDS[i].frequency);
break;
}
}
}
}
}
}
void openxc::diagnostics::obd2::initialize(DiagnosticsManager* manager) {
requestIgnitionStatus(manager);
}
// * CAN traffic will eventualy stop, and we will suspend.
// * When do we wake up?
// * If normal CAN is open, bus activity will wake us up and we will resume.
// * If normal CAN is blocked, we rely on a watchdog to wake us up every 15
// seconds to start this process over again.
void openxc::diagnostics::obd2::loop(DiagnosticsManager* manager) {
static bool pidSupportQueried = false;
const int MAX_IGNITION_CHECK_COUNT = 3;
static int ignitionCheckCount = 0;
if(!manager->initialized || manager->obd2Bus == NULL) {
return;
}
if(time::elapsed(&IGNITION_STATUS_TIMER, false)) {
if(ignitionCheckCount >= MAX_IGNITION_CHECK_COUNT &&
getConfiguration()->powerManagement ==
PowerManagement::OBD2_IGNITION_CHECK) {
debug("Ignition appears to be off - reducing frequency of ignition checks");
diagnostics::reset(manager);
// Don't stop sending requests altogether, because if the CAN bus is still
// active we want to keep querying for ignition. If we stop sending
// ignition checks here we risk getting stuck awake, but not querying
// for any diagnostics messages. Additionally the time between ignition checks
// must be larger than the CAN_ACTIVE_TIMEOUT, otherwise we'll never suspend
// even if the CAN bus goes inactive.
IGNITION_STATUS_TIMER.frequency = 1.0 / (openxc::can::CAN_ACTIVE_TIMEOUT_S + 5);
ignitionCheckCount = 0;
pidSupportQueried = false;
} else {
// We haven't received an ignition in 5 seconds. Either the user didn't
// have either OBD-II request configured as a recurring request (which
// is fine) or they did, but the car stopped responding. Kick off
// another request to see which is true. It will take 5+5 seconds after
// ignition off to decide we should cancel all outstanding requests.
requestIgnitionStatus(manager);
++ignitionCheckCount;
}
} else if(ENGINE_STARTED || VEHICLE_IN_MOTION) {
IGNITION_STATUS_TIMER.frequency = 0.5;
ignitionCheckCount = 0;
getConfiguration()->desiredRunLevel = RunLevel::ALL_IO;
if(getConfiguration()->recurringObd2Requests && !pidSupportQueried) {
debug("Ignition is on - querying for supported OBD-II PIDs");
pidSupportQueried = true;
DiagnosticRequest request = {
arbitration_id: OBD2_FUNCTIONAL_BROADCAST_ID,
mode: 0x1,
has_pid: true,
pid: 0x0};
for(int i = 0x0; i <= 0x80; i += 0x20) {
request.pid = i;
addRequest(manager, manager->obd2Bus, &request, NULL, false,
NULL, checkSupportedPids);
}
}
}
}
bool openxc::diagnostics::obd2::isObd2Request(DiagnosticRequest* request) {
return request->mode == 0x1 && request->pid < 0xff;
}
void openxc::diagnostics::obd2::handleObd2Pid(
const DiagnosticResponse* response, float parsedPayload, char* str_buf, int buf_size) {
snprintf(str_buf, buf_size, "%f", diagnostic_decode_obd2_pid(response));
}