I have a simple sketch that query for RPM. Its been working days before, but now photon crashes when executes Carloop.begin() (if I remove the line , the photon works good, but no obd readings).
Is there any known issue related to that behaviour ?
Thanks
There are no known issues with the Carloop library.
There are also no known issues running Carloop applications on Photons or Electrons that have up-to-date system firmware. Make sure the system firmware on your device is up-to-date. (Particle just released new system firmware in the last week.)
Besides that, there are quite a number of things that need special attention when you write your application firmware.
To figure out what is likely, we need some more information from you.
First, it will be necessary to share your code so we can review it and spot any issues there.
Also, we have to ask you what you actually mean when the photon crashes. Do you mean that it resets, or becomes unresponsive, or Red Flash SOS, or …?
Please consult this section of the documentation (for the Photon) to help in accurately describing the behaviour:
https://docs.particle.io/guide/getting-started/modes/photon/#troubleshooting-modes
I’m sorry about missing important things:
The code is
#include "carloop.h"
#include "base85.h"
SYSTEM_MODE(SEMI_AUTOMATIC);
SYSTEM_THREAD(ENABLED);
void sendObdRequest();
void waitForObdResponse();
void delayUntilNextRequest();
void printValuesAtInterval();
void publishValuesAtInterval();
void printValues();
String dumpMessage(const CANMessage &message);
bool byteArray8Equal(uint8_t a1[8], uint8_t a2[8]);
Carloop<CarloopRevision2> carloop;
int canMessageCount = 0;
///////////////////////////////////////////////////////////////////////////
//GLOBAL INTEGERS FOR USE IN PERFORMING MATH AND EXTRACTION OF OBDII DATA//
///////////////////////////////////////////////////////////////////////////
int data0;
int data1;
int data2;
int data3;
int data4;
int data5;
int data6;
int data7;
int PID_Array[] = {data3, data4, data5, data6};
int AvailablePID_1_20[32];
int AvailablePID_21_40[32];
int AvailablePID_41_60[32];
int AvailablePID_61_80[32];
// OBD CAN MESSAGE IDs
const auto OBD_CAN_BROADCAST_ID = 0X7DF;
const auto OBD_CAN_REQUEST_ID = 0x7E0;
const auto OBD_CAN_REPLY_ID_MIN = 0x7E8;
const auto OBD_CAN_REPLY_ID_MAX = 0x7EF;
// OBD MODES
const auto OBD_MODE_CURRENT_DATA = 0x01;
///////////////////////////////////////////////////////////////////////////////
//LIST OF ALL MODE 1 AVAILABLE PIDS POLLING. NOT ALL MAY BE AVAILABLE TO YOU.//
///////////////////////////////////////////////////////////////////////////////
const auto OBD_PID_SUPPORTED_PIDS_01_20 = 0x00;
const auto OBD_PID_SUPPORTED_PIDS_21_40 = 0x20;
const auto OBD_PID_SUPPORTED_PIDS_41_60 = 0x40;
const auto OBD_PID_SUPPORTED_PIDS_61_80 = 0x60;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
//SUM THE TOTAL AMOUNT OF PIDS YOU WOULD LIKE TO REQUEST AND PLACE THAT IN const size_t NUM_PIDS_TO_REQUEST//
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
const size_t NUM_PIDS_TO_REQUEST = 4;
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//COMMENT OUT OR REMOVE THE PIDS THAT YOU DO NOT HAVE TO INCREASE EFFECIENCY BUT BE SURE TO UPDATE THE ABOVE CONSTANT//
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const uint8_t pidsToRequest[NUM_PIDS_TO_REQUEST] = {
OBD_PID_SUPPORTED_PIDS_01_20,
OBD_PID_SUPPORTED_PIDS_21_40,
OBD_PID_SUPPORTED_PIDS_41_60,
OBD_PID_SUPPORTED_PIDS_61_80
};
uint8_t pidIndex = NUM_PIDS_TO_REQUEST - 1;
String dumpForPublish;
auto *obdLoopFunction = sendObdRequest;
unsigned long transitionTime = 0;
uint8_t lastMessageData[8];
void setup() {
Serial.begin(9600);
carloop.begin();
Particle.connect();
transitionTime = millis();
}
void loop() {
carloop.update();
printValuesAtInterval();
obdLoopFunction();
waitForObdResponse();
math();
}
/*************** Begin: OBD Loop Functions ****************/
void sendObdRequest() {
pidIndex = (pidIndex + 1) % NUM_PIDS_TO_REQUEST;
CANMessage message;
message.id = OBD_CAN_BROADCAST_ID;
message.len = 8; // just always use 8
message.data[0] = 0x02; // 0 = single-frame format, 2 = num data bytes
message.data[1] = OBD_MODE_CURRENT_DATA; // OBD MODE
message.data[2] = pidsToRequest[pidIndex]; // OBD PID
carloop.can().transmit(message);
obdLoopFunction = waitForObdResponse;
transitionTime = millis();
}
void waitForObdResponse() {
if (millis() - transitionTime >= 10) {
obdLoopFunction = delayUntilNextRequest;
transitionTime = millis();
return;
}
bool responseReceived = false;
String dump;
CANMessage message;
while (carloop.can().receive(message)) {
canMessageCount++;
if (message.id == 0x130) {
if (!byteArray8Equal(message.data, lastMessageData)) {
memcpy(lastMessageData, message.data, 8);
}
} else {
if (message.id >= OBD_CAN_REPLY_ID_MIN &&
message.id <= OBD_CAN_REPLY_ID_MAX &&
message.data[2] == pidsToRequest[pidIndex]) {
responseReceived = true;
//Serial.println("response recieved");
data0 = message.data[0];
data1 = message.data[1];
data2 = message.data[2];
data3 = message.data[3];
data4 = message.data[4];
data5 = message.data[5];
data6 = message.data[6];
data7 = message.data[7];
PID_Array[0] = message.data[3];
PID_Array[1] = message.data[4];
PID_Array[2] = message.data[5];
PID_Array[3] = message.data[6];
return;
}
return;
}
return;
}
}
void delayUntilNextRequest() {
if (millis() - transitionTime >= 8) {
obdLoopFunction = sendObdRequest;
transitionTime = millis();
}
}
/*************** End: OBD Loop Functions ****************/
void printValuesAtInterval() {
static const unsigned long interval = 10000;
static unsigned long lastDisplay = 0;
if (millis() - lastDisplay < interval) {
return;
}
lastDisplay = millis();
printValues();
}
void printValues() {
//PIDs 1-20 in HEX
Serial.println("**************Printing PIDs 0-20 (HEXIDECIMAL)**************");
if (AvailablePID_1_20[7] == true) {
Serial.println("Monitor status since DTCs cleared");
}
if (AvailablePID_1_20[6] == true) {
Serial.println("Freeze DTC");
}
if (AvailablePID_1_20[5] == true) {
Serial.println("Fuel system status");
}
if (AvailablePID_1_20[4] == true) {
Serial.println("Calculated engine load");
}
if (AvailablePID_1_20[3] == true) {
Serial.println("Engine coolant temperature");
}
if (AvailablePID_1_20[2] == true) {
Serial.println("Short term fuel trim Bank 1");
}
if (AvailablePID_1_20[1] == true) {
Serial.println("Long term fuel trim Bank 1");
}
if (AvailablePID_1_20[0] == true) {
Serial.println("Short term fuel trim Bank 2");
}
if (AvailablePID_1_20[15] == true) {
Serial.println("Long term fuel trim Bank 2");
}
if (AvailablePID_1_20[14] == true) {
Serial.println("Fuel pressure");
}
if (AvailablePID_1_20[13] == true) {
Serial.println("Intake manifold absolute pressure");
}
if (AvailablePID_1_20[12] == true) {
Serial.println("Engine RPM");
}
if (AvailablePID_1_20[11] == true) {
Serial.println("Vehicle speed");
}
if (AvailablePID_1_20[10] == true) {
Serial.println("Timing advance");
}
if (AvailablePID_1_20[9] == true) {
Serial.println("Intake air temperature");
}
if (AvailablePID_1_20[8] == true) {
Serial.println("MAF air flow rate");
}
if (AvailablePID_1_20[23] == true) {
Serial.println("Throttle position");
}
if (AvailablePID_1_20[22] == true) {
Serial.println("Commanded secondary air status");
}
if (AvailablePID_1_20[21] == true) {
Serial.println("Oxygen sensors present (in 2 banks)");
}
if (AvailablePID_1_20[20] == true) {
Serial.println("Oxygen Sensor 1 A:Voltage B:Short term fuel trim");
}
if (AvailablePID_1_20[19] == true) {
Serial.println("Oxygen Sensor 2 A:Voltage B:Short term fuel trim");
}
if (AvailablePID_1_20[18] == true) {
Serial.println("Oxygen Sensor 3 A:Voltage B:Short term fuel trim");
}
if (AvailablePID_1_20[17] == true) {
Serial.println("Oxygen Sensor 4 A:Voltage B:Short term fuel trim");
}
if (AvailablePID_1_20[16] == true) {
Serial.println("Oxygen Sensor 5 A:Voltage B:Short term fuel trim");
}
if (AvailablePID_1_20[31] == true) {
Serial.println("Oxygen Sensor 6 A:Voltage B:Short term fuel trim");
}
if (AvailablePID_1_20[30] == true) {
Serial.println("Oxygen Sensor 7 A:Voltage B:Short term fuel trim");
}
if (AvailablePID_1_20[29] == true) {
Serial.println("Oxygen Sensor 8 A:Voltage B:Short term fuel trim");
}
if (AvailablePID_1_20[28] == true) {
Serial.println("OBD standards this vehicle conforms to");
}
if (AvailablePID_1_20[27] == true) {
Serial.println("Oxygen sensors present (in 4 banks)");
}
if (AvailablePID_1_20[26] == true) {
Serial.println("Auxiliary input status");
}
if (AvailablePID_1_20[25] == true) {
Serial.println("Run time since engine start");
}
if (AvailablePID_1_20[24] == true) {
Serial.println("PIDs supported [21 - 40]");
}
//PIDs 21-40 in HEX
Serial.println("**************Printing PIDs 21-40 (HEXIDECIMAL)**************");
if (AvailablePID_21_40[7] == true) {
Serial.println("Distance traveled with malfunction indicator lamp (MIL) on");
}
if (AvailablePID_21_40[6] == true) {
Serial.println("Fuel Rail Pressure (relative to manifold vacuum)");
}
if (AvailablePID_21_40[5] == true) {
Serial.println("Fuel Rail Gauge Pressure (diesel, or gasoline direct injection)");
}
if (AvailablePID_21_40[4] == true) {
Serial.println("Oxygen Sensor 1 AB: Fuel Air Equivalence Ratio CD: Voltage");
}
if (AvailablePID_21_40[3] == true) {
Serial.println("Oxygen Sensor 2 AB: Fuel Air Equivalence Ratio CD: Voltage");
}
if (AvailablePID_21_40[2] == true) {
Serial.println("Oxygen Sensor 3 AB: Fuel Air Equivalence Ratio CD: Voltage");
}
if (AvailablePID_21_40[1] == true) {
Serial.println("Oxygen Sensor 4 AB: Fuel Air Equivalence Ratio CD: Voltage");
}
if (AvailablePID_21_40[0] == true) {
Serial.println("Oxygen Sensor 5 AB: Fuel Air Equivalence Ratio CD: Voltage");
}
if (AvailablePID_21_40[15] == true) {
Serial.println("Oxygen Sensor 6 AB: Fuel Air Equivalence Ratio CD: Voltage");
}
if (AvailablePID_21_40[14] == true) {
Serial.println("Oxygen Sensor 7 AB: Fuel Air Equivalence Ratio CD: Voltage");
}
if (AvailablePID_21_40[13] == true) {
Serial.println("Oxygen Sensor 8 AB: Fuel Air Equivalence Ratio CD: Voltage");
}
if (AvailablePID_21_40[12] == true) {
Serial.println("Commanded EGR");
}
if (AvailablePID_21_40[11] == true) {
Serial.println("EGR Error");
}
if (AvailablePID_21_40[10] == true) {
Serial.println("Commanded evaporative purge");
}
if (AvailablePID_21_40[9] == true) {
Serial.println("Fuel Tank Level Input");
}
if (AvailablePID_21_40[8] == true) {
Serial.println("Warm-ups since codes cleared");
}
if (AvailablePID_21_40[23] == true) {
Serial.println("Distance traveled since codes cleared");
}
if (AvailablePID_21_40[22] == true) {
Serial.println("Evap. System Vapor Pressure");
}
if (AvailablePID_21_40[21] == true) {
Serial.println("Absolute Barometric Pressure");
}
if (AvailablePID_21_40[20] == true) {
Serial.println("Oxygen Sensor 1 AB: Fuel Air Equivalence Ratio CD: Current");
}
if (AvailablePID_21_40[19] == true) {
Serial.println("Oxygen Sensor 2 AB: Fuel Air Equivalence Ratio CD: Current");
}
if (AvailablePID_21_40[18] == true) {
Serial.println("Oxygen Sensor 3 AB: Fuel Air Equivalence Ratio CD: Current");
}
if (AvailablePID_21_40[17] == true) {
Serial.println("Oxygen Sensor 4 AB: Fuel Air Equivalence Ratio CD: Current");
}
if (AvailablePID_21_40[16] == true) {
Serial.println("Oxygen Sensor 5 AB: Fuel Air Equivalence Ratio CD: Current");
}
if (AvailablePID_21_40[31] == true) {
Serial.println("Oxygen Sensor 6 AB: Fuel Air Equivalence Ratio CD: Current");
}
if (AvailablePID_21_40[30] == true) {
Serial.println("Oxygen Sensor 7 AB: Fuel Air Equivalence Ratio CD: Current");
}
if (AvailablePID_21_40[29] == true) {
Serial.println("Oxygen Sensor 8 AB: Fuel Air Equivalence Ratio CD: Current");
}
if (AvailablePID_21_40[28] == true) {
Serial.println("Catalyst Temperature: Bank 1, Sensor 1");
}
if (AvailablePID_21_40[27] == true) {
Serial.println("Catalyst Temperature: Bank 2, Sensor 1");
}
if (AvailablePID_21_40[26] == true) {
Serial.println("Catalyst Temperature: Bank 1, Sensor 2");
}
if (AvailablePID_21_40[25] == true) {
Serial.println("Catalyst Temperature: Bank 2, Sensor 2");
}
if (AvailablePID_21_40[24] == true) {
Serial.println("PIDs supported [41 - 60]");
}
//PIDs41-60 in HEX
Serial.println("**************Printing PIDs 41-60 (HEXIDECIMAL)**************");
if (AvailablePID_41_60[7] == true) {
Serial.println("Monitor status this drive cycle");
}
if (AvailablePID_41_60[6] == true) {
Serial.println("Control module voltage");
}
if (AvailablePID_41_60[5] == true) {
Serial.println("Absolute load value");
}
if (AvailablePID_41_60[4] == true) {
Serial.println("Fuel Air commanded equivalence ratio");
}
if (AvailablePID_41_60[3] == true) {
Serial.println("Relative throttle position");
}
if (AvailablePID_41_60[2] == true) {
Serial.println("Ambient air temperature");
}
if (AvailablePID_41_60[1] == true) {
Serial.println("Absolute throttle position B");
}
if (AvailablePID_41_60[0] == true) {
Serial.println("Absolute throttle position C");
}
if (AvailablePID_41_60[15] == true) {
Serial.println("Accelerator pedal position D");
}
if (AvailablePID_41_60[14] == true) {
Serial.println("Accelerator pedal position E");
}
if (AvailablePID_41_60[13] == true) {
Serial.println("Accelerator pedal position F");
}
if (AvailablePID_41_60[12] == true) {
Serial.println("Commanded throttle actuator");
}
if (AvailablePID_41_60[11] == true) {
Serial.println("Time run with MIL on");
}
if (AvailablePID_41_60[10] == true) {
Serial.println("Time since trouble codes cleared");
}
if (AvailablePID_41_60[9] == true) {
Serial.println("Maximum value for Fuel–Air equivalence ratio, oxygen sensor voltage, oxygen sensor current, and intake manifold absolute pressure");
}
if (AvailablePID_41_60[8] == true) {
Serial.println("Maximum value for air flow rate from mass air flow sensor");
}
if (AvailablePID_41_60[23] == true) {
Serial.println("Fuel Type");
}
if (AvailablePID_41_60[22] == true) {
Serial.println("Ethanol fuel %");
}
if (AvailablePID_41_60[21] == true) {
Serial.println("Absolute Evap system Vapor Pressure");
}
if (AvailablePID_41_60[20] == true) {
Serial.println("Evap system vapor pressure");
}
if (AvailablePID_41_60[19] == true) {
Serial.println("Short term secondary oxygen sensor trim, A: bank 1, B: bank 3");
}
if (AvailablePID_41_60[18] == true) {
Serial.println("Long term secondary oxygen sensor trim, A: bank 1, B: bank 3");
}
if (AvailablePID_41_60[17] == true) {
Serial.println("Short term secondary oxygen sensor trim, A: bank 2, B: bank 4");
}
if (AvailablePID_41_60[16] == true) {
Serial.println("Long term secondary oxygen sensor trim, A: bank 2, B: bank 4");
}
if (AvailablePID_41_60[31] == true) {
Serial.println("Fuel rail absolute pressure");
}
if (AvailablePID_41_60[30] == true) {
Serial.println("Relative accelerator pedal position");
}
if (AvailablePID_41_60[29] == true) {
Serial.println("Hybrid battery pack remaining life");
}
if (AvailablePID_41_60[28] == true) {
Serial.println("Engine oil temperature");
}
if (AvailablePID_41_60[27] == true) {
Serial.println("Fuel injection timing");
}
if (AvailablePID_41_60[26] == true) {
Serial.println("Engine fuel rate");
}
if (AvailablePID_41_60[25] == true) {
Serial.println("Emission requirements to which vehicle is designed");
}
if (AvailablePID_41_60[24] == true) {
Serial.println("PIDs supported [61 - 80]");
}
Serial.println("**************Printing PIDs 61-80 (HEXIDECIMAL)**************");
if (AvailablePID_61_80[7] == true) {
Serial.println("Driver's demand engine - percent torque");
}
if (AvailablePID_61_80[6] == true) {
Serial.println("Actual engine - percent torque");
}
if (AvailablePID_61_80[5] == true) {
Serial.println("Engine reference torque");
}
if (AvailablePID_61_80[4] == true) {
Serial.println("Engine percent torque data");
}
if (AvailablePID_61_80[3] == true) {
Serial.println("Auxiliary input / output supported");
}
if (AvailablePID_61_80[2] == true) {
Serial.println("Mass air flow sensor");
}
if (AvailablePID_61_80[1] == true) {
Serial.println("Engine coolant temperature");
}
if (AvailablePID_61_80[0] == true) {
Serial.println("Intake air temperature sensor");
}
if (AvailablePID_61_80[15] == true) {
Serial.println("Commanded EGR and EGR Error");
}
if (AvailablePID_61_80[14] == true) {
Serial.println("Commanded Diesel intake air flow control and relative intake air flow position");
}
if (AvailablePID_61_80[13] == true) {
Serial.println("Exhaust gas recirculation temperature");
}
if (AvailablePID_61_80[12] == true) {
Serial.println("Commanded throttle actuator control and relative throttle position");
}
if (AvailablePID_61_80[11] == true) {
Serial.println("Fuel pressure control system");
}
if (AvailablePID_61_80[10] == true) {
Serial.println("Injection pressure control system");
}
if (AvailablePID_61_80[9] == true) {
Serial.println("Turbocharger compressor inlet pressure");
}
if (AvailablePID_61_80[8] == true) {
Serial.println("Boost pressure control");
}
if (AvailablePID_61_80[23] == true) {
Serial.println("Variable Geometry turbo (VGT) control");
}
if (AvailablePID_61_80[22] == true) {
Serial.println("Wastegate control");
}
if (AvailablePID_61_80[21] == true) {
Serial.println("Exhaust pressure");
}
if (AvailablePID_61_80[20] == true) {
Serial.println("Turbocharger RPM");
}
if (AvailablePID_61_80[19] == true) {
Serial.println("Turbocharger temperature");
}
if (AvailablePID_61_80[18] == true) {
Serial.println("Turbocharger temperature");
}
if (AvailablePID_61_80[17] == true) {
Serial.println("Charge air cooler temperature (CACT)");
}
if (AvailablePID_61_80[16] == true) {
Serial.println("Exhaust Gas temperature (EGT) Bank 1");
}
if (AvailablePID_61_80[31] == true) {
Serial.println("Exhaust Gas temperature (EGT) Bank 2");
}
if (AvailablePID_61_80[30] == true) {
Serial.println("Diesel particulate filter (DPF)");
}
if (AvailablePID_61_80[29] == true) {
Serial.println("Diesel particulate filter (DPF)");
}
if (AvailablePID_61_80[28] == true) {
Serial.println("Diesel Particulate filter (DPF) temperature");
}
if (AvailablePID_61_80[27] == true) {
Serial.println("NOx NTE control area status");
}
if (AvailablePID_61_80[26] == true) {
Serial.println("PM NTE control area status");
}
if (AvailablePID_61_80[25] == true) {
Serial.println("Engine run time");
}
if (AvailablePID_61_80[24] == true) {
Serial.println("PIDs supported [81 - A0]");
}
}
///////////////////////////////////////
//MATH FOR DETERMINING AVAILABLE PIDS//
///////////////////////////////////////
void math() {
if (data2 == 0) {
int n = 0;
int arrayPosition = 0;
int arrayPlaceHolder = 0;
int a = 0;
for (int i = 0; i <= 31; i++) {
int x;
AvailablePID_1_20[i] = (PID_Array[arrayPosition] >> n) & 1;
n = n + 1;
arrayPlaceHolder = i;
x = arrayPlaceHolder;
if (x == 7 || x == 15 || x == 23) {
arrayPosition = arrayPosition + 1;
n = 0;
}
}
}
if (data2 == 32) {
int n = 0;
int arrayPosition = 0;
int arrayPlaceHolder = 0;
for (int i = 0; i <= 31; i++) {
int x;
AvailablePID_21_40[i] = (PID_Array[arrayPosition] >> n) & 1;
n = n+1;
arrayPlaceHolder = i;
x = arrayPlaceHolder;
if (x == 7 || x == 15 || x == 23) {
arrayPosition = arrayPosition + 1;
n = 0;
}
}
}
if (data2 == 64) {
int n = 0;
int arrayPosition = 0;
int arrayPlaceHolder = 0;
for (int i = 0; i <= 31; i++) {
int x;
AvailablePID_41_60[i] = (PID_Array[arrayPosition] >> n) & 1;
n = n+1;
arrayPlaceHolder = i;
x = arrayPlaceHolder;
if (x == 7 || x == 15 || x == 23) {
arrayPosition = arrayPosition + 1;
n = 0;
}
}
}
if (data2 == 96) {
int n = 0;
int arrayPosition = 0;
int arrayPlaceHolder = 0;
for (int i = 0; i <= 31; i++) {
int x;
AvailablePID_61_80[i] = (PID_Array[arrayPosition] >> n) & 1;
n = n+1;
arrayPlaceHolder = i;
x = arrayPlaceHolder;
if (x == 7 || x == 15 || x == 23) {
arrayPosition = arrayPosition + 1;
n = 0;
}
}
}
}
bool byteArray8Equal(uint8_t a1[8], uint8_t a2[8]) {
for (int i = 0; i < 8; i++) {
if (a1[i] != a2[i]) return false;
}
return true;
}
When my photons (Im testing on 2 photons) are powered up, the status led turns on in white for a less than a second ant then blinks in red.
Im attaching the videos of my two photons. The firmware version the photons has is 0.7.0.
The electron doesnt crash (hardware fault) but is not reading messages.
If I comment the carloop.begin() line, both photons starts but not reading.
Also, Is there any way to change the CAN pins that I want to use in electron? As far as I see, in the code is defined CAN_D1_D2 , but I want to swtich to CAN_C4_C5 in electon without modify the library. is it possible?
Thanks
Hi, same issue here. I am using the Hello World example. Put’s the photon (system firmware 0.7.0) into SOS. I am NOT connected to an OBD port - not sure if that causes it.
I just bought 2 CarLoops, got them last night, plugged into my new Photon, copy and pasted Hello World example into the WEB IDE on particle and flashed the particle. After restart, it goes right to SOS. I’m bummed out.
If I comment out carloop.begin() in setup(), it’s fine.
@stonej , As far as I know (and see), there is no needed to plug the connector to the car’s obd port to get working the code, but there is a “workaround” that at least worked for me (I dont know why).
Changed the begin call from setup to loop function as follows :
bool loaded = false;
void setup() {}
void loop() {
if(!loaded) {
carloop.begin();
loaded = true;
}
}
Worked for me in my three photons I had tested. Let me know if that solves your issue as well; if so, there is a thing that would happen (or happened).
I am experiencing the same problem and my carloop just arrived. I tried the above to no avail. Not sure if its the carloop library that’s given up the ghost with the .begin() or if its the photon firmware update.
I’m performing more test, but one of my photons is running with the issue with the change I mention, but the other boots with no problems randomly.
If found something (I hope to do quickly) I let you know guys. It is difficult to debug the firmware crashes.
@maleficarum,
Sorry, but your videos appear to me as “Error: Unsupported video type or invalid file path”
Can you please review the particle documentation and provide a full description of the behaviour.
Red blinking is not helpful to aid in determining what the problem might be.
@stonej,
You have provided slightly more information that the error mode is an SOS.
However, please indicate which SOS error code (count the number per the instructions https://docs.particle.io/guide/getting-started/modes/photon/#troubleshooting-modes). Without the code, I have no idea what the error is.
For any of you having this problem, can someone do a simple test by reverting back to system firmware 0.6.4 and see if the problem is still there or not?
carloop.begin() is needed to begin the configuration of carloop. If it is not there, or it does not work, then it makes sense that the carloop will not communicate on the CANbus. So, we have to get carloop.begin() to work.
One other thing that might be helpful is to put some debug logging (using the logger, or sending messages to the USB serial connection) into your code and then share with us just how far it gets (the code plus the debug log).
The code is defined that way to correspond with the Carloop hardware.
In theory, making this change is possible. Practically, the answer is unknown, and is not likely to be simple.
You will have to start by modifying the Carloop hardware to cut the connections to D1 & D2 and then make new connections to C4 & C5. After that, you will need to modify the Carloop library to switch the pins, or even better to make it selectable.
One thing to note is that I am not aware of anyone testing or writing firmware to use anything but the first CANbus on the Electron (the Photon has only one available in hardware). It may work or it may need changes in the Particle HAL; we will not know for sure until someone tries it.
If you do the development work, please report on it here, and also at community.particle.io.
Ok so I’m getting just 1 blink after the SOS - Hard Fault. I’m sure it’s just 1 blink, watched a few cycles through.
I also am in the same situation than @stonej . But, once I put the carloop.begin() in the loop I got my photons work “fine”. I see that the workaround is not working for the others, so there will be anything else that we’re missing (or the library is not working well in the situation we are).
I took a bit of time to review code.
In your application, you are calling carloop.begin() just before particle.connect().
carloop.begin() is pretty simple code within that function; the only call of significance is can.begin().
I am wondering if there is something in the Particle HAL that is now non-blocking in version 0.7.0 causing can.begin() to be still running (not yet completed) when particle.connect() is called. If those require the same system resources, there could be a conflict which could cause an SOS. I AM JUST GUESSING AT THIS POINT.
This might need a minimal test-case to provide to the folks at particle.
However, I am waiting on USPS to get my next development kit, so I am not able to put something together right away.
@alanm or @jvanier, do you have any thoughts on the behaviour that people are seeing?
@maleficarum, How about experimenting with a delay(100) in between carloop.begin() and particle.connect()?
You might experiment with changing the delay time to see if that has any effect. Let us know if you get better results with something like that. Giving it some extra time might give better results than repeating it many times quickly hoping that it may work.
@cyclin_al1 I already did what you suggested but I got the same result. I had added a delay(100) (and delay(1000)) between Particle.connect() and carloop.begin();
Has anyone confirmed if the problem goes away by downgrading to system firmware 0.6.4?
I am waiting for you to provide more information, or for USPS to deliver another Carloop (but they seem to have lost the package) so I can test myself?
I’m out of town right now, but as soon as I go back home Ill try with the firmware version you’re suggesting.
I’ll take a look and report back. Thanks for letting us know!
I can successfully run the “hello world” example code if I specify 0.6.3 Photon firmware. It will generate red SOS if I use 0.7.0. Specifically, I get 7 red flashes after the SOS, which means “exit”.
Same “SOS, exit” with 0.8.0-rc2 (pre-release).
@alanm, did you catch that it was not a problem with 0.6.3?
@hartmms, Thank you very much for testing that for us!
I’m still with the same issue with 0.6.2 and 0.6.4 (in electron there is no option to target the firmware to 0.6.3). But I can confirm that in photon 0.6.3 there is no error as @hartmms said .
@cyclin_al1 and @alanm Any updates on this topic? I just received two Carloops and have not yet been able to read data from my Mini Countryman using the Electron. As Particle firmware version 6.3 is no longer available, should I be using 0.64, 0.7, or something else?