ROM Comm / Mbed 2 deprecated espar_mini_control_CAN

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Dependencies:   mbed mbed-STM32F103C8T6

heatcontrol.cpp@10:a82e51837e2b, 2020-06-12 (annotated)

Committer:
lorded
Date:
Fri Jun 12 23:28:43 2020 +0000
Revision:
10:a82e51837e2b
Parent:
9:6126b83608be
Child:
11:b571de4666c9
First mini-heater firmware, accounts for altimeter.

Who changed what in which revision?

UserRevisionLine numberNew contents of line
lorded 8:2b0d18ebbba9 1 #include "mbed.h"
lorded 8:2b0d18ebbba9 2 #include "heatcontrol.h"
lorded 8:2b0d18ebbba9 3 #include "globals.h" // includes CAN2
lorded 8:2b0d18ebbba9 4 #include "espar_can.h"
lorded 8:2b0d18ebbba9 5 /******************************************************
lorded 8:2b0d18ebbba9 6 * Constants
lorded 8:2b0d18ebbba9 7 ******************************************************/
lorded 8:2b0d18ebbba9 8 //#define EASYSTARTFORMAT 1
lorded 8:2b0d18ebbba9 9 #define LIN_BAUD 1200
lorded 8:2b0d18ebbba9 10
lorded 8:2b0d18ebbba9 11 extern void DebugWrite(const char * str);
lorded 8:2b0d18ebbba9 12 extern char printbuff[256];
lorded 8:2b0d18ebbba9 13
lorded 8:2b0d18ebbba9 14 extern unsigned long lifetimer;
lorded 8:2b0d18ebbba9 15
lorded 8:2b0d18ebbba9 16 #define NOREPORTING 0
lorded 8:2b0d18ebbba9 17 #define HEATERCALLEDON 1
lorded 8:2b0d18ebbba9 18
lorded 8:2b0d18ebbba9 19 char heaterDetected = 0;
lorded 8:2b0d18ebbba9 20
lorded 8:2b0d18ebbba9 21 //const uint16_t HEATER1ID = 0x0054;
lorded 8:2b0d18ebbba9 22 //const uint16_t CTRLCHANNEL = 0x07A0;
lorded 8:2b0d18ebbba9 23 //#define EASYSTARTFORMAT
lorded 8:2b0d18ebbba9 24 #ifdef EASYSTARTFORMAT
lorded 8:2b0d18ebbba9 25 const uint16_t HEATER1ID = 0x0054; // 0x009C heater 1
lorded 8:2b0d18ebbba9 26 const uint16_t CTRLCHANNEL = 0x07A0;
lorded 8:2b0d18ebbba9 27 const uint16_t CTRLRESPONSE = 0x073C;// heater1 0x073C, response 0x073D heater 2
lorded 8:2b0d18ebbba9 28
lorded 8:2b0d18ebbba9 29 const uint16_t HEATER2ID = 0x0057;// 0x009C heater 1
lorded 8:2b0d18ebbba9 30 const uint16_t CTRLCHANNEL2 = 0x07A1;
lorded 8:2b0d18ebbba9 31 const uint16_t CTRLRESPONSE2 = 0x073D;// heater1 0x073C, response 0x073D heater 2
lorded 8:2b0d18ebbba9 32
lorded 8:2b0d18ebbba9 33 #else
lorded 8:2b0d18ebbba9 34 const uint16_t HEATER1ID = 0x009C; // 0x009C heater 1
lorded 8:2b0d18ebbba9 35 const uint16_t CTRLCHANNEL = 0x07A0;
lorded 8:2b0d18ebbba9 36 const uint16_t CTRLRESPONSE = 0x073C; // heater1 0x073C, response 0x073D heater 2
lorded 8:2b0d18ebbba9 37
lorded 8:2b0d18ebbba9 38 const uint16_t HEATER2ID = 0x00F3; // 0x009C heater 1
lorded 8:2b0d18ebbba9 39 const uint16_t CTRLCHANNEL2 = 0x07A1;
lorded 8:2b0d18ebbba9 40 const uint16_t CTRLRESPONSE2 = 0x073D; // heater1 0x073C, response 0x073D heater 2
lorded 8:2b0d18ebbba9 41
lorded 8:2b0d18ebbba9 42 #endif
lorded 8:2b0d18ebbba9 43
lorded 8:2b0d18ebbba9 44 /******************************************************
lorded 8:2b0d18ebbba9 45 * Enumerations
lorded 8:2b0d18ebbba9 46 ******************************************************/
lorded 8:2b0d18ebbba9 47
lorded 8:2b0d18ebbba9 48 /******************************************************
lorded 8:2b0d18ebbba9 49 * Type Definitions
lorded 8:2b0d18ebbba9 50 ******************************************************/
lorded 8:2b0d18ebbba9 51
lorded 8:2b0d18ebbba9 52 /******************************************************
lorded 8:2b0d18ebbba9 53 * Structures
lorded 8:2b0d18ebbba9 54 ******************************************************/
lorded 8:2b0d18ebbba9 55 extern struct sSystemSettings Settings; // structure to hold system settings //
lorded 8:2b0d18ebbba9 56 /******************************************************
lorded 8:2b0d18ebbba9 57 * Function Declarations
lorded 8:2b0d18ebbba9 58 ******************************************************/
lorded 8:2b0d18ebbba9 59 void printCAN(CANMessage *canMsg);
lorded 8:2b0d18ebbba9 60 void printCANTx(CANMessage *canMsg);
lorded 8:2b0d18ebbba9 61
lorded 8:2b0d18ebbba9 62 void printPacketBuffer(unsigned int length, struct sHeatVars *s);
lorded 8:2b0d18ebbba9 63 void parseLINBuffer(struct sHeatVars *s);
lorded 8:2b0d18ebbba9 64 void readLINBuffer(struct sHeatVars *s);
lorded 8:2b0d18ebbba9 65 unsigned char fromHexAscii(char ascii);
lorded 8:2b0d18ebbba9 66 extern void resetTimerAsync(struct sHeatVars *s);
lorded 8:2b0d18ebbba9 67 extern void resetTimer(struct sHeatVars *s);
lorded 8:2b0d18ebbba9 68 int doFindExpectedResponse(CANMessage* msg, const uint16_t expectedID, const char* expectedResponse, int charsInMatch);
lorded 8:2b0d18ebbba9 69 /******************************************************
lorded 8:2b0d18ebbba9 70 * Variable Definitions
lorded 8:2b0d18ebbba9 71 ******************************************************/
lorded 8:2b0d18ebbba9 72
lorded 8:2b0d18ebbba9 73 // local vars
lorded 8:2b0d18ebbba9 74 // external timer variables to use for timing (ie 1 minute, etc.)
lorded 8:2b0d18ebbba9 75 extern volatile unsigned char idletimer;
lorded 8:2b0d18ebbba9 76 extern void DebugWrite(const char* str);
lorded 10:a82e51837e2b 77 struct sHeatVars heaterState[HEATERSTATECOUNT];
lorded 8:2b0d18ebbba9 78
lorded 8:2b0d18ebbba9 79 char otherControllerDetected = 0;
lorded 8:2b0d18ebbba9 80 /******************************************************
lorded 8:2b0d18ebbba9 81 * Function Definitions
lorded 8:2b0d18ebbba9 82 ******************************************************/
lorded 8:2b0d18ebbba9 83
lorded 8:2b0d18ebbba9 84 /*
lorded 8:2b0d18ebbba9 85 * 0-ID,0054:00 00 FE FF FE FF 00 00
lorded 8:2b0d18ebbba9 86
lorded 8:2b0d18ebbba9 87 0-ID,0625:25 00 B5 54 C0 BB E4 01
lorded 8:2b0d18ebbba9 88
lorded 8:2b0d18ebbba9 89 0-ID,0054:00 00 FE FF FE FF 00 00
lorded 8:2b0d18ebbba9 90
lorded 8:2b0d18ebbba9 91 0-ID,0057:00 00 FE FF FE FF 00 00
lorded 8:2b0d18ebbba9 92
lorded 8:2b0d18ebbba9 93 0-ID,0625:25 00 B5 54 C0 BB E4 01
lorded 8:2b0d18ebbba9 94
lorded 8:2b0d18ebbba9 95 0-ID,02C4:03 00 04 00 18 03 00 00
lorded 8:2b0d18ebbba9 96
lorded 8:2b0d18ebbba9 97 0-ID,02C6:F4 01 84 03 00 00 00 00
lorded 8:2b0d18ebbba9 98
lorded 8:2b0d18ebbba9 99 0-ID,0625:25 00 B5 54 C0 BB E4 01
lorded 8:2b0d18ebbba9 100
lorded 8:2b0d18ebbba9 101 0-ID,02C6:F4 01 84 03 00 00 00 00
lorded 8:2b0d18ebbba9 102
lorded 8:2b0d18ebbba9 103 0-ID,073C:02 7E 00 02 7B 00 02 11
lorded 8:2b0d18ebbba9 104
lorded 8:2b0d18ebbba9 105 0-ID,02C6:F4 01 84 03 00 00 00 00
lorded 8:2b0d18ebbba9 106
lorded 8:2b0d18ebbba9 107 0-ID,0625:25 00 B5 54 C0 BB E4 01
lorded 8:2b0d18ebbba9 108
lorded 8:2b0d18ebbba9 109 0-ID,02C6:F4 01 84 03 00 00 00 00
lorded 8:2b0d18ebbba9 110
lorded 8:2b0d18ebbba9 111 * */
lorded 8:2b0d18ebbba9 112
lorded 8:2b0d18ebbba9 113 void initHeaterState(struct sHeatVars *s)
lorded 8:2b0d18ebbba9 114 {
lorded 8:2b0d18ebbba9 115 s->internalAltitude = 0;
lorded 8:2b0d18ebbba9 116 s->battV = 0;
lorded 8:2b0d18ebbba9 117 s->primeFuelPumpCount = 0;
lorded 8:2b0d18ebbba9 118 s->heatCallDetected = WICED_FALSE;
lorded 8:2b0d18ebbba9 119 s->heaterTemp = -9999;
lorded 8:2b0d18ebbba9 120 s->initTimer = 3; // 3s before we do anything other than "I'm here"
lorded 8:2b0d18ebbba9 121 s->tasksequence = 0;
lorded 8:2b0d18ebbba9 122 s->currentError = 0xff;
lorded 8:2b0d18ebbba9 123 s->heatOn = 0; // default 0
lorded 8:2b0d18ebbba9 124 //unsigned char errorHistory[8];
lorded 8:2b0d18ebbba9 125 s->errorChangeFlag = 0;
lorded 8:2b0d18ebbba9 126 s->heatcontrolstate = 0; // default 0
lorded 8:2b0d18ebbba9 127 s->lastRequest = 0; // default = 0;
lorded 8:2b0d18ebbba9 128 s->lastResponse = 0; //default = 0;
lorded 8:2b0d18ebbba9 129 s->noResponseCount = 0; //default = 0;
lorded 8:2b0d18ebbba9 130 s->retryHC = 0; // = 0;
lorded 8:2b0d18ebbba9 131 s->heatrunning = 0; // = 0;
lorded 8:2b0d18ebbba9 132 s->reset_fault_codes = WICED_FALSE; // WICED_FALSE
lorded 8:2b0d18ebbba9 133 s->isAnalogHeater = WICED_FALSE;
lorded 8:2b0d18ebbba9 134 s->heattime = 0;
lorded 8:2b0d18ebbba9 135 s->heatresettime = RESETHEATTIME;
lorded 8:2b0d18ebbba9 136 s->reportflag = 0;
lorded 8:2b0d18ebbba9 137 s->preheattime = 0;
lorded 8:2b0d18ebbba9 138 s->heaterSetpointChange = 0;
lorded 8:2b0d18ebbba9 139 s->primeFuelPump = WICED_FALSE;
lorded 8:2b0d18ebbba9 140 s->OBAltitude = WICED_FALSE;
lorded 8:2b0d18ebbba9 141 s->altitudeMode = WICED_TRUE;
lorded 8:2b0d18ebbba9 142 }
lorded 8:2b0d18ebbba9 143 // do checksum calc
lorded 8:2b0d18ebbba9 144 int testChecksum(unsigned int length, struct sHeatVars *s)
lorded 8:2b0d18ebbba9 145 {
lorded 8:2b0d18ebbba9 146 unsigned int checksum = 0;
lorded 8:2b0d18ebbba9 147 int i;
lorded 8:2b0d18ebbba9 148 for (i = s->working; i < (s->working + length + 3); i++)
lorded 8:2b0d18ebbba9 149 {
lorded 8:2b0d18ebbba9 150 checksum += s->linbuff[i];
lorded 8:2b0d18ebbba9 151 }
lorded 8:2b0d18ebbba9 152 // convert the last 2 bytes to checksum
lorded 8:2b0d18ebbba9 153 if ((checksum % 256) == (fromHexAscii(s->linbuff[s->working + length + 3]) * 16 + fromHexAscii(s->linbuff[s->working + length + 4])))
lorded 8:2b0d18ebbba9 154 {
lorded 8:2b0d18ebbba9 155 return 1;
lorded 8:2b0d18ebbba9 156 }
lorded 8:2b0d18ebbba9 157 return 0;
lorded 8:2b0d18ebbba9 158 }
lorded 9:6126b83608be 159 #define CANSPEED_500 500000
lorded 8:2b0d18ebbba9 160 void InitCAN()
lorded 8:2b0d18ebbba9 161 {
lorded 9:6126b83608be 162 if ( can2.frequency(CANSPEED_500) ) {
lorded 9:6126b83608be 163
lorded 9:6126b83608be 164 }
lorded 8:2b0d18ebbba9 165 otherControllerDetected = 0;
lorded 8:2b0d18ebbba9 166 DebugWrite("Init can\r\n");
lorded 8:2b0d18ebbba9 167 int result;
lorded 8:2b0d18ebbba9 168 // can is just there.
lorded 8:2b0d18ebbba9 169 }
lorded 8:2b0d18ebbba9 170
lorded 8:2b0d18ebbba9 171 void setHeatSetpoint(struct sHeatVars* s, int setpoint)
lorded 8:2b0d18ebbba9 172 {
lorded 8:2b0d18ebbba9 173 printf("setting setpoint of %d\r\n", setpoint);
lorded 8:2b0d18ebbba9 174 if ((setpoint > 50) && (setpoint <= 380))
lorded 8:2b0d18ebbba9 175 {
lorded 8:2b0d18ebbba9 176 s->heaterSetpointChange = setpoint;
lorded 8:2b0d18ebbba9 177 }
lorded 8:2b0d18ebbba9 178 }
lorded 8:2b0d18ebbba9 179 void primeFuelPump(struct sHeatVars* s)
lorded 8:2b0d18ebbba9 180 {
lorded 8:2b0d18ebbba9 181 s->primeFuelPump = WICED_TRUE;
lorded 8:2b0d18ebbba9 182 }
lorded 8:2b0d18ebbba9 183 void resetFaultCodes(struct sHeatVars* s)
lorded 8:2b0d18ebbba9 184 {
lorded 8:2b0d18ebbba9 185 //printf("Reset Fault codes on\r\n");
lorded 8:2b0d18ebbba9 186 s->reset_fault_codes = WICED_TRUE;
lorded 8:2b0d18ebbba9 187 }
lorded 8:2b0d18ebbba9 188 void set_heat_con(struct sHeatVars* s, heatcall on_off)
lorded 8:2b0d18ebbba9 189 {
lorded 8:2b0d18ebbba9 190 resetTimerAsync(s);
lorded 8:2b0d18ebbba9 191 if (on_off == HEATCALLINIT)
lorded 8:2b0d18ebbba9 192 {
lorded 8:2b0d18ebbba9 193 s->heatOn = HEATCALLINIT;
lorded 8:2b0d18ebbba9 194 //heattime = 100; //60*Settings.DefaultHeaterRuntime;
lorded 8:2b0d18ebbba9 195 s->heattime = 24*60*60;
lorded 8:2b0d18ebbba9 196 s->heatresettime = RESETHEATTIME;
lorded 8:2b0d18ebbba9 197
lorded 8:2b0d18ebbba9 198 s->preheattime = 0;
lorded 8:2b0d18ebbba9 199 //printf("Init heater, preheat %lu\n", preheattime);
lorded 8:2b0d18ebbba9 200 }
lorded 8:2b0d18ebbba9 201 else if (on_off == HEATCALLOFF)
lorded 8:2b0d18ebbba9 202 {
lorded 8:2b0d18ebbba9 203 s->heatOn = HEATCALLOFF;
lorded 8:2b0d18ebbba9 204 s->heattime = 0;
lorded 8:2b0d18ebbba9 205 s->heatresettime = RESETHEATTIME;
lorded 8:2b0d18ebbba9 206 s->preheattime = 0;
lorded 8:2b0d18ebbba9 207 ///printf("Turning heater OFF\n");
lorded 8:2b0d18ebbba9 208 }
lorded 8:2b0d18ebbba9 209 else if (on_off == HEATCALLON)
lorded 8:2b0d18ebbba9 210 {
lorded 8:2b0d18ebbba9 211 // skip preheat
lorded 8:2b0d18ebbba9 212 s->heatOn = HEATCALLON;
lorded 8:2b0d18ebbba9 213 s->heattime = 24*60*60;
lorded 8:2b0d18ebbba9 214 s->heatresettime = RESETHEATTIME;
lorded 8:2b0d18ebbba9 215 s->preheattime = 0;
lorded 8:2b0d18ebbba9 216 //printf("Turning heater ON (skip preheat)\n");
lorded 8:2b0d18ebbba9 217 }
lorded 8:2b0d18ebbba9 218 else
lorded 8:2b0d18ebbba9 219 {
lorded 8:2b0d18ebbba9 220 //printf("\n unknown command\n");
lorded 8:2b0d18ebbba9 221 }
lorded 8:2b0d18ebbba9 222 }
lorded 8:2b0d18ebbba9 223
lorded 8:2b0d18ebbba9 224 void WakeHeater(struct sHeatVars* s)
lorded 8:2b0d18ebbba9 225 {
lorded 8:2b0d18ebbba9 226 if (s->heatcontrolstate == 0)
lorded 8:2b0d18ebbba9 227 {
lorded 8:2b0d18ebbba9 228 //InitDigHeater();
lorded 8:2b0d18ebbba9 229 s->retryHC = 0;
lorded 8:2b0d18ebbba9 230 s->heatcontrolstate = 1;
lorded 8:2b0d18ebbba9 231 }
lorded 8:2b0d18ebbba9 232 }
lorded 8:2b0d18ebbba9 233
lorded 8:2b0d18ebbba9 234 void sendCANCommand(uint16_t id, const char*data, int length)
lorded 8:2b0d18ebbba9 235 {
lorded 8:2b0d18ebbba9 236 //return; // listen mode
lorded 8:2b0d18ebbba9 237
lorded 9:6126b83608be 238 CANMessage TxMessage(id, data, length);
lorded 8:2b0d18ebbba9 239 can2.write(TxMessage);
lorded 9:6126b83608be 240 printCAN(&TxMessage);
lorded 8:2b0d18ebbba9 241 }
lorded 8:2b0d18ebbba9 242
lorded 8:2b0d18ebbba9 243 void sendRepeatMode(struct sHeatVars* s)
lorded 8:2b0d18ebbba9 244 {
lorded 8:2b0d18ebbba9 245 const char wake[8] =
lorded 8:2b0d18ebbba9 246 { 0x0F, 0x11, 0xC9, 0x22, 0x00, 0x20, 0x60, 0x00 };
lorded 8:2b0d18ebbba9 247 if (s->heaternum == 1)
lorded 8:2b0d18ebbba9 248 {
lorded 8:2b0d18ebbba9 249 sendCANCommand(0x060F, wake, 8);
lorded 8:2b0d18ebbba9 250 }
lorded 8:2b0d18ebbba9 251 //else if (s->heaternum == 2)
lorded 8:2b0d18ebbba9 252 //{
lorded 8:2b0d18ebbba9 253 // sendCANCommand(CTRLCHANNEL2, wake, 8);
lorded 8:2b0d18ebbba9 254 //}
lorded 8:2b0d18ebbba9 255 }
lorded 8:2b0d18ebbba9 256 void sendWakeCommand(struct sHeatVars* s)
lorded 8:2b0d18ebbba9 257 {
lorded 8:2b0d18ebbba9 258 //DebugWrite("Wake command\r\n");
lorded 8:2b0d18ebbba9 259 // "3e is "tester present"
lorded 8:2b0d18ebbba9 260 const char wake[8] =
lorded 8:2b0d18ebbba9 261 { 0x02, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
lorded 8:2b0d18ebbba9 262 //{0x0F, 0x10, 0x03, 0x00, 0x20, 0x60, 0x00, 0x00};
lorded 8:2b0d18ebbba9 263 if (s->heaternum == 1)
lorded 8:2b0d18ebbba9 264 {
lorded 8:2b0d18ebbba9 265 sendCANCommand(CTRLCHANNEL, wake, 8);
lorded 8:2b0d18ebbba9 266 }
lorded 8:2b0d18ebbba9 267 else if (s->heaternum == 2)
lorded 8:2b0d18ebbba9 268 {
lorded 8:2b0d18ebbba9 269 sendCANCommand(CTRLCHANNEL2, wake, 8);
lorded 8:2b0d18ebbba9 270 }
lorded 8:2b0d18ebbba9 271
lorded 8:2b0d18ebbba9 272 //const char wake2[8] = {0x0F, 0x10, 0x03, 0x00, 0x20, 0x60, 0x00, 0x00};
lorded 8:2b0d18ebbba9 273 //sendCANCommand(CTRLCHANNEL2, wake2, 8);
lorded 8:2b0d18ebbba9 274 }
lorded 8:2b0d18ebbba9 275 void sendHeatOffCommand(struct sHeatVars* s)
lorded 8:2b0d18ebbba9 276 {
lorded 8:2b0d18ebbba9 277 //DebugWrite("Heat Off command\r\n");
lorded 8:2b0d18ebbba9 278 const char heatoncmd[8] =
lorded 8:2b0d18ebbba9 279 #ifdef EASYSTARTFORMAT
lorded 8:2b0d18ebbba9 280 { 0x00, 0x00, 0xFE, 0xFF, 0xFE, 0xFF, 0x00, 0x00};
lorded 8:2b0d18ebbba9 281 #else
lorded 8:2b0d18ebbba9 282 { 0x05, 0x00, 0xFE, 0xFF, 0xFE, 0xFF, 0x00, 0x00 };
lorded 8:2b0d18ebbba9 283 #endif
lorded 8:2b0d18ebbba9 284 if (s->heaternum == 1)
lorded 8:2b0d18ebbba9 285 {
lorded 8:2b0d18ebbba9 286 sendCANCommand(HEATER1ID, heatoncmd, 8);
lorded 8:2b0d18ebbba9 287 }
lorded 8:2b0d18ebbba9 288 else if (s->heaternum == 2)
lorded 8:2b0d18ebbba9 289 {
lorded 8:2b0d18ebbba9 290 sendCANCommand(HEATER2ID, heatoncmd, 8);
lorded 8:2b0d18ebbba9 291 }
lorded 8:2b0d18ebbba9 292 }
lorded 8:2b0d18ebbba9 293 void sendHeatVentConmmand(struct sHeatVars* s)
lorded 8:2b0d18ebbba9 294 {
lorded 8:2b0d18ebbba9 295 DebugWrite("SENDHEATVENT\r\n");
lorded 8:2b0d18ebbba9 296 const char heatoncmd[8] =
lorded 8:2b0d18ebbba9 297 { 0x01, 0x02, 0xFE, 0xFF, 0xF8, 0x02, 0x00, 0x00 };
lorded 8:2b0d18ebbba9 298 if (s->heaternum == 1)
lorded 8:2b0d18ebbba9 299 {
lorded 8:2b0d18ebbba9 300 sendCANCommand(HEATER1ID, heatoncmd, 8);
lorded 8:2b0d18ebbba9 301 }
lorded 8:2b0d18ebbba9 302 else if (s->heaternum == 2)
lorded 8:2b0d18ebbba9 303 {
lorded 8:2b0d18ebbba9 304 sendCANCommand(HEATER2ID, heatoncmd, 8);
lorded 8:2b0d18ebbba9 305 }
lorded 8:2b0d18ebbba9 306 }
lorded 8:2b0d18ebbba9 307
lorded 8:2b0d18ebbba9 308 void sendHeatOnCommand(struct sHeatVars* s)
lorded 8:2b0d18ebbba9 309 {
lorded 8:2b0d18ebbba9 310 DebugWrite("SENDHEATON\r\n");
lorded 8:2b0d18ebbba9 311 char heatoncmd[8] =
lorded 8:2b0d18ebbba9 312 #ifdef EASYSTARTFORMAT
lorded 8:2b0d18ebbba9 313 { 0x01, 0x01, 0xFE, 0xFF, 0xFE, 0xFF, 0x00, 0x00}; // works?
lorded 8:2b0d18ebbba9 314 #else
lorded 8:2b0d18ebbba9 315 { 0x07, 0x01, 0xFE, 0xFF, 0xFE, 0xFF, 0x00, 0x00 }; // works?
lorded 8:2b0d18ebbba9 316 #endif
lorded 8:2b0d18ebbba9 317 //{ 0x07, 0x01, 0xFE, 0xFF, 0xFE, 0xFF, 0x00, 0x00 };
lorded 8:2b0d18ebbba9 318
lorded 8:2b0d18ebbba9 319 uint16_t setpointbytes = 65534;
lorded 8:2b0d18ebbba9 320 char *usetpoint = (char*) &setpointbytes;
lorded 8:2b0d18ebbba9 321 // heater 2 has setpoint in 2/3... heater1 in 3/4??????
lorded 8:2b0d18ebbba9 322 heatoncmd[2] = usetpoint[0]; // LSB in slot 2
lorded 8:2b0d18ebbba9 323 heatoncmd[3] = usetpoint[1];
lorded 8:2b0d18ebbba9 324 heatoncmd[4] = usetpoint[0]; // LSB in slot 2
lorded 8:2b0d18ebbba9 325 heatoncmd[5] = usetpoint[1];
lorded 8:2b0d18ebbba9 326 //{ 0x07, 0x01, 0xFE, 0xFF, 0xFE, 0xFF, 0x00, 0x00 }; // "mode is "preheating"?
lorded 8:2b0d18ebbba9 327 if (s->heaternum == 1)
lorded 8:2b0d18ebbba9 328 {
lorded 8:2b0d18ebbba9 329 //need to reintroduce this...
lorded 8:2b0d18ebbba9 330 if ((s->OBAltitude == WICED_FALSE))
lorded 8:2b0d18ebbba9 331 {
lorded 8:2b0d18ebbba9 332 char mysteryCommand[8] =
lorded 8:2b0d18ebbba9 333 { 0x0F, 0x00, 0xC9, 0x22, 0x00, 0x00, 0x00, 0x00 };
lorded 8:2b0d18ebbba9 334 sendCANCommand(0x060D, mysteryCommand, 8);
lorded 8:2b0d18ebbba9 335 }
lorded 8:2b0d18ebbba9 336
lorded 8:2b0d18ebbba9 337 sendCANCommand(HEATER1ID, heatoncmd, 8);
lorded 8:2b0d18ebbba9 338 }
lorded 8:2b0d18ebbba9 339 else if (s->heaternum == 2)
lorded 8:2b0d18ebbba9 340 {
lorded 8:2b0d18ebbba9 341 sendCANCommand(HEATER2ID, heatoncmd, 8);
lorded 8:2b0d18ebbba9 342 }
lorded 8:2b0d18ebbba9 343 }
lorded 8:2b0d18ebbba9 344 void sendAltitudeMode(struct sHeatVars *s)
lorded 8:2b0d18ebbba9 345 {
lorded 8:2b0d18ebbba9 346 if (s->OBAltitude == WICED_TRUE)
lorded 8:2b0d18ebbba9 347 {
lorded 8:2b0d18ebbba9 348 return; // don't send if altitude mode on board.
lorded 8:2b0d18ebbba9 349 }
lorded 8:2b0d18ebbba9 350
lorded 8:2b0d18ebbba9 351 char highAltitudeCmd[8] =
lorded 8:2b0d18ebbba9 352 { 0x4c, 0x1d, 0, 0, 0, 0, 0, 0 };
lorded 8:2b0d18ebbba9 353
lorded 8:2b0d18ebbba9 354 // no idea what this is for?
lorded 8:2b0d18ebbba9 355 //5000 60D 205935687 0008 0D 11 C9 22 00 20 60 00
lorded 8:2b0d18ebbba9 356 //#ifdef EASYSTARTFORMAT
lorded 8:2b0d18ebbba9 357
lorded 8:2b0d18ebbba9 358 //#endif
lorded 8:2b0d18ebbba9 359 // 4C,1D - 7500 for high altitude
lorded 8:2b0d18ebbba9 360 // 10,27 - 10000 for low altitude
lorded 8:2b0d18ebbba9 361
lorded 8:2b0d18ebbba9 362 //uint16_t setpointbytes = 6800;
lorded 8:2b0d18ebbba9 363 uint16_t setpointbytes = 6800;
lorded 8:2b0d18ebbba9 364 if (s->internalAltitude > 0)
lorded 8:2b0d18ebbba9 365 {
lorded 8:2b0d18ebbba9 366 setpointbytes = (s->internalAltitude * 10);
lorded 8:2b0d18ebbba9 367 //sprintf(printbuff, "-- Internal alt\r\n %d\r\n", s->internalAltitude);
lorded 8:2b0d18ebbba9 368 //DebugWrite(printbuff);
lorded 8:2b0d18ebbba9 369 }
lorded 8:2b0d18ebbba9 370 else
lorded 8:2b0d18ebbba9 371 {
lorded 8:2b0d18ebbba9 372 setpointbytes = 6800;
lorded 8:2b0d18ebbba9 373 }
lorded 8:2b0d18ebbba9 374 char *usetpoint = (char*) &setpointbytes;
lorded 8:2b0d18ebbba9 375 highAltitudeCmd[0] = usetpoint[0]; // LSB in slot 2
lorded 8:2b0d18ebbba9 376 highAltitudeCmd[1] = usetpoint[1];
lorded 8:2b0d18ebbba9 377 char lowAltitudeCmd[8] =
lorded 8:2b0d18ebbba9 378 { 0x10, 0x27, 0, 0, 0, 0, 0, 0 };
lorded 8:2b0d18ebbba9 379
lorded 8:2b0d18ebbba9 380 if (s->internalAltitude > 0)
lorded 8:2b0d18ebbba9 381 {
lorded 8:2b0d18ebbba9 382 setpointbytes = (s->internalAltitude * 10);
lorded 8:2b0d18ebbba9 383 // sprintf(printbuff, "-- Internal alt %d\r\n", s->internalAltitude);
lorded 8:2b0d18ebbba9 384 // DebugWrite(printbuff);
lorded 8:2b0d18ebbba9 385 }
lorded 8:2b0d18ebbba9 386 else
lorded 8:2b0d18ebbba9 387 {
lorded 8:2b0d18ebbba9 388 setpointbytes = 10000;
lorded 8:2b0d18ebbba9 389 }
lorded 8:2b0d18ebbba9 390
lorded 8:2b0d18ebbba9 391 lowAltitudeCmd[0] = usetpoint[0]; // LSB in slot 2
lorded 8:2b0d18ebbba9 392 lowAltitudeCmd[1] = usetpoint[1];
lorded 8:2b0d18ebbba9 393
lorded 8:2b0d18ebbba9 394 if (s->heaternum == 1)
lorded 8:2b0d18ebbba9 395 {
lorded 8:2b0d18ebbba9 396 if (s->altitudeMode == WICED_TRUE)
lorded 8:2b0d18ebbba9 397 {
lorded 8:2b0d18ebbba9 398
lorded 8:2b0d18ebbba9 399 sendCANCommand(0x0055, highAltitudeCmd, 8);
lorded 8:2b0d18ebbba9 400 // sendCANCommand(0x0056, highAltitudeCmd, 8);
lorded 8:2b0d18ebbba9 401 sendCANCommand(HEATER1ID + 1, highAltitudeCmd, 8);
lorded 8:2b0d18ebbba9 402 }
lorded 8:2b0d18ebbba9 403 else
lorded 8:2b0d18ebbba9 404 {
lorded 8:2b0d18ebbba9 405 sendCANCommand(0x0055, lowAltitudeCmd, 8);
lorded 8:2b0d18ebbba9 406 // sendCANCommand(0x0056, lowAltitudeCmd, 8);
lorded 8:2b0d18ebbba9 407 sendCANCommand(HEATER1ID + 1, lowAltitudeCmd, 8);
lorded 8:2b0d18ebbba9 408 }
lorded 8:2b0d18ebbba9 409
lorded 8:2b0d18ebbba9 410 }
lorded 8:2b0d18ebbba9 411 /*
lorded 8:2b0d18ebbba9 412 else if (s->heaternum == 2)
lorded 8:2b0d18ebbba9 413 {
lorded 8:2b0d18ebbba9 414 if (s->altitudeMode == WICED_TRUE)
lorded 8:2b0d18ebbba9 415 {
lorded 8:2b0d18ebbba9 416 sendCANCommand(HEATER2ID + 1, highAltitudeCmd, 8);
lorded 8:2b0d18ebbba9 417 sendCANCommand(0x0055, lowAltitudeCmd, 8);
lorded 8:2b0d18ebbba9 418 sendCANCommand(0x0056, highAltitudeCmd, 8);
lorded 8:2b0d18ebbba9 419 }
lorded 8:2b0d18ebbba9 420 else
lorded 8:2b0d18ebbba9 421 {
lorded 8:2b0d18ebbba9 422 sendCANCommand(HEATER2ID + 1, lowAltitudeCmd, 8);
lorded 8:2b0d18ebbba9 423 sendCANCommand(0x0055, lowAltitudeCmd, 8);
lorded 8:2b0d18ebbba9 424 sendCANCommand(0x0056, lowAltitudeCmd, 8);
lorded 8:2b0d18ebbba9 425 }
lorded 8:2b0d18ebbba9 426
lorded 8:2b0d18ebbba9 427 }
lorded 8:2b0d18ebbba9 428 */
lorded 8:2b0d18ebbba9 429 }
lorded 8:2b0d18ebbba9 430 void sendHeatOnCommandSetpoint(struct sHeatVars* s)
lorded 8:2b0d18ebbba9 431 {
lorded 8:2b0d18ebbba9 432 DebugWrite("SENDHEATONSETPOINT\r\n");
lorded 8:2b0d18ebbba9 433 sprintf(printbuff, "Setpoint is %d", s->setpoint);
lorded 8:2b0d18ebbba9 434 DebugWrite(printbuff);
lorded 8:2b0d18ebbba9 435 char heatoncmd[8] =
lorded 8:2b0d18ebbba9 436 //{ 0x01, 0x04, 0xFE, 0xFF, 0xFE, 0xFF, 0x00, 0x00 }; // "mode is "setpoint with temp"?
lorded 8:2b0d18ebbba9 437 { 0x07, 0x04, 0xFE, 0xFF, 0xFF, 0xFE, 0x00, 0x00 }; // "mode is "setpoint with temp"?
lorded 8:2b0d18ebbba9 438
lorded 8:2b0d18ebbba9 439 uint16_t setpointbytes = 65534;
lorded 8:2b0d18ebbba9 440 char *usetpoint = (char*) &setpointbytes;
lorded 8:2b0d18ebbba9 441 // heater 2 has setpoint in 2/3... heater1 in 3/4??????
lorded 8:2b0d18ebbba9 442 heatoncmd[2] = usetpoint[0]; // LSB in slot 2
lorded 8:2b0d18ebbba9 443 heatoncmd[3] = usetpoint[1];
lorded 8:2b0d18ebbba9 444 heatoncmd[4] = usetpoint[0]; // LSB in slot 2
lorded 8:2b0d18ebbba9 445 heatoncmd[5] = usetpoint[1];
lorded 8:2b0d18ebbba9 446
lorded 8:2b0d18ebbba9 447 setpointbytes = s->setpoint;
lorded 8:2b0d18ebbba9 448 usetpoint = (char*) &setpointbytes;
lorded 8:2b0d18ebbba9 449 // heater 2 has setpoint in 2/3... heater1 in 3/4??????
lorded 8:2b0d18ebbba9 450 if (s->heaternum == 2)
lorded 8:2b0d18ebbba9 451 {
lorded 8:2b0d18ebbba9 452 heatoncmd[2] = usetpoint[0]; // LSB in slot 2
lorded 8:2b0d18ebbba9 453 heatoncmd[3] = usetpoint[1];
lorded 8:2b0d18ebbba9 454 //heatoncmd[4] = usetpoint[0]; // LSB in slot 2
lorded 8:2b0d18ebbba9 455 //heatoncmd[5] = usetpoint[1];
lorded 8:2b0d18ebbba9 456 sendCANCommand(HEATER2ID, heatoncmd, 8);
lorded 8:2b0d18ebbba9 457 }
lorded 8:2b0d18ebbba9 458 else
lorded 8:2b0d18ebbba9 459 {
lorded 8:2b0d18ebbba9 460 heatoncmd[4] = usetpoint[0]; // LSB in slot 2
lorded 8:2b0d18ebbba9 461 heatoncmd[5] = usetpoint[1];
lorded 8:2b0d18ebbba9 462 sendCANCommand(HEATER1ID, heatoncmd, 8);
lorded 8:2b0d18ebbba9 463 }
lorded 8:2b0d18ebbba9 464
lorded 8:2b0d18ebbba9 465 }
lorded 8:2b0d18ebbba9 466 void doOtherResetSequence(struct sHeatVars* s)
lorded 8:2b0d18ebbba9 467 {
lorded 8:2b0d18ebbba9 468 //DebugWrite("**************\r\n");
lorded 8:2b0d18ebbba9 469 CANMessage msg;
lorded 8:2b0d18ebbba9 470
lorded 8:2b0d18ebbba9 471 DebugWrite("Send wake\r\n");
lorded 8:2b0d18ebbba9 472 sendWakeCommand(s);
lorded 8:2b0d18ebbba9 473
lorded 8:2b0d18ebbba9 474 int id = CTRLCHANNEL;
lorded 8:2b0d18ebbba9 475 int resp = CTRLRESPONSE;
lorded 8:2b0d18ebbba9 476 if (s->heaternum == 2)
lorded 8:2b0d18ebbba9 477 {
lorded 8:2b0d18ebbba9 478 id = CTRLCHANNEL2;
lorded 8:2b0d18ebbba9 479 resp = CTRLRESPONSE2;
lorded 8:2b0d18ebbba9 480 }
lorded 8:2b0d18ebbba9 481 char switchToSession[8] =
lorded 8:2b0d18ebbba9 482 { 0x10, 0x61, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
lorded 8:2b0d18ebbba9 483 sendCANCommand(id, switchToSession, 8);
lorded 8:2b0d18ebbba9 484 DebugWrite("Switch To Session\r\n");
lorded 8:2b0d18ebbba9 485 if (doFindExpectedResponse(&msg, resp, NULL, 0) > 0)
lorded 8:2b0d18ebbba9 486 {
lorded 8:2b0d18ebbba9 487 DebugWrite("Got a response!\r\n");
lorded 8:2b0d18ebbba9 488 printCAN(&msg);
lorded 8:2b0d18ebbba9 489 //return;
lorded 8:2b0d18ebbba9 490 }
lorded 8:2b0d18ebbba9 491 else
lorded 8:2b0d18ebbba9 492 {
lorded 8:2b0d18ebbba9 493
lorded 8:2b0d18ebbba9 494 }
lorded 8:2b0d18ebbba9 495 // request seed
lorded 8:2b0d18ebbba9 496
lorded 8:2b0d18ebbba9 497 //DebugWrite("**************\r\n");
lorded 8:2b0d18ebbba9 498 }
lorded 8:2b0d18ebbba9 499 void doPrimeSequence(struct sHeatVars* s)
lorded 8:2b0d18ebbba9 500 {
lorded 8:2b0d18ebbba9 501 int extrabyte = 0;
lorded 8:2b0d18ebbba9 502 int count;
lorded 8:2b0d18ebbba9 503 sendWakeCommand(s);
lorded 8:2b0d18ebbba9 504
lorded 8:2b0d18ebbba9 505 CANMessage msg;
lorded 8:2b0d18ebbba9 506 int id = CTRLCHANNEL;
lorded 8:2b0d18ebbba9 507 int resp = CTRLRESPONSE;
lorded 8:2b0d18ebbba9 508 if (s->heaternum == 2)
lorded 8:2b0d18ebbba9 509 {
lorded 8:2b0d18ebbba9 510 id = CTRLCHANNEL2;
lorded 8:2b0d18ebbba9 511 resp = CTRLRESPONSE2;
lorded 8:2b0d18ebbba9 512 }
lorded 8:2b0d18ebbba9 513
lorded 8:2b0d18ebbba9 514 char pump[8] =
lorded 8:2b0d18ebbba9 515 { 0x07, 0x31, 0x01, 0xF0, 0x00, 0x64, 0x00, 0x05 };
lorded 8:2b0d18ebbba9 516 char pump2[8] =
lorded 8:2b0d18ebbba9 517 { 0x04, 0x31, 0x03, 0xF0, 0x00, 0x00, 0x00, 0x00 };
lorded 8:2b0d18ebbba9 518
lorded 8:2b0d18ebbba9 519 // read data F1F2 identifiers...
lorded 8:2b0d18ebbba9 520 char reset1[8] =
lorded 8:2b0d18ebbba9 521 { 0x03, 0x22, 0xF1, 0xF2, 0x00, 0x00, 0x00, 0x00 };
lorded 8:2b0d18ebbba9 522 char res1[5] =
lorded 8:2b0d18ebbba9 523 { 0x10, 0x09, 0x62, 0xF1, 0xF2 };
lorded 8:2b0d18ebbba9 524
lorded 8:2b0d18ebbba9 525 // not sure
lorded 8:2b0d18ebbba9 526 char reset2[8] =
lorded 8:2b0d18ebbba9 527 { 0x30, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00 };
lorded 8:2b0d18ebbba9 528 char res2[5] =
lorded 8:2b0d18ebbba9 529 { 0x21, 0x00, 0x00, 0x60, 0xF2 };
lorded 8:2b0d18ebbba9 530
lorded 8:2b0d18ebbba9 531 // security access
lorded 8:2b0d18ebbba9 532 char reset3[8] =
lorded 8:2b0d18ebbba9 533 { 0x02, 0x27, 0x63, 0x00, 0x00, 0x00, 0x00, 0x00 };
lorded 8:2b0d18ebbba9 534 // security response
lorded 8:2b0d18ebbba9 535 char res3[4] =
lorded 8:2b0d18ebbba9 536 { 0x06, 0x67, 0x63, 0x00 };
lorded 8:2b0d18ebbba9 537
lorded 8:2b0d18ebbba9 538 char reset3a[8] =
lorded 8:2b0d18ebbba9 539 { 0x02, 0x10, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00 };
lorded 8:2b0d18ebbba9 540 char res3a[3] =
lorded 8:2b0d18ebbba9 541 { 0x06, 0x50, 0x01 };
lorded 8:2b0d18ebbba9 542
lorded 8:2b0d18ebbba9 543 // change to session '60'
lorded 8:2b0d18ebbba9 544 char reset3b[8] =
lorded 8:2b0d18ebbba9 545 { 0x02, 0x10, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00 };
lorded 8:2b0d18ebbba9 546 char res3b[3] =
lorded 8:2b0d18ebbba9 547 { 0x06, 0x50, 0x60 };
lorded 8:2b0d18ebbba9 548
lorded 8:2b0d18ebbba9 549 // scurity access
lorded 8:2b0d18ebbba9 550 char reset4a[8] =
lorded 8:2b0d18ebbba9 551 { 0x06, 0x27, 0x64, 0x00, 0x00, 0x10, 0x60, 0x00 };
lorded 8:2b0d18ebbba9 552 char res4a[4] =
lorded 8:2b0d18ebbba9 553 { 0x02, 0x67, 0x64, 0x00 };
lorded 8:2b0d18ebbba9 554 count = 0;
lorded 8:2b0d18ebbba9 555 DebugWrite("***RESET1\r\n");
lorded 8:2b0d18ebbba9 556 sendCANCommand(id, reset1, 8);
lorded 8:2b0d18ebbba9 557 while (count++ < 20)
lorded 8:2b0d18ebbba9 558 {
lorded 8:2b0d18ebbba9 559 if (doFindExpectedResponse(&msg, resp, res1, 3) > 0)
lorded 8:2b0d18ebbba9 560 {
lorded 8:2b0d18ebbba9 561 printf("1!\r\n");
lorded 8:2b0d18ebbba9 562 break;
lorded 8:2b0d18ebbba9 563 }
lorded 8:2b0d18ebbba9 564 else
lorded 8:2b0d18ebbba9 565 {
lorded 8:2b0d18ebbba9 566 if (msg.id == 0x073)
lorded 8:2b0d18ebbba9 567 {
lorded 8:2b0d18ebbba9 568 DebugWrite("Got-");
lorded 8:2b0d18ebbba9 569 printCAN(&msg);
lorded 8:2b0d18ebbba9 570 }
lorded 8:2b0d18ebbba9 571 }
lorded 8:2b0d18ebbba9 572 }
lorded 8:2b0d18ebbba9 573 if (count >= 20)
lorded 8:2b0d18ebbba9 574 {
lorded 8:2b0d18ebbba9 575 DebugWrite("FAILED(1)\r\n");
lorded 8:2b0d18ebbba9 576 return;
lorded 8:2b0d18ebbba9 577 }
lorded 8:2b0d18ebbba9 578 count = 0;
lorded 8:2b0d18ebbba9 579 sendCANCommand(id, reset2, 8);
lorded 8:2b0d18ebbba9 580 DebugWrite("***RESET2\r\n");
lorded 8:2b0d18ebbba9 581 while (count++ < 20)
lorded 8:2b0d18ebbba9 582 {
lorded 8:2b0d18ebbba9 583 if (doFindExpectedResponse(&msg, resp, res2, 3) > 0)
lorded 8:2b0d18ebbba9 584 {
lorded 8:2b0d18ebbba9 585 DebugWrite("2!\r\n");
lorded 8:2b0d18ebbba9 586 break;
lorded 8:2b0d18ebbba9 587 }
lorded 8:2b0d18ebbba9 588 else
lorded 8:2b0d18ebbba9 589 {
lorded 8:2b0d18ebbba9 590
lorded 8:2b0d18ebbba9 591 }
lorded 8:2b0d18ebbba9 592 }
lorded 8:2b0d18ebbba9 593 if (count >= 20)
lorded 8:2b0d18ebbba9 594 {
lorded 8:2b0d18ebbba9 595 DebugWrite("FAILED(2)\r\n");
lorded 8:2b0d18ebbba9 596 return;
lorded 8:2b0d18ebbba9 597 }
lorded 8:2b0d18ebbba9 598
lorded 8:2b0d18ebbba9 599 // check msg byte 4, if 01, additional commands
lorded 8:2b0d18ebbba9 600 extrabyte = msg.data[3];
lorded 8:2b0d18ebbba9 601 if (extrabyte > 0)
lorded 8:2b0d18ebbba9 602 {
lorded 8:2b0d18ebbba9 603 count = 0;
lorded 8:2b0d18ebbba9 604 sendCANCommand(id, reset3a, 8);
lorded 8:2b0d18ebbba9 605 while (count++ < 20)
lorded 8:2b0d18ebbba9 606 {
lorded 8:2b0d18ebbba9 607 if (doFindExpectedResponse(&msg, resp, res3a, 3) > 0)
lorded 8:2b0d18ebbba9 608 {
lorded 8:2b0d18ebbba9 609 DebugWrite("3a!\r\n");
lorded 8:2b0d18ebbba9 610 break;
lorded 8:2b0d18ebbba9 611 }
lorded 8:2b0d18ebbba9 612 else
lorded 8:2b0d18ebbba9 613 {
lorded 8:2b0d18ebbba9 614
lorded 8:2b0d18ebbba9 615 }
lorded 8:2b0d18ebbba9 616 }
lorded 8:2b0d18ebbba9 617 if (count >= 20)
lorded 8:2b0d18ebbba9 618 {
lorded 8:2b0d18ebbba9 619 DebugWrite("FAILED(3)\r\n");
lorded 8:2b0d18ebbba9 620 return;
lorded 8:2b0d18ebbba9 621 }
lorded 8:2b0d18ebbba9 622 count = 0;
lorded 8:2b0d18ebbba9 623 sendCANCommand(id, reset3b, 8);
lorded 8:2b0d18ebbba9 624 while (count++ < 20)
lorded 8:2b0d18ebbba9 625 {
lorded 8:2b0d18ebbba9 626 if (doFindExpectedResponse(&msg, resp, res3b, 3) > 0)
lorded 8:2b0d18ebbba9 627 {
lorded 8:2b0d18ebbba9 628 DebugWrite("3b!\r\n");
lorded 8:2b0d18ebbba9 629 break;
lorded 8:2b0d18ebbba9 630 }
lorded 8:2b0d18ebbba9 631 else
lorded 8:2b0d18ebbba9 632 {
lorded 8:2b0d18ebbba9 633
lorded 8:2b0d18ebbba9 634 }
lorded 8:2b0d18ebbba9 635 }
lorded 8:2b0d18ebbba9 636 if (count >= 20)
lorded 8:2b0d18ebbba9 637 {
lorded 8:2b0d18ebbba9 638 DebugWrite("FAILED(4)\r\n");
lorded 8:2b0d18ebbba9 639 return;
lorded 8:2b0d18ebbba9 640 }
lorded 8:2b0d18ebbba9 641 }
lorded 8:2b0d18ebbba9 642
lorded 8:2b0d18ebbba9 643 count = 0;
lorded 8:2b0d18ebbba9 644 sendCANCommand(id, reset3, 8);
lorded 8:2b0d18ebbba9 645 while (count++ < 20)
lorded 8:2b0d18ebbba9 646 {
lorded 8:2b0d18ebbba9 647 if (doFindExpectedResponse(&msg, resp, res3, 3) > 0)
lorded 8:2b0d18ebbba9 648 {
lorded 8:2b0d18ebbba9 649 DebugWrite("3!\r\n");
lorded 8:2b0d18ebbba9 650 break;
lorded 8:2b0d18ebbba9 651 }
lorded 8:2b0d18ebbba9 652 else
lorded 8:2b0d18ebbba9 653 {
lorded 8:2b0d18ebbba9 654
lorded 8:2b0d18ebbba9 655 }
lorded 8:2b0d18ebbba9 656 }
lorded 8:2b0d18ebbba9 657 if (count >= 20)
lorded 8:2b0d18ebbba9 658 {
lorded 8:2b0d18ebbba9 659 DebugWrite("FAILED(5)\r\n");
lorded 8:2b0d18ebbba9 660 return;
lorded 8:2b0d18ebbba9 661 }
lorded 8:2b0d18ebbba9 662 if (extrabyte > 0)
lorded 8:2b0d18ebbba9 663 {
lorded 8:2b0d18ebbba9 664 count = 0;
lorded 8:2b0d18ebbba9 665 sendCANCommand(id, reset4a, 8);
lorded 8:2b0d18ebbba9 666 while (count++ < 20)
lorded 8:2b0d18ebbba9 667 {
lorded 8:2b0d18ebbba9 668 if (doFindExpectedResponse(&msg, resp, res4a, 3) > 0)
lorded 8:2b0d18ebbba9 669 {
lorded 8:2b0d18ebbba9 670 DebugWrite("4a!\r\n");
lorded 8:2b0d18ebbba9 671 break;
lorded 8:2b0d18ebbba9 672 }
lorded 8:2b0d18ebbba9 673 else
lorded 8:2b0d18ebbba9 674 {
lorded 8:2b0d18ebbba9 675
lorded 8:2b0d18ebbba9 676 }
lorded 8:2b0d18ebbba9 677 }
lorded 8:2b0d18ebbba9 678 if (count >= 20)
lorded 8:2b0d18ebbba9 679 {
lorded 8:2b0d18ebbba9 680 DebugWrite("FAILED(6)\r\n");
lorded 8:2b0d18ebbba9 681 return;
lorded 8:2b0d18ebbba9 682 }
lorded 8:2b0d18ebbba9 683 }
lorded 8:2b0d18ebbba9 684 count = 0;
lorded 8:2b0d18ebbba9 685
lorded 8:2b0d18ebbba9 686 DebugWrite("SENDING PUMP COMMAND\r\n");
lorded 8:2b0d18ebbba9 687 sendCANCommand(id, pump, 8);
lorded 8:2b0d18ebbba9 688 DebugWrite("SEQUENCE ON COMMAND\r\n");
lorded 8:2b0d18ebbba9 689 sendCANCommand(id, pump2, 8);
lorded 8:2b0d18ebbba9 690 s->primeFuelPumpCount = 5;
lorded 8:2b0d18ebbba9 691 }
lorded 8:2b0d18ebbba9 692
lorded 8:2b0d18ebbba9 693 void doResetSequence(struct sHeatVars* s)
lorded 8:2b0d18ebbba9 694 {
lorded 8:2b0d18ebbba9 695 int extrabyte = 0;
lorded 8:2b0d18ebbba9 696 int count;
lorded 8:2b0d18ebbba9 697 sendWakeCommand(s);
lorded 8:2b0d18ebbba9 698
lorded 8:2b0d18ebbba9 699 CANMessage msg;
lorded 8:2b0d18ebbba9 700 int id = CTRLCHANNEL;
lorded 8:2b0d18ebbba9 701 int resp = CTRLRESPONSE;
lorded 8:2b0d18ebbba9 702 if (s->heaternum == 2)
lorded 8:2b0d18ebbba9 703 {
lorded 8:2b0d18ebbba9 704 id = CTRLCHANNEL2;
lorded 8:2b0d18ebbba9 705 resp = CTRLRESPONSE2;
lorded 8:2b0d18ebbba9 706 }
lorded 8:2b0d18ebbba9 707 // read data F1F2 identifiers...
lorded 8:2b0d18ebbba9 708 char reset1[8] =
lorded 8:2b0d18ebbba9 709 { 0x03, 0x22, 0xF1, 0xF2, 0x00, 0x00, 0x00, 0x00 };
lorded 8:2b0d18ebbba9 710 char res1[5] =
lorded 8:2b0d18ebbba9 711 { 0x10, 0x09, 0x62, 0xF1, 0xF2 };
lorded 8:2b0d18ebbba9 712
lorded 8:2b0d18ebbba9 713 // not sure
lorded 8:2b0d18ebbba9 714 char reset2[8] =
lorded 8:2b0d18ebbba9 715 { 0x30, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00 };
lorded 8:2b0d18ebbba9 716 char res2[5] =
lorded 8:2b0d18ebbba9 717 { 0x21, 0x00, 0x00, 0x60, 0xF2 };
lorded 8:2b0d18ebbba9 718
lorded 8:2b0d18ebbba9 719 // security access
lorded 8:2b0d18ebbba9 720 char reset3[8] =
lorded 8:2b0d18ebbba9 721 { 0x02, 0x27, 0x63, 0x00, 0x00, 0x00, 0x00, 0x00 };
lorded 8:2b0d18ebbba9 722 // security response
lorded 8:2b0d18ebbba9 723 char res3[4] =
lorded 8:2b0d18ebbba9 724 { 0x06, 0x67, 0x63, 0x00 };
lorded 8:2b0d18ebbba9 725
lorded 8:2b0d18ebbba9 726 // clear diagnostics
lorded 8:2b0d18ebbba9 727 char reset4[8] =
lorded 8:2b0d18ebbba9 728 { 0x04, 0x14, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00 };
lorded 8:2b0d18ebbba9 729 // response
lorded 8:2b0d18ebbba9 730 char res4[4] =
lorded 8:2b0d18ebbba9 731 { 0x01, 0x54, 0x63, 0x00 };
lorded 8:2b0d18ebbba9 732
lorded 8:2b0d18ebbba9 733 // routine control
lorded 8:2b0d18ebbba9 734 char reset5[8] =
lorded 8:2b0d18ebbba9 735 { 0x04, 0x31, 0x01, 0xF0, 0x05, 0x00, 0x00, 0x00 };
lorded 8:2b0d18ebbba9 736 char res5[5] =
lorded 8:2b0d18ebbba9 737 { 0x04, 0x71, 0x01, 0xF0, 0x05 };
lorded 8:2b0d18ebbba9 738
lorded 8:2b0d18ebbba9 739 char reset3a[8] =
lorded 8:2b0d18ebbba9 740 { 0x02, 0x10, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00 };
lorded 8:2b0d18ebbba9 741 char res3a[3] =
lorded 8:2b0d18ebbba9 742 { 0x06, 0x50, 0x01 };
lorded 8:2b0d18ebbba9 743
lorded 8:2b0d18ebbba9 744 // change to session '60'
lorded 8:2b0d18ebbba9 745 char reset3b[8] =
lorded 8:2b0d18ebbba9 746 { 0x02, 0x10, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00 };
lorded 8:2b0d18ebbba9 747 char res3b[3] =
lorded 8:2b0d18ebbba9 748 { 0x06, 0x50, 0x60 };
lorded 8:2b0d18ebbba9 749
lorded 8:2b0d18ebbba9 750 // scurity access
lorded 8:2b0d18ebbba9 751 char reset4a[8] =
lorded 8:2b0d18ebbba9 752 { 0x06, 0x27, 0x64, 0x00, 0x00, 0x10, 0x60, 0x00 };
lorded 8:2b0d18ebbba9 753 char res4a[4] =
lorded 8:2b0d18ebbba9 754 { 0x02, 0x67, 0x64, 0x00 };
lorded 8:2b0d18ebbba9 755 count = 0;
lorded 8:2b0d18ebbba9 756 DebugWrite("***RESET1\r\n");
lorded 8:2b0d18ebbba9 757 sendCANCommand(id, reset1, 8);
lorded 8:2b0d18ebbba9 758 while (count++ < 20)
lorded 8:2b0d18ebbba9 759 {
lorded 8:2b0d18ebbba9 760 if (doFindExpectedResponse(&msg, resp, res1, 3) > 0)
lorded 8:2b0d18ebbba9 761 {
lorded 8:2b0d18ebbba9 762 printf("1!\r\n");
lorded 8:2b0d18ebbba9 763 break;
lorded 8:2b0d18ebbba9 764 }
lorded 8:2b0d18ebbba9 765 else
lorded 8:2b0d18ebbba9 766 {
lorded 8:2b0d18ebbba9 767 if (msg.id == 0x073)
lorded 8:2b0d18ebbba9 768 {
lorded 8:2b0d18ebbba9 769 DebugWrite("Got-");
lorded 8:2b0d18ebbba9 770 printCAN(&msg);
lorded 8:2b0d18ebbba9 771 }
lorded 8:2b0d18ebbba9 772 }
lorded 8:2b0d18ebbba9 773 }
lorded 8:2b0d18ebbba9 774 if (count >= 20)
lorded 8:2b0d18ebbba9 775 {
lorded 8:2b0d18ebbba9 776 DebugWrite("FAILED(1)\r\n");
lorded 8:2b0d18ebbba9 777 return;
lorded 8:2b0d18ebbba9 778 }
lorded 8:2b0d18ebbba9 779 count = 0;
lorded 8:2b0d18ebbba9 780 sendCANCommand(id, reset2, 8);
lorded 8:2b0d18ebbba9 781 DebugWrite("***RESET2\r\n");
lorded 8:2b0d18ebbba9 782 while (count++ < 20)
lorded 8:2b0d18ebbba9 783 {
lorded 8:2b0d18ebbba9 784 if (doFindExpectedResponse(&msg, resp, res2, 3) > 0)
lorded 8:2b0d18ebbba9 785 {
lorded 8:2b0d18ebbba9 786 DebugWrite("2!\r\n");
lorded 8:2b0d18ebbba9 787 break;
lorded 8:2b0d18ebbba9 788 }
lorded 8:2b0d18ebbba9 789 else
lorded 8:2b0d18ebbba9 790 {
lorded 8:2b0d18ebbba9 791
lorded 8:2b0d18ebbba9 792 }
lorded 8:2b0d18ebbba9 793 }
lorded 8:2b0d18ebbba9 794 if (count >= 20)
lorded 8:2b0d18ebbba9 795 {
lorded 8:2b0d18ebbba9 796 DebugWrite("FAILED(2)\r\n");
lorded 8:2b0d18ebbba9 797 return;
lorded 8:2b0d18ebbba9 798 }
lorded 8:2b0d18ebbba9 799 // check msg byte 4, if 01, additional commands
lorded 8:2b0d18ebbba9 800 extrabyte = msg.data[3];
lorded 8:2b0d18ebbba9 801 if (extrabyte > 0)
lorded 8:2b0d18ebbba9 802 {
lorded 8:2b0d18ebbba9 803 count = 0;
lorded 8:2b0d18ebbba9 804 sendCANCommand(id, reset3a, 8);
lorded 8:2b0d18ebbba9 805 while (count++ < 20)
lorded 8:2b0d18ebbba9 806 {
lorded 8:2b0d18ebbba9 807 if (doFindExpectedResponse(&msg, resp, res3a, 3) > 0)
lorded 8:2b0d18ebbba9 808 {
lorded 8:2b0d18ebbba9 809 DebugWrite("3a!\r\n");
lorded 8:2b0d18ebbba9 810 break;
lorded 8:2b0d18ebbba9 811 }
lorded 8:2b0d18ebbba9 812 else
lorded 8:2b0d18ebbba9 813 {
lorded 8:2b0d18ebbba9 814
lorded 8:2b0d18ebbba9 815 }
lorded 8:2b0d18ebbba9 816 }
lorded 8:2b0d18ebbba9 817 if (count >= 20)
lorded 8:2b0d18ebbba9 818 {
lorded 8:2b0d18ebbba9 819 DebugWrite("FAILED(3)\r\n");
lorded 8:2b0d18ebbba9 820 return;
lorded 8:2b0d18ebbba9 821 }
lorded 8:2b0d18ebbba9 822 count = 0;
lorded 8:2b0d18ebbba9 823 sendCANCommand(id, reset3b, 8);
lorded 8:2b0d18ebbba9 824 while (count++ < 20)
lorded 8:2b0d18ebbba9 825 {
lorded 8:2b0d18ebbba9 826 if (doFindExpectedResponse(&msg, resp, res3b, 3) > 0)
lorded 8:2b0d18ebbba9 827 {
lorded 8:2b0d18ebbba9 828 DebugWrite("3b!\r\n");
lorded 8:2b0d18ebbba9 829 break;
lorded 8:2b0d18ebbba9 830 }
lorded 8:2b0d18ebbba9 831 else
lorded 8:2b0d18ebbba9 832 {
lorded 8:2b0d18ebbba9 833
lorded 8:2b0d18ebbba9 834 }
lorded 8:2b0d18ebbba9 835 }
lorded 8:2b0d18ebbba9 836 if (count >= 20)
lorded 8:2b0d18ebbba9 837 {
lorded 8:2b0d18ebbba9 838 DebugWrite("FAILED(4)\r\n");
lorded 8:2b0d18ebbba9 839 return;
lorded 8:2b0d18ebbba9 840 }
lorded 8:2b0d18ebbba9 841 }
lorded 8:2b0d18ebbba9 842 count = 0;
lorded 8:2b0d18ebbba9 843 sendCANCommand(id, reset3, 8);
lorded 8:2b0d18ebbba9 844 while (count++ < 20)
lorded 8:2b0d18ebbba9 845 {
lorded 8:2b0d18ebbba9 846 if (doFindExpectedResponse(&msg, resp, res3, 3) > 0)
lorded 8:2b0d18ebbba9 847 {
lorded 8:2b0d18ebbba9 848 DebugWrite("3!\r\n");
lorded 8:2b0d18ebbba9 849 break;
lorded 8:2b0d18ebbba9 850 }
lorded 8:2b0d18ebbba9 851 else
lorded 8:2b0d18ebbba9 852 {
lorded 8:2b0d18ebbba9 853
lorded 8:2b0d18ebbba9 854 }
lorded 8:2b0d18ebbba9 855 }
lorded 8:2b0d18ebbba9 856 if (count >= 20)
lorded 8:2b0d18ebbba9 857 {
lorded 8:2b0d18ebbba9 858 DebugWrite("FAILED(5)\r\n");
lorded 8:2b0d18ebbba9 859 return;
lorded 8:2b0d18ebbba9 860 }
lorded 8:2b0d18ebbba9 861 if (extrabyte > 0)
lorded 8:2b0d18ebbba9 862 {
lorded 8:2b0d18ebbba9 863 count = 0;
lorded 8:2b0d18ebbba9 864 sendCANCommand(id, reset4a, 8);
lorded 8:2b0d18ebbba9 865 while (count++ < 20)
lorded 8:2b0d18ebbba9 866 {
lorded 8:2b0d18ebbba9 867 if (doFindExpectedResponse(&msg, resp, res4a, 3) > 0)
lorded 8:2b0d18ebbba9 868 {
lorded 8:2b0d18ebbba9 869 DebugWrite("4a!\r\n");
lorded 8:2b0d18ebbba9 870 break;
lorded 8:2b0d18ebbba9 871 }
lorded 8:2b0d18ebbba9 872 else
lorded 8:2b0d18ebbba9 873 {
lorded 8:2b0d18ebbba9 874
lorded 8:2b0d18ebbba9 875 }
lorded 8:2b0d18ebbba9 876 }
lorded 8:2b0d18ebbba9 877 if (count >= 20)
lorded 8:2b0d18ebbba9 878 {
lorded 8:2b0d18ebbba9 879 DebugWrite("FAILED(6)\r\n");
lorded 8:2b0d18ebbba9 880 return;
lorded 8:2b0d18ebbba9 881 }
lorded 8:2b0d18ebbba9 882 }
lorded 8:2b0d18ebbba9 883 count = 0;
lorded 8:2b0d18ebbba9 884 sendCANCommand(id, reset4, 8);
lorded 8:2b0d18ebbba9 885 while (count++ < 20)
lorded 8:2b0d18ebbba9 886 {
lorded 8:2b0d18ebbba9 887 if (doFindExpectedResponse(&msg, resp, res4, 3) > 0)
lorded 8:2b0d18ebbba9 888 {
lorded 8:2b0d18ebbba9 889 printf("4!\r\n");
lorded 8:2b0d18ebbba9 890 break;
lorded 8:2b0d18ebbba9 891 }
lorded 8:2b0d18ebbba9 892 else
lorded 8:2b0d18ebbba9 893 {
lorded 8:2b0d18ebbba9 894
lorded 8:2b0d18ebbba9 895 }
lorded 8:2b0d18ebbba9 896 }
lorded 8:2b0d18ebbba9 897 if (count >= 20)
lorded 8:2b0d18ebbba9 898 {
lorded 8:2b0d18ebbba9 899 printf("FAILED(7)\r\n");
lorded 8:2b0d18ebbba9 900 return;
lorded 8:2b0d18ebbba9 901 }
lorded 8:2b0d18ebbba9 902 count = 0;
lorded 8:2b0d18ebbba9 903 sendCANCommand(id, reset5, 8);
lorded 8:2b0d18ebbba9 904 while (count++ < 20)
lorded 8:2b0d18ebbba9 905 {
lorded 8:2b0d18ebbba9 906 if (doFindExpectedResponse(&msg, resp, res5, 3) > 0)
lorded 8:2b0d18ebbba9 907 {
lorded 8:2b0d18ebbba9 908 printf("5!\r\n");
lorded 8:2b0d18ebbba9 909 break;
lorded 8:2b0d18ebbba9 910 }
lorded 8:2b0d18ebbba9 911 else
lorded 8:2b0d18ebbba9 912 {
lorded 8:2b0d18ebbba9 913
lorded 8:2b0d18ebbba9 914 }
lorded 8:2b0d18ebbba9 915 }
lorded 8:2b0d18ebbba9 916 if (count >= 20)
lorded 8:2b0d18ebbba9 917 {
lorded 8:2b0d18ebbba9 918 printf("FAILED(8)\r\n");
lorded 8:2b0d18ebbba9 919 return;
lorded 8:2b0d18ebbba9 920 }
lorded 8:2b0d18ebbba9 921 printf("SUCCESS\r\n");
lorded 8:2b0d18ebbba9 922 }
lorded 8:2b0d18ebbba9 923 int doFindExpectedResponse(CANMessage* msg, const uint16_t expectedID, const char* expectedResponse, int charsInMatch)
lorded 8:2b0d18ebbba9 924 {
lorded 8:2b0d18ebbba9 925 char buff[256];
lorded 8:2b0d18ebbba9 926 //printf("fe-a\r\n");
lorded 8:2b0d18ebbba9 927 int timeout = 0;
lorded 8:2b0d18ebbba9 928 wiced_bool_t couldRead = WICED_FALSE;
lorded 8:2b0d18ebbba9 929 int incoming = 0;
lorded 8:2b0d18ebbba9 930
lorded 8:2b0d18ebbba9 931 while ((incoming == 0) && (timeout++ < 10))
lorded 8:2b0d18ebbba9 932 {
lorded 8:2b0d18ebbba9 933
lorded 8:2b0d18ebbba9 934 incoming = can2.read(*msg);
lorded 8:2b0d18ebbba9 935 //printf("fe-b %d\r\n", incoming);
lorded 8:2b0d18ebbba9 936 if (incoming > 0)
lorded 8:2b0d18ebbba9 937 {
lorded 8:2b0d18ebbba9 938 couldRead = WICED_TRUE;
lorded 8:2b0d18ebbba9 939 }
lorded 8:2b0d18ebbba9 940 if (!couldRead)
lorded 8:2b0d18ebbba9 941 {
lorded 8:2b0d18ebbba9 942 wait(0.01);
lorded 8:2b0d18ebbba9 943 }
lorded 8:2b0d18ebbba9 944 }
lorded 8:2b0d18ebbba9 945 //printf("fe-c\r\n");
lorded 8:2b0d18ebbba9 946 if (incoming > 0)
lorded 8:2b0d18ebbba9 947 {
lorded 8:2b0d18ebbba9 948
lorded 8:2b0d18ebbba9 949 //CAN_FIFORelease(CAN1, CAN_FIFO0);
lorded 8:2b0d18ebbba9 950 if (msg->id != expectedID)
lorded 8:2b0d18ebbba9 951 {
lorded 8:2b0d18ebbba9 952 //sprintf(buff, "No match: %04X\r\n", (unsigned int) msg->StdId);
lorded 8:2b0d18ebbba9 953 //DebugWrite(buff);
lorded 8:2b0d18ebbba9 954 return 0; // not a match
lorded 8:2b0d18ebbba9 955 }
lorded 8:2b0d18ebbba9 956 // ignore byte 1
lorded 8:2b0d18ebbba9 957 for (int i = 1; i < charsInMatch; i++)
lorded 8:2b0d18ebbba9 958 {
lorded 8:2b0d18ebbba9 959 if (!(msg->data[i] == expectedResponse[i]))
lorded 8:2b0d18ebbba9 960 {
lorded 8:2b0d18ebbba9 961 // no match
lorded 8:2b0d18ebbba9 962 return 0;
lorded 8:2b0d18ebbba9 963 }
lorded 8:2b0d18ebbba9 964 return 1; // match
lorded 8:2b0d18ebbba9 965 }
lorded 8:2b0d18ebbba9 966 // no chars in match, always a match?
lorded 8:2b0d18ebbba9 967 return 1;
lorded 8:2b0d18ebbba9 968 }
lorded 8:2b0d18ebbba9 969 else
lorded 8:2b0d18ebbba9 970 {
lorded 8:2b0d18ebbba9 971 return -1; // no read
lorded 8:2b0d18ebbba9 972 }
lorded 8:2b0d18ebbba9 973 }
lorded 8:2b0d18ebbba9 974 void printCAN(CANMessage *canMsg)
lorded 8:2b0d18ebbba9 975 {
lorded 8:2b0d18ebbba9 976 char buff[256];
lorded 8:2b0d18ebbba9 977 sprintf(buff, "ID,%04X:", (unsigned int) canMsg->id);
lorded 8:2b0d18ebbba9 978
lorded 8:2b0d18ebbba9 979 DebugWrite(buff);
lorded 8:2b0d18ebbba9 980 for (int i = 0; i < canMsg->len; i++)
lorded 8:2b0d18ebbba9 981 {
lorded 8:2b0d18ebbba9 982 sprintf(buff, "%02X ", canMsg->data[i]);
lorded 8:2b0d18ebbba9 983 DebugWrite(buff);
lorded 8:2b0d18ebbba9 984 }
lorded 8:2b0d18ebbba9 985 DebugWrite("\r\n");
lorded 8:2b0d18ebbba9 986 }
lorded 8:2b0d18ebbba9 987
lorded 8:2b0d18ebbba9 988 void printCANTx(CANMessage *canMsg)
lorded 8:2b0d18ebbba9 989 {
lorded 8:2b0d18ebbba9 990 char buff[256];
lorded 8:2b0d18ebbba9 991 sprintf(buff, "->ID,%04X:", (unsigned int) canMsg->id);
lorded 8:2b0d18ebbba9 992
lorded 8:2b0d18ebbba9 993 DebugWrite(buff);
lorded 8:2b0d18ebbba9 994 for (int i = 0; i < canMsg->len; i++)
lorded 8:2b0d18ebbba9 995 {
lorded 8:2b0d18ebbba9 996 sprintf(buff, "%02X ", canMsg->data[i]);
lorded 8:2b0d18ebbba9 997 DebugWrite(buff);
lorded 8:2b0d18ebbba9 998 }
lorded 8:2b0d18ebbba9 999 DebugWrite("\r\n");
lorded 8:2b0d18ebbba9 1000 }
lorded 8:2b0d18ebbba9 1001 void sendGetRuntime(struct sHeatVars *s, char *buff)
lorded 8:2b0d18ebbba9 1002 {
lorded 8:2b0d18ebbba9 1003 int count = 0;
lorded 8:2b0d18ebbba9 1004 CANMessage rxMsg;
lorded 8:2b0d18ebbba9 1005 int id;
lorded 8:2b0d18ebbba9 1006 int resp;
lorded 8:2b0d18ebbba9 1007 id = CTRLCHANNEL;
lorded 8:2b0d18ebbba9 1008 resp = CTRLRESPONSE;
lorded 8:2b0d18ebbba9 1009 if (s->heaternum == 2)
lorded 8:2b0d18ebbba9 1010 {
lorded 8:2b0d18ebbba9 1011 id = CTRLCHANNEL2;
lorded 8:2b0d18ebbba9 1012 resp = CTRLRESPONSE2;
lorded 8:2b0d18ebbba9 1013 }
lorded 8:2b0d18ebbba9 1014
lorded 8:2b0d18ebbba9 1015 const char msgbytes[8] =
lorded 8:2b0d18ebbba9 1016 { 0x03, 0x22, 0xFD, 0x17, 0x00, 0x00, 0x00, 0x00 };
lorded 8:2b0d18ebbba9 1017 const char continuePacket[8] =
lorded 8:2b0d18ebbba9 1018 { 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
lorded 8:2b0d18ebbba9 1019
lorded 8:2b0d18ebbba9 1020 sendCANCommand(id, msgbytes, 8);
lorded 8:2b0d18ebbba9 1021 //The control unit reads out the operating hours counter using the UDS service 22 ID: FD17
lorded 8:2b0d18ebbba9 1022 while (count++ < 10)
lorded 8:2b0d18ebbba9 1023 {
lorded 8:2b0d18ebbba9 1024 // just expect the ID (0
lorded 8:2b0d18ebbba9 1025 if (doFindExpectedResponse(&rxMsg, resp, msgbytes, 0) > 0)
lorded 8:2b0d18ebbba9 1026 {
lorded 8:2b0d18ebbba9 1027 printCAN(&rxMsg);
lorded 8:2b0d18ebbba9 1028 // response in the format 59
lorded 8:2b0d18ebbba9 1029 // the first byte dictates the length
lorded 8:2b0d18ebbba9 1030
lorded 8:2b0d18ebbba9 1031 //073C:03 59 02 7B 05 48 C3 01
lorded 8:2b0d18ebbba9 1032
lorded 8:2b0d18ebbba9 1033 if (rxMsg.data[0] < 0x10)
lorded 8:2b0d18ebbba9 1034 {
lorded 8:2b0d18ebbba9 1035 DebugWrite("Single Message. Shouldn't happen\r\n");
lorded 8:2b0d18ebbba9 1036 }
lorded 8:2b0d18ebbba9 1037 else if (rxMsg.data[0] < 0x20)
lorded 8:2b0d18ebbba9 1038 {
lorded 8:2b0d18ebbba9 1039
lorded 8:2b0d18ebbba9 1040 int totalLength = rxMsg.data[1];
lorded 8:2b0d18ebbba9 1041 unsigned int totalExpectedPackets = ((totalLength - 7) / 7) + 1;
lorded 8:2b0d18ebbba9 1042 unsigned char dataBytes[6 + totalExpectedPackets * 7];
lorded 8:2b0d18ebbba9 1043 memset(dataBytes, 0, 6 + totalExpectedPackets * 7);
lorded 8:2b0d18ebbba9 1044
lorded 8:2b0d18ebbba9 1045 // first packet contains 6 bytes of data, additional contain 7
lorded 8:2b0d18ebbba9 1046 // length 11: 1 extra packet ((11 - 6 - 1) \ 7) + = 4\7 + 1 = 1
lorded 8:2b0d18ebbba9 1047 // length 13: 1 extra packet ((13 - 6 - 1) \ 7) + = 6\7 + 1 = 1
lorded 8:2b0d18ebbba9 1048 // length 14: 2 packets ((14 - 6 - 1) \ 7) + = 7\7 + 1 = 2
lorded 8:2b0d18ebbba9 1049 // length 20: 2 packets ((20 - 6 - 1) \ 7) + = 7\7 + 1 = 2
lorded 8:2b0d18ebbba9 1050 // length 21: 3 packets ((21 - 6 - 1) \ 7) + = 7\7 + 1 = 3
lorded 8:2b0d18ebbba9 1051 // Packets = lenght is ((length - 7) \ 7) + 1
lorded 8:2b0d18ebbba9 1052
lorded 9:6126b83608be 1053 sprintf(buff, "multi message start, length %d\r\n", rxMsg.data[1]);
lorded 9:6126b83608be 1054 DebugWrite(buff);
lorded 8:2b0d18ebbba9 1055
lorded 8:2b0d18ebbba9 1056 printCAN(&rxMsg);
lorded 8:2b0d18ebbba9 1057 /*Query 03 19 02 08
lorded 8:2b0d18ebbba9 1058 * ID,073C:[10 0B] [59 02] [7B] 00 02 11]
lorded 8:2b0d18ebbba9 1059 * ID,073C:21 2B 00 02 A1 2A xx xx
lorded 8:2b0d18ebbba9 1060 * 10: Multi message start packet
lorded 8:2b0d18ebbba9 1061 * 0B: Length (11 DATA bytes). x'd out non-data
lorded 8:2b0d18ebbba9 1062 * 59: response type 59
lorded 8:2b0d18ebbba9 1063 * 02: subfunction 2
lorded 8:2b0d18ebbba9 1064 * 7B: mask
lorded 8:2b0d18ebbba9 1065 * 00 02 11: first 3 bytes of fault. Need next part
lorded 8:2b0d18ebbba9 1066 */
lorded 8:2b0d18ebbba9 1067 // get the first fault code, bytes 4-7
lorded 8:2b0d18ebbba9 1068 sendCANCommand(id, continuePacket, 8);
lorded 8:2b0d18ebbba9 1069 CANMessage additionalRxMsg[totalExpectedPackets];
lorded 8:2b0d18ebbba9 1070 int currentPacket = 0;
lorded 8:2b0d18ebbba9 1071 while (count++ < 10)
lorded 8:2b0d18ebbba9 1072 {
lorded 8:2b0d18ebbba9 1073
lorded 8:2b0d18ebbba9 1074 if (doFindExpectedResponse(&(additionalRxMsg[currentPacket]), resp, msgbytes, 0) > 0)
lorded 8:2b0d18ebbba9 1075 {
lorded 8:2b0d18ebbba9 1076 count = 0;
lorded 8:2b0d18ebbba9 1077 currentPacket++;
lorded 8:2b0d18ebbba9 1078 if (currentPacket >= totalExpectedPackets)
lorded 8:2b0d18ebbba9 1079 {
lorded 9:6126b83608be 1080 DebugWrite("Found all additional packets\r\n");
lorded 8:2b0d18ebbba9 1081
lorded 8:2b0d18ebbba9 1082 memcpy(dataBytes, rxMsg.data + 2, 6); // 6 initial data bytes
lorded 8:2b0d18ebbba9 1083 for (int i = 0; i < totalExpectedPackets; i++)
lorded 8:2b0d18ebbba9 1084 {
lorded 8:2b0d18ebbba9 1085 memcpy(dataBytes + 6 + (totalExpectedPackets * i), additionalRxMsg[i].data + 1, 7);
lorded 8:2b0d18ebbba9 1086 }
lorded 8:2b0d18ebbba9 1087
lorded 9:6126b83608be 1088 DebugWrite("Runtime Data bytes: ");
lorded 8:2b0d18ebbba9 1089 for (int i = 0; i < totalLength; i++)
lorded 8:2b0d18ebbba9 1090 {
lorded 8:2b0d18ebbba9 1091 sprintf(buff, "%02X ", dataBytes[i]);
lorded 8:2b0d18ebbba9 1092 DebugWrite(buff);
lorded 8:2b0d18ebbba9 1093 }
lorded 8:2b0d18ebbba9 1094 //DebugWrite("\r\n");
lorded 8:2b0d18ebbba9 1095
lorded 8:2b0d18ebbba9 1096 long runtime = -1;
lorded 8:2b0d18ebbba9 1097 // bytes 3-6 are runtime
lorded 8:2b0d18ebbba9 1098 if (totalLength > 6)
lorded 8:2b0d18ebbba9 1099 {
lorded 8:2b0d18ebbba9 1100 runtime = dataBytes[3];
lorded 8:2b0d18ebbba9 1101 runtime = runtime << 8;
lorded 8:2b0d18ebbba9 1102 runtime = runtime + dataBytes[4];
lorded 8:2b0d18ebbba9 1103 runtime = runtime << 8;
lorded 8:2b0d18ebbba9 1104 runtime = runtime + dataBytes[5];
lorded 8:2b0d18ebbba9 1105 runtime = runtime << 8;
lorded 8:2b0d18ebbba9 1106 runtime = runtime + dataBytes[6];
lorded 8:2b0d18ebbba9 1107 s->heaterRuntime = runtime;
lorded 8:2b0d18ebbba9 1108 }
lorded 8:2b0d18ebbba9 1109 s->heaterRuntime = runtime;
lorded 8:2b0d18ebbba9 1110 break;
lorded 8:2b0d18ebbba9 1111 }
lorded 8:2b0d18ebbba9 1112
lorded 8:2b0d18ebbba9 1113 }
lorded 9:6126b83608be 1114 } // outer while
lorded 8:2b0d18ebbba9 1115 }
lorded 8:2b0d18ebbba9 1116 }
lorded 9:6126b83608be 1117 } // while
lorded 8:2b0d18ebbba9 1118 printf("f-b\r\n");
lorded 8:2b0d18ebbba9 1119 if (count >= 10)
lorded 8:2b0d18ebbba9 1120 {
lorded 9:6126b83608be 1121 printf("FAILED or done\r\n");
lorded 8:2b0d18ebbba9 1122 return;
lorded 8:2b0d18ebbba9 1123 }
lorded 8:2b0d18ebbba9 1124 return;
lorded 8:2b0d18ebbba9 1125 }
lorded 8:2b0d18ebbba9 1126 wiced_result_t sendGetGeneric(struct sHeatVars *s, char *buff, const char msgbytes[8], CANMessage* rxMsg)
lorded 8:2b0d18ebbba9 1127 {
lorded 8:2b0d18ebbba9 1128 int id;
lorded 8:2b0d18ebbba9 1129 int resp = CTRLRESPONSE;
lorded 8:2b0d18ebbba9 1130 id = CTRLCHANNEL;
lorded 8:2b0d18ebbba9 1131 if (s->heaternum == 2)
lorded 8:2b0d18ebbba9 1132 {
lorded 8:2b0d18ebbba9 1133 id = CTRLCHANNEL2;
lorded 8:2b0d18ebbba9 1134 resp = CTRLRESPONSE2;
lorded 8:2b0d18ebbba9 1135 }
lorded 8:2b0d18ebbba9 1136
lorded 8:2b0d18ebbba9 1137 const char continuePacket[8] =
lorded 8:2b0d18ebbba9 1138 { 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
lorded 8:2b0d18ebbba9 1139
lorded 8:2b0d18ebbba9 1140 //DebugWrite("************\r\n");
lorded 8:2b0d18ebbba9 1141 sendCANCommand(id, msgbytes, 8);
lorded 8:2b0d18ebbba9 1142 if (doFindExpectedResponse(rxMsg, resp, msgbytes, 0) > 0)
lorded 8:2b0d18ebbba9 1143 {
lorded 8:2b0d18ebbba9 1144 return WICED_SUCCESS;
lorded 8:2b0d18ebbba9 1145 }
lorded 8:2b0d18ebbba9 1146 return WICED_NOT_FOUND;
lorded 8:2b0d18ebbba9 1147 }
lorded 8:2b0d18ebbba9 1148 void sendGetTemperatures(struct sHeatVars *s, char *buff)
lorded 8:2b0d18ebbba9 1149 {
lorded 8:2b0d18ebbba9 1150
lorded 8:2b0d18ebbba9 1151 int id;
lorded 8:2b0d18ebbba9 1152 int count;
lorded 8:2b0d18ebbba9 1153 int resp = CTRLRESPONSE;
lorded 8:2b0d18ebbba9 1154 id = CTRLCHANNEL;
lorded 8:2b0d18ebbba9 1155 if (s->heaternum == 2)
lorded 8:2b0d18ebbba9 1156 {
lorded 8:2b0d18ebbba9 1157 id = CTRLCHANNEL2;
lorded 8:2b0d18ebbba9 1158 resp = CTRLRESPONSE2;
lorded 8:2b0d18ebbba9 1159 }
lorded 8:2b0d18ebbba9 1160 CANMessage rxMsg;
lorded 8:2b0d18ebbba9 1161 const char msgbytes[8] =
lorded 8:2b0d18ebbba9 1162 { 0x03, 0x22, 0xFD, 0x01, 0x00, 0x00, 0x00, 0x00 };
lorded 8:2b0d18ebbba9 1163
lorded 8:2b0d18ebbba9 1164 const char continuePacket[8] =
lorded 8:2b0d18ebbba9 1165 { 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
lorded 8:2b0d18ebbba9 1166
lorded 8:2b0d18ebbba9 1167 count = 0;
lorded 8:2b0d18ebbba9 1168
lorded 8:2b0d18ebbba9 1169 //DebugWrite("************\r\n");
lorded 8:2b0d18ebbba9 1170 sendCANCommand(id, msgbytes, 8);
lorded 8:2b0d18ebbba9 1171 // just expect the ID (0
lorded 8:2b0d18ebbba9 1172
lorded 8:2b0d18ebbba9 1173 if (doFindExpectedResponse(&rxMsg, resp, msgbytes, 0) > 0)
lorded 8:2b0d18ebbba9 1174 {
lorded 8:2b0d18ebbba9 1175 //DebugWrite("********(a)****\r\n");
lorded 8:2b0d18ebbba9 1176 printCAN(&rxMsg);
lorded 8:2b0d18ebbba9 1177
lorded 8:2b0d18ebbba9 1178 // response is a multi part
lorded 8:2b0d18ebbba9 1179 if (rxMsg.data[0] < 0x10)
lorded 8:2b0d18ebbba9 1180 {
lorded 8:2b0d18ebbba9 1181 DebugWrite("Single Message. Shouldn't happen\r\n");
lorded 8:2b0d18ebbba9 1182 }
lorded 8:2b0d18ebbba9 1183 else if (rxMsg.data[0] < 0x20)
lorded 8:2b0d18ebbba9 1184 {
lorded 8:2b0d18ebbba9 1185 int totalLength = rxMsg.data[1];
lorded 8:2b0d18ebbba9 1186 unsigned int totalExpectedPackets = ((totalLength - 7) / 7) + 1;
lorded 8:2b0d18ebbba9 1187 unsigned char dataBytes[6 + totalExpectedPackets * 7];
lorded 8:2b0d18ebbba9 1188 memset(dataBytes, 0, 6 + totalExpectedPackets * 7);
lorded 8:2b0d18ebbba9 1189
lorded 8:2b0d18ebbba9 1190 // first packet contains 6 bytes of data, additional contain 7
lorded 8:2b0d18ebbba9 1191 // length 11: 1 extra packet ((11 - 6 - 1) \ 7) + = 4\7 + 1 = 1
lorded 8:2b0d18ebbba9 1192 // length 13: 1 extra packet ((13 - 6 - 1) \ 7) + = 6\7 + 1 = 1
lorded 8:2b0d18ebbba9 1193 // length 14: 2 packets ((14 - 6 - 1) \ 7) + = 7\7 + 1 = 2
lorded 8:2b0d18ebbba9 1194 // length 20: 2 packets ((20 - 6 - 1) \ 7) + = 7\7 + 1 = 2
lorded 8:2b0d18ebbba9 1195 // length 21: 3 packets ((21 - 6 - 1) \ 7) + = 7\7 + 1 = 3
lorded 8:2b0d18ebbba9 1196 // Packets = lenght is ((length - 7) \ 7) + 1
lorded 8:2b0d18ebbba9 1197
lorded 8:2b0d18ebbba9 1198 sprintf(buff, "multi message start, length %d\r\n", rxMsg.data[1]);
lorded 8:2b0d18ebbba9 1199 DebugWrite(buff);
lorded 8:2b0d18ebbba9 1200
lorded 8:2b0d18ebbba9 1201 printCAN(&rxMsg);
lorded 8:2b0d18ebbba9 1202 /*Query 03 19 02 08
lorded 8:2b0d18ebbba9 1203 * ID,073C:[10 0B] [59 02] [7B] 00 02 11]
lorded 8:2b0d18ebbba9 1204 * ID,073C:21 2B 00 02 A1 2A xx xx
lorded 8:2b0d18ebbba9 1205 * 10: Multi message start packet
lorded 8:2b0d18ebbba9 1206 * 0B: Length (11 DATA bytes). x'd out non-data
lorded 8:2b0d18ebbba9 1207 * 59: response type 59
lorded 8:2b0d18ebbba9 1208 * 02: subfunction 2
lorded 8:2b0d18ebbba9 1209 * 7B: mask
lorded 8:2b0d18ebbba9 1210 * 00 02 11: first 3 bytes of fault. Need next part
lorded 8:2b0d18ebbba9 1211 */
lorded 8:2b0d18ebbba9 1212 // get the first fault code, bytes 4-7
lorded 8:2b0d18ebbba9 1213 sendCANCommand(id, continuePacket, 8);
lorded 8:2b0d18ebbba9 1214 CANMessage additionalRxMsg[totalExpectedPackets];
lorded 8:2b0d18ebbba9 1215 int currentPacket = 0;
lorded 8:2b0d18ebbba9 1216 while (count++ < 10)
lorded 8:2b0d18ebbba9 1217 {
lorded 8:2b0d18ebbba9 1218
lorded 8:2b0d18ebbba9 1219 if (doFindExpectedResponse(&(additionalRxMsg[currentPacket]), resp, msgbytes, 0) > 0)
lorded 8:2b0d18ebbba9 1220 {
lorded 8:2b0d18ebbba9 1221 count = 0;
lorded 8:2b0d18ebbba9 1222 currentPacket++;
lorded 8:2b0d18ebbba9 1223 if (currentPacket >= totalExpectedPackets)
lorded 8:2b0d18ebbba9 1224 {
lorded 8:2b0d18ebbba9 1225 //DebugWrite("Found all additional packets\r\n");
lorded 8:2b0d18ebbba9 1226
lorded 8:2b0d18ebbba9 1227 memcpy(dataBytes, rxMsg.data + 2, 6); // 6 initial data bytes
lorded 8:2b0d18ebbba9 1228 for (int i = 0; i < totalExpectedPackets; i++)
lorded 8:2b0d18ebbba9 1229 {
lorded 8:2b0d18ebbba9 1230 memcpy(dataBytes + 6 + (totalExpectedPackets * i), additionalRxMsg[i].data + 1, 7);
lorded 8:2b0d18ebbba9 1231 }
lorded 8:2b0d18ebbba9 1232
lorded 8:2b0d18ebbba9 1233 s->flameTemp = dataBytes[3];
lorded 8:2b0d18ebbba9 1234 s->flameTemp = s->flameTemp << 8;
lorded 8:2b0d18ebbba9 1235 s->flameTemp += dataBytes[4];
lorded 8:2b0d18ebbba9 1236 s->flameTemp -= 5000;
lorded 8:2b0d18ebbba9 1237
lorded 8:2b0d18ebbba9 1238 s->inletTemp = dataBytes[5];
lorded 8:2b0d18ebbba9 1239 s->inletTemp = s->inletTemp << 8;
lorded 8:2b0d18ebbba9 1240 s->inletTemp += dataBytes[6];
lorded 8:2b0d18ebbba9 1241 s->inletTemp -= 5000;
lorded 8:2b0d18ebbba9 1242
lorded 8:2b0d18ebbba9 1243 s->outletTemp = dataBytes[7];
lorded 8:2b0d18ebbba9 1244 s->outletTemp = s->outletTemp << 8;
lorded 8:2b0d18ebbba9 1245 s->outletTemp += dataBytes[8];
lorded 8:2b0d18ebbba9 1246 s->outletTemp -= 5000;
lorded 8:2b0d18ebbba9 1247
lorded 8:2b0d18ebbba9 1248 DebugWrite(" **\r\n");
lorded 8:2b0d18ebbba9 1249 //DebugWrite("\r\n");
lorded 8:2b0d18ebbba9 1250
lorded 8:2b0d18ebbba9 1251 //long runtime = -1;
lorded 8:2b0d18ebbba9 1252 // bytes 3-6 are runtime
lorded 8:2b0d18ebbba9 1253 /*
lorded 8:2b0d18ebbba9 1254 if (totalLength > 6)
lorded 8:2b0d18ebbba9 1255 {
lorded 8:2b0d18ebbba9 1256 runtime = dataBytes[3];
lorded 8:2b0d18ebbba9 1257 runtime = runtime << 8;
lorded 8:2b0d18ebbba9 1258 runtime = runtime + dataBytes[4];
lorded 8:2b0d18ebbba9 1259 runtime = runtime << 8;
lorded 8:2b0d18ebbba9 1260 runtime = runtime + dataBytes[5];
lorded 8:2b0d18ebbba9 1261 runtime = runtime << 8;
lorded 8:2b0d18ebbba9 1262 runtime = runtime + dataBytes[6];
lorded 8:2b0d18ebbba9 1263 s->heaterRuntime = runtime;
lorded 8:2b0d18ebbba9 1264 }
lorded 8:2b0d18ebbba9 1265 s->heaterRuntime = runtime;
lorded 8:2b0d18ebbba9 1266 */
lorded 8:2b0d18ebbba9 1267 break;
lorded 8:2b0d18ebbba9 1268 }
lorded 8:2b0d18ebbba9 1269 }
lorded 8:2b0d18ebbba9 1270 }
lorded 8:2b0d18ebbba9 1271 }
lorded 8:2b0d18ebbba9 1272 }
lorded 8:2b0d18ebbba9 1273 printf("f-b\r\n");
lorded 8:2b0d18ebbba9 1274 if (count >= 10)
lorded 8:2b0d18ebbba9 1275 {
lorded 8:2b0d18ebbba9 1276 printf("FAILED\r\n");
lorded 8:2b0d18ebbba9 1277 return;
lorded 8:2b0d18ebbba9 1278 }
lorded 8:2b0d18ebbba9 1279 return;
lorded 8:2b0d18ebbba9 1280 }
lorded 8:2b0d18ebbba9 1281 void sendGetBattery(struct sHeatVars *s, char *buff)
lorded 8:2b0d18ebbba9 1282 {
lorded 8:2b0d18ebbba9 1283 int count;
lorded 8:2b0d18ebbba9 1284 CANMessage rxMsg;
lorded 8:2b0d18ebbba9 1285 char msgbytes[8] =
lorded 8:2b0d18ebbba9 1286 { 0x03, 0x22, 0xFD, 0x04, 0x00, 0x00, 0x00, 0x00 };
lorded 8:2b0d18ebbba9 1287 // response is on 73C: 0x05, 0x62, 0xFD, 0x04, [0x00, 0x7D], 0xB0, 0x1C
lorded 8:2b0d18ebbba9 1288 int id;
lorded 8:2b0d18ebbba9 1289 int resp = CTRLRESPONSE;
lorded 8:2b0d18ebbba9 1290 id = CTRLCHANNEL;
lorded 8:2b0d18ebbba9 1291 if (s->heaternum == 2)
lorded 8:2b0d18ebbba9 1292 {
lorded 8:2b0d18ebbba9 1293 id = CTRLCHANNEL2;
lorded 8:2b0d18ebbba9 1294 resp = CTRLRESPONSE2;
lorded 8:2b0d18ebbba9 1295 }
lorded 8:2b0d18ebbba9 1296 count = 0;
lorded 8:2b0d18ebbba9 1297 sendCANCommand(id, msgbytes, 8);
lorded 8:2b0d18ebbba9 1298 int batt = 0;
lorded 8:2b0d18ebbba9 1299 msgbytes[1] = 0x62;
lorded 8:2b0d18ebbba9 1300 while (count++ < 10)
lorded 8:2b0d18ebbba9 1301 {
lorded 8:2b0d18ebbba9 1302 // just expect the ID (0
lorded 8:2b0d18ebbba9 1303 if (doFindExpectedResponse(&rxMsg, resp, msgbytes, 4) > 0)
lorded 8:2b0d18ebbba9 1304 {
lorded 8:2b0d18ebbba9 1305 printCAN(&rxMsg);
lorded 8:2b0d18ebbba9 1306 batt = rxMsg.data[4];
lorded 8:2b0d18ebbba9 1307 batt = batt << 8;
lorded 8:2b0d18ebbba9 1308 batt += rxMsg.data[5];
lorded 8:2b0d18ebbba9 1309 s->battV = batt;
lorded 8:2b0d18ebbba9 1310 }
lorded 8:2b0d18ebbba9 1311 }
lorded 8:2b0d18ebbba9 1312 }
lorded 8:2b0d18ebbba9 1313 void sendGetAltitude(struct sHeatVars *s, char *buff)
lorded 8:2b0d18ebbba9 1314 {
lorded 8:2b0d18ebbba9 1315 //DebugWrite("ALTITUDE******\r\n");
lorded 8:2b0d18ebbba9 1316 int count;
lorded 8:2b0d18ebbba9 1317 CANMessage rxMsg;
lorded 8:2b0d18ebbba9 1318 char msgbytes[8] =
lorded 8:2b0d18ebbba9 1319 { 0x03, 0x22, 0xFD, 0x36, 0x00, 0x00, 0x00, 0x00 };
lorded 8:2b0d18ebbba9 1320 // response is on 73C: 0x05, 0x62, 0xFD, 0x04, [0x00, 0x7D], 0xB0, 0x1C
lorded 8:2b0d18ebbba9 1321 int id;
lorded 8:2b0d18ebbba9 1322 int resp = CTRLRESPONSE;
lorded 8:2b0d18ebbba9 1323 id = CTRLCHANNEL;
lorded 8:2b0d18ebbba9 1324 if (s->heaternum == 2)
lorded 8:2b0d18ebbba9 1325 {
lorded 8:2b0d18ebbba9 1326 id = CTRLCHANNEL2;
lorded 8:2b0d18ebbba9 1327 resp = CTRLRESPONSE2;
lorded 8:2b0d18ebbba9 1328 }
lorded 8:2b0d18ebbba9 1329 count = 0;
lorded 8:2b0d18ebbba9 1330 sendCANCommand(id, msgbytes, 8);
lorded 8:2b0d18ebbba9 1331 int alt = 0;
lorded 8:2b0d18ebbba9 1332 msgbytes[1] = 0x62;
lorded 8:2b0d18ebbba9 1333 while (count++ < 10)
lorded 8:2b0d18ebbba9 1334 {
lorded 8:2b0d18ebbba9 1335 // just expect the ID (0
lorded 8:2b0d18ebbba9 1336 if (doFindExpectedResponse(&rxMsg, resp, msgbytes, 4) > 0)
lorded 8:2b0d18ebbba9 1337 {
lorded 8:2b0d18ebbba9 1338 printCAN(&rxMsg);
lorded 8:2b0d18ebbba9 1339 alt = rxMsg.data[4];
lorded 8:2b0d18ebbba9 1340 alt = alt << 8;
lorded 8:2b0d18ebbba9 1341 alt += rxMsg.data[5];
lorded 8:2b0d18ebbba9 1342 s->altitude = alt / 10;
lorded 8:2b0d18ebbba9 1343 }
lorded 8:2b0d18ebbba9 1344 }
lorded 8:2b0d18ebbba9 1345 //DebugWrite("ALTITUDE******\r\n");
lorded 8:2b0d18ebbba9 1346 }
lorded 8:2b0d18ebbba9 1347
lorded 8:2b0d18ebbba9 1348 void sendGetFault(struct sHeatVars *s, char *buff)
lorded 8:2b0d18ebbba9 1349 {
lorded 8:2b0d18ebbba9 1350 //DebugWrite("Fault command\r\n");
lorded 8:2b0d18ebbba9 1351 CANMessage rxMsg;
lorded 8:2b0d18ebbba9 1352 int count;
lorded 8:2b0d18ebbba9 1353 // 3 bytes, function 19, command 2, mask 8 (all confirmed errors) (failed this cycle)
lorded 8:2b0d18ebbba9 1354 const char msgbytes[8] =
lorded 8:2b0d18ebbba9 1355 { 0x03, 0x19, 0x02, 0x08, 0x00, 0x00, 0x00, 0x00 };
lorded 8:2b0d18ebbba9 1356 const char continuePacket[8] =
lorded 8:2b0d18ebbba9 1357 { 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
lorded 8:2b0d18ebbba9 1358
lorded 8:2b0d18ebbba9 1359 int id;
lorded 8:2b0d18ebbba9 1360 int resp = CTRLRESPONSE;
lorded 8:2b0d18ebbba9 1361 id = CTRLCHANNEL;
lorded 8:2b0d18ebbba9 1362 if (s->heaternum == 2)
lorded 8:2b0d18ebbba9 1363 {
lorded 8:2b0d18ebbba9 1364 id = CTRLCHANNEL2;
lorded 8:2b0d18ebbba9 1365 resp = CTRLRESPONSE2;
lorded 8:2b0d18ebbba9 1366 }
lorded 8:2b0d18ebbba9 1367 count = 0;
lorded 8:2b0d18ebbba9 1368 sendCANCommand(id, msgbytes, 8);
lorded 8:2b0d18ebbba9 1369
lorded 8:2b0d18ebbba9 1370 while (count++ < 10)
lorded 8:2b0d18ebbba9 1371 {
lorded 8:2b0d18ebbba9 1372 // just expect the ID (0
lorded 8:2b0d18ebbba9 1373 if (doFindExpectedResponse(&rxMsg, resp, msgbytes, 0) > 0)
lorded 8:2b0d18ebbba9 1374 {
lorded 8:2b0d18ebbba9 1375 printCAN(&rxMsg);
lorded 8:2b0d18ebbba9 1376 // response in the format 59
lorded 8:2b0d18ebbba9 1377 // the first byte dictates the length
lorded 8:2b0d18ebbba9 1378
lorded 8:2b0d18ebbba9 1379 //073C:03 59 02 7B 05 48 C3 01
lorded 8:2b0d18ebbba9 1380
lorded 8:2b0d18ebbba9 1381 if (rxMsg.data[0] < 0x10)
lorded 8:2b0d18ebbba9 1382 {
lorded 8:2b0d18ebbba9 1383 DebugWrite("Single Message. ");
lorded 8:2b0d18ebbba9 1384 if (rxMsg.data[0] == 0x03)
lorded 8:2b0d18ebbba9 1385 {
lorded 8:2b0d18ebbba9 1386 // 59 is a resonse. Mask info isnt useful because no faults
lorded 8:2b0d18ebbba9 1387 if (rxMsg.data[1] == 0x59)
lorded 8:2b0d18ebbba9 1388 {
lorded 8:2b0d18ebbba9 1389 // no faults
lorded 8:2b0d18ebbba9 1390 if (s->currentError != 0)
lorded 8:2b0d18ebbba9 1391 {
lorded 8:2b0d18ebbba9 1392 s->errorChangeFlag = 1;
lorded 8:2b0d18ebbba9 1393 }
lorded 8:2b0d18ebbba9 1394 sprintf(buff, "NO FAULTS (reset)\r\n");
lorded 8:2b0d18ebbba9 1395 DebugWrite(buff);
lorded 8:2b0d18ebbba9 1396 s->currentError = 0x00;
lorded 8:2b0d18ebbba9 1397 s->errorHistory[0] = 0x0;
lorded 8:2b0d18ebbba9 1398 s->errorHistory[1] = 0x0;
lorded 8:2b0d18ebbba9 1399 s->errorHistory[2] = 0x0;
lorded 8:2b0d18ebbba9 1400 s->errorHistory[3] = 0x0;
lorded 8:2b0d18ebbba9 1401 s->errorHistory[4] = 0x0;
lorded 8:2b0d18ebbba9 1402 s->errorHistory[5] = 0x0;
lorded 9:6126b83608be 1403 break; // out of the loop
lorded 8:2b0d18ebbba9 1404 }
lorded 8:2b0d18ebbba9 1405 }
lorded 8:2b0d18ebbba9 1406 else if ((rxMsg.data[0] == 0x07) && rxMsg.data[1] == 0x59)
lorded 8:2b0d18ebbba9 1407 {
lorded 8:2b0d18ebbba9 1408
lorded 8:2b0d18ebbba9 1409 //ID,073C:07 59 02 7B 00 02 11 2A
lorded 8:2b0d18ebbba9 1410 // 07 length
lorded 8:2b0d18ebbba9 1411 // 59 response
lorded 8:2b0d18ebbba9 1412
lorded 8:2b0d18ebbba9 1413 // one fault. Is it a current fault?
lorded 8:2b0d18ebbba9 1414 if ((rxMsg.data[5] == 0x00) && (rxMsg.data[6] == 0x00))
lorded 8:2b0d18ebbba9 1415 {
lorded 8:2b0d18ebbba9 1416 // the fault isn't a fault.
lorded 8:2b0d18ebbba9 1417 sprintf(buff, "NO FAULTS\r\n");
lorded 8:2b0d18ebbba9 1418 DebugWrite(buff);
lorded 8:2b0d18ebbba9 1419 if (s->currentError != 0)
lorded 8:2b0d18ebbba9 1420 {
lorded 8:2b0d18ebbba9 1421 s->errorChangeFlag = 1;
lorded 8:2b0d18ebbba9 1422 }
lorded 8:2b0d18ebbba9 1423 s->currentError = 0x00;
lorded 8:2b0d18ebbba9 1424 s->errorHistory[0] = 0x0;
lorded 8:2b0d18ebbba9 1425 s->errorHistory[1] = 0x0;
lorded 8:2b0d18ebbba9 1426 s->errorHistory[2] = 0x0;
lorded 8:2b0d18ebbba9 1427 s->errorHistory[3] = 0x0;
lorded 8:2b0d18ebbba9 1428 s->errorHistory[4] = 0x0;
lorded 8:2b0d18ebbba9 1429 s->errorHistory[5] = 0x0;
lorded 8:2b0d18ebbba9 1430 }
lorded 8:2b0d18ebbba9 1431 else
lorded 8:2b0d18ebbba9 1432 {
lorded 8:2b0d18ebbba9 1433
lorded 8:2b0d18ebbba9 1434 //A: 0010 1010 bit 1 is test failed this cycle
lorded 8:2b0d18ebbba9 1435 //B: 0010 1011 bit 0 is test failed. Seems to be considered
lorded 8:2b0d18ebbba9 1436 // active if bit 0 is '1'
lorded 8:2b0d18ebbba9 1437
lorded 8:2b0d18ebbba9 1438 // bit 5 test failed since last clear
lorded 8:2b0d18ebbba9 1439
lorded 8:2b0d18ebbba9 1440 //07 59 02 7B 00 02 11 2A
lorded 8:2b0d18ebbba9 1441
lorded 8:2b0d18ebbba9 1442 uint16_t newError = rxMsg.data[5];
lorded 8:2b0d18ebbba9 1443 newError *= 256;
lorded 8:2b0d18ebbba9 1444 newError += rxMsg.data[6];
lorded 8:2b0d18ebbba9 1445 wiced_bool_t gotAnError = WICED_FALSE;
lorded 8:2b0d18ebbba9 1446 // is it a current fault?
lorded 8:2b0d18ebbba9 1447 if ((rxMsg.data[7] & 0x01) == 0x01)
lorded 8:2b0d18ebbba9 1448 {
lorded 8:2b0d18ebbba9 1449 gotAnError = WICED_TRUE;
lorded 8:2b0d18ebbba9 1450 if (s->currentError != newError)
lorded 8:2b0d18ebbba9 1451 {
lorded 8:2b0d18ebbba9 1452 s->errorChangeFlag = 1;
lorded 8:2b0d18ebbba9 1453 }
lorded 8:2b0d18ebbba9 1454 // active fault
lorded 8:2b0d18ebbba9 1455 s->currentError = newError;
lorded 8:2b0d18ebbba9 1456 }
lorded 8:2b0d18ebbba9 1457 if (!gotAnError)
lorded 8:2b0d18ebbba9 1458 {
lorded 8:2b0d18ebbba9 1459 s->currentError = 0;
lorded 8:2b0d18ebbba9 1460 }
lorded 8:2b0d18ebbba9 1461 // also first history fault
lorded 8:2b0d18ebbba9 1462 s->errorHistory[0] = newError;
lorded 8:2b0d18ebbba9 1463
lorded 8:2b0d18ebbba9 1464 sprintf(buff, "FAULT(h%d): %02X%02X\r\n", s->heaternum, rxMsg.data[5], rxMsg.data[6]);
lorded 8:2b0d18ebbba9 1465 DebugWrite(buff);
lorded 8:2b0d18ebbba9 1466
lorded 8:2b0d18ebbba9 1467 // if (s->currentError != newError)
lorded 8:2b0d18ebbba9 1468 // {
lorded 8:2b0d18ebbba9 1469 // s->errorChangeFlag = 1;
lorded 8:2b0d18ebbba9 1470 // }
lorded 8:2b0d18ebbba9 1471 //errorChangeFlag
lorded 8:2b0d18ebbba9 1472 }
lorded 8:2b0d18ebbba9 1473 }
lorded 8:2b0d18ebbba9 1474 }
lorded 8:2b0d18ebbba9 1475 else if (rxMsg.data[0] < 0x20)
lorded 8:2b0d18ebbba9 1476 {
lorded 8:2b0d18ebbba9 1477
lorded 8:2b0d18ebbba9 1478 int totalLength = rxMsg.data[1];
lorded 8:2b0d18ebbba9 1479 unsigned int totalExpectedPackets = ((totalLength - 7) / 7) + 1;
lorded 8:2b0d18ebbba9 1480 unsigned char dataBytes[6 + totalExpectedPackets * 7];
lorded 8:2b0d18ebbba9 1481 memset(dataBytes, 0, 6 + totalExpectedPackets * 7)
lorded 8:2b0d18ebbba9 1482
lorded 8:2b0d18ebbba9 1483 ;
lorded 8:2b0d18ebbba9 1484 // first packet contains 6 bytes of data, additional contain 7
lorded 8:2b0d18ebbba9 1485 // length 11: 1 extra packet ((11 - 6 - 1) \ 7) + = 4\7 + 1 = 1
lorded 8:2b0d18ebbba9 1486 // length 13: 1 extra packet ((13 - 6 - 1) \ 7) + = 6\7 + 1 = 1
lorded 8:2b0d18ebbba9 1487 // length 14: 2 packets ((14 - 6 - 1) \ 7) + = 7\7 + 1 = 2
lorded 8:2b0d18ebbba9 1488 // length 20: 2 packets ((20 - 6 - 1) \ 7) + = 7\7 + 1 = 2
lorded 8:2b0d18ebbba9 1489 // length 21: 3 packets ((21 - 6 - 1) \ 7) + = 7\7 + 1 = 3
lorded 8:2b0d18ebbba9 1490 // Packets = lenght is ((length - 7) \ 7) + 1
lorded 8:2b0d18ebbba9 1491
lorded 8:2b0d18ebbba9 1492 // sprintf(buff, "multi message start, length %d\r\n", rxMsg.data[1]);
lorded 8:2b0d18ebbba9 1493 // DebugWrite(buff);
lorded 8:2b0d18ebbba9 1494
lorded 8:2b0d18ebbba9 1495 printCAN(&rxMsg);
lorded 8:2b0d18ebbba9 1496 /*Query 03 19 02 08
lorded 8:2b0d18ebbba9 1497 * ID,073C:[10 0B] [59 02] [7B] 00 02 11]
lorded 8:2b0d18ebbba9 1498 * ID,073C:21 2B 00 02 A1 2A xx xx
lorded 8:2b0d18ebbba9 1499 * 10: Multi message start packet
lorded 8:2b0d18ebbba9 1500 * 0B: Length (11 DATA bytes). x'd out non-data
lorded 8:2b0d18ebbba9 1501 * 59: response type 59
lorded 8:2b0d18ebbba9 1502 * 02: subfunction 2
lorded 8:2b0d18ebbba9 1503 * 7B: mask
lorded 8:2b0d18ebbba9 1504 * 00 02 11: first 3 bytes of fault. Need next part
lorded 8:2b0d18ebbba9 1505 */
lorded 8:2b0d18ebbba9 1506 // get the first fault code, bytes 4-7
lorded 8:2b0d18ebbba9 1507 sendCANCommand(id, continuePacket, 8);
lorded 8:2b0d18ebbba9 1508 CANMessage additionalRxMsg[totalExpectedPackets];
lorded 8:2b0d18ebbba9 1509 int currentPacket = 0;
lorded 8:2b0d18ebbba9 1510 while (count++ < 10)
lorded 8:2b0d18ebbba9 1511 {
lorded 8:2b0d18ebbba9 1512 if (doFindExpectedResponse(&(additionalRxMsg[currentPacket]), resp, msgbytes, 0) > 0)
lorded 8:2b0d18ebbba9 1513 {
lorded 8:2b0d18ebbba9 1514 count = 0;
lorded 8:2b0d18ebbba9 1515 currentPacket++;
lorded 8:2b0d18ebbba9 1516 if (currentPacket >= totalExpectedPackets)
lorded 8:2b0d18ebbba9 1517 {
lorded 8:2b0d18ebbba9 1518 DebugWrite("Found all additional packets\r\n");
lorded 8:2b0d18ebbba9 1519
lorded 8:2b0d18ebbba9 1520 memcpy(dataBytes, rxMsg.data + 2, 6); // 6 initial data bytes
lorded 8:2b0d18ebbba9 1521 for (int i = 0; i < totalExpectedPackets; i++)
lorded 8:2b0d18ebbba9 1522 {
lorded 8:2b0d18ebbba9 1523 sprintf(printbuff, "- copying packet %d to databytes + %d\r\n", i, 6 + (i) * 7);
lorded 8:2b0d18ebbba9 1524 DebugWrite(printbuff);
lorded 8:2b0d18ebbba9 1525 memcpy(dataBytes + 6 + ((i) * 7), additionalRxMsg[i].data + 1, 7);
lorded 8:2b0d18ebbba9 1526
lorded 8:2b0d18ebbba9 1527 }
lorded 8:2b0d18ebbba9 1528 DebugWrite("Data bytes: ");
lorded 8:2b0d18ebbba9 1529 for (int i = 0; i < totalLength; i++)
lorded 8:2b0d18ebbba9 1530 {
lorded 8:2b0d18ebbba9 1531 sprintf(buff, "%02X ", dataBytes[i]);
lorded 8:2b0d18ebbba9 1532 DebugWrite(buff);
lorded 8:2b0d18ebbba9 1533 }
lorded 8:2b0d18ebbba9 1534 DebugWrite("\r\n");
lorded 8:2b0d18ebbba9 1535
lorded 8:2b0d18ebbba9 1536 uint16_t newError;
lorded 8:2b0d18ebbba9 1537 wiced_bool_t gotAnError = WICED_FALSE;
lorded 8:2b0d18ebbba9 1538 //Data bytes: 59 02 7B [00 02 11 2B] [00 02 A1 28]
lorded 8:2b0d18ebbba9 1539
lorded 8:2b0d18ebbba9 1540 for (int i = 0; i < 6; i++)
lorded 8:2b0d18ebbba9 1541 {
lorded 8:2b0d18ebbba9 1542 s->errorHistory[i] = 0;
lorded 8:2b0d18ebbba9 1543 }
lorded 8:2b0d18ebbba9 1544 for (int i = 3; i < totalLength; i += 4)
lorded 8:2b0d18ebbba9 1545 {
lorded 8:2b0d18ebbba9 1546 newError = dataBytes[i + 1];
lorded 8:2b0d18ebbba9 1547 newError *= 256;
lorded 8:2b0d18ebbba9 1548 newError += dataBytes[i + 2];
lorded 8:2b0d18ebbba9 1549
lorded 8:2b0d18ebbba9 1550 // is it a current fault?
lorded 8:2b0d18ebbba9 1551 if ((dataBytes[i + 3] & 0x01) == 0x01)
lorded 8:2b0d18ebbba9 1552 {
lorded 8:2b0d18ebbba9 1553 gotAnError = WICED_TRUE;
lorded 8:2b0d18ebbba9 1554 if (s->currentError != newError)
lorded 8:2b0d18ebbba9 1555 {
lorded 8:2b0d18ebbba9 1556 s->errorChangeFlag = 1;
lorded 8:2b0d18ebbba9 1557 }
lorded 8:2b0d18ebbba9 1558 // active fault
lorded 8:2b0d18ebbba9 1559 s->currentError = newError;
lorded 8:2b0d18ebbba9 1560 }
lorded 8:2b0d18ebbba9 1561 // history fault
lorded 8:2b0d18ebbba9 1562 if (((i - 3) / 4) < 6)
lorded 8:2b0d18ebbba9 1563 {
lorded 8:2b0d18ebbba9 1564 s->errorHistory[(i - 3) / 4] = newError;
lorded 8:2b0d18ebbba9 1565 }
lorded 8:2b0d18ebbba9 1566
lorded 8:2b0d18ebbba9 1567 sprintf(buff, "FAULT: %02X%02X\r\n", dataBytes[i + 1], dataBytes[i + 2]);
lorded 8:2b0d18ebbba9 1568 DebugWrite(buff);
lorded 8:2b0d18ebbba9 1569 }
lorded 8:2b0d18ebbba9 1570 if (!gotAnError)
lorded 8:2b0d18ebbba9 1571 {
lorded 8:2b0d18ebbba9 1572 s->currentError = 0; // no error to start.
lorded 8:2b0d18ebbba9 1573 }
lorded 8:2b0d18ebbba9 1574 // clear the remainder
lorded 8:2b0d18ebbba9 1575 break;
lorded 8:2b0d18ebbba9 1576 }
lorded 8:2b0d18ebbba9 1577 }
lorded 8:2b0d18ebbba9 1578 }
lorded 8:2b0d18ebbba9 1579 }
lorded 8:2b0d18ebbba9 1580 }
lorded 9:6126b83608be 1581 } // while
lorded 8:2b0d18ebbba9 1582 printf("f-b\r\n");
lorded 8:2b0d18ebbba9 1583 if (count >= 10)
lorded 8:2b0d18ebbba9 1584 {
lorded 8:2b0d18ebbba9 1585 printf("FAILED\r\n");
lorded 8:2b0d18ebbba9 1586 return;
lorded 8:2b0d18ebbba9 1587 }
lorded 8:2b0d18ebbba9 1588 printf("f-c\r\n");
lorded 8:2b0d18ebbba9 1589 if ((rxMsg.data[0] == 0x03) && (rxMsg.data[1] == 0x59) && (rxMsg.data[5] == 0x56) && (rxMsg.data[6] == 0x78))
lorded 8:2b0d18ebbba9 1590 {
lorded 8:2b0d18ebbba9 1591
lorded 8:2b0d18ebbba9 1592 if (s->currentError != 0)
lorded 8:2b0d18ebbba9 1593 {
lorded 8:2b0d18ebbba9 1594 s->errorChangeFlag = 1;
lorded 8:2b0d18ebbba9 1595 }
lorded 8:2b0d18ebbba9 1596 sprintf(buff, "NO FAULTS (reset)\r\n");
lorded 8:2b0d18ebbba9 1597 DebugWrite(buff);
lorded 8:2b0d18ebbba9 1598 s->currentError = 0x00;
lorded 8:2b0d18ebbba9 1599 s->errorHistory[0] = 0x0;
lorded 8:2b0d18ebbba9 1600 s->errorHistory[0] = 0x0;
lorded 8:2b0d18ebbba9 1601 s->errorHistory[0] = 0x0;
lorded 8:2b0d18ebbba9 1602 s->errorHistory[0] = 0x0;
lorded 8:2b0d18ebbba9 1603 s->errorHistory[0] = 0x0;
lorded 8:2b0d18ebbba9 1604 s->errorHistory[0] = 0x0;
lorded 8:2b0d18ebbba9 1605 }
lorded 8:2b0d18ebbba9 1606 else if ((rxMsg.data[0] == 0x03) && (rxMsg.data[1] == 0x59) && (rxMsg.data[5] == 0x00) && (rxMsg.data[6] == 0x00))
lorded 8:2b0d18ebbba9 1607 {
lorded 8:2b0d18ebbba9 1608 if (s->currentError != 0)
lorded 8:2b0d18ebbba9 1609 {
lorded 8:2b0d18ebbba9 1610 s->errorChangeFlag = 1;
lorded 8:2b0d18ebbba9 1611 }
lorded 8:2b0d18ebbba9 1612 sprintf(buff, "NO FAULTS(1)\r\n");
lorded 8:2b0d18ebbba9 1613 DebugWrite(buff);
lorded 8:2b0d18ebbba9 1614 s->currentError = 0x00;
lorded 8:2b0d18ebbba9 1615 s->errorHistory[0] = 0x0;
lorded 8:2b0d18ebbba9 1616 s->errorHistory[0] = 0x0;
lorded 8:2b0d18ebbba9 1617 s->errorHistory[0] = 0x0;
lorded 8:2b0d18ebbba9 1618 s->errorHistory[0] = 0x0;
lorded 8:2b0d18ebbba9 1619 s->errorHistory[0] = 0x0;
lorded 8:2b0d18ebbba9 1620 s->errorHistory[0] = 0x0;
lorded 8:2b0d18ebbba9 1621 }
lorded 8:2b0d18ebbba9 1622 else if ((rxMsg.data[0] == 0x07) && (rxMsg.data[1] == 0x59) && (rxMsg.data[2] == 0x02))
lorded 8:2b0d18ebbba9 1623 {
lorded 8:2b0d18ebbba9 1624 if ((rxMsg.data[5] == 0x00) && (rxMsg.data[6] == 0x00))
lorded 8:2b0d18ebbba9 1625 {
lorded 8:2b0d18ebbba9 1626 sprintf(buff, "NO FAULTS\r\n");
lorded 8:2b0d18ebbba9 1627 DebugWrite(buff);
lorded 8:2b0d18ebbba9 1628 if (s->currentError != 0)
lorded 8:2b0d18ebbba9 1629 {
lorded 8:2b0d18ebbba9 1630 s->errorChangeFlag = 1;
lorded 8:2b0d18ebbba9 1631 }
lorded 8:2b0d18ebbba9 1632 s->currentError = 0x00;
lorded 8:2b0d18ebbba9 1633 s->errorHistory[0] = 0x0;
lorded 8:2b0d18ebbba9 1634 s->errorHistory[1] = 0x0;
lorded 8:2b0d18ebbba9 1635 s->errorHistory[2] = 0x0;
lorded 8:2b0d18ebbba9 1636 s->errorHistory[3] = 0x0;
lorded 8:2b0d18ebbba9 1637 s->errorHistory[4] = 0x0;
lorded 8:2b0d18ebbba9 1638 s->errorHistory[5] = 0x0;
lorded 8:2b0d18ebbba9 1639 }
lorded 8:2b0d18ebbba9 1640 else
lorded 8:2b0d18ebbba9 1641 {
lorded 8:2b0d18ebbba9 1642 sprintf(buff, "FAULT: %02X%02X\r\n", rxMsg.data[5], rxMsg.data[6]);
lorded 8:2b0d18ebbba9 1643 DebugWrite(buff);
lorded 8:2b0d18ebbba9 1644 uint16_t newError = rxMsg.data[5];
lorded 8:2b0d18ebbba9 1645 newError *= 256;
lorded 8:2b0d18ebbba9 1646 newError += rxMsg.data[6];
lorded 8:2b0d18ebbba9 1647 if (s->currentError != newError)
lorded 8:2b0d18ebbba9 1648 {
lorded 8:2b0d18ebbba9 1649 s->errorChangeFlag = 1;
lorded 8:2b0d18ebbba9 1650 }
lorded 8:2b0d18ebbba9 1651 //errorChangeFlag
lorded 8:2b0d18ebbba9 1652 s->currentError = newError;
lorded 8:2b0d18ebbba9 1653 s->errorHistory[0] = newError;
lorded 8:2b0d18ebbba9 1654 }
lorded 8:2b0d18ebbba9 1655 printf("SUCCESS\r\n");
lorded 8:2b0d18ebbba9 1656 }
lorded 8:2b0d18ebbba9 1657 else if ((rxMsg.data[0] == 0x03) && (rxMsg.data[1] == 0x59) && (rxMsg.data[2] == 0x02))
lorded 8:2b0d18ebbba9 1658 {
lorded 8:2b0d18ebbba9 1659 // this means cleared in both cases!
lorded 8:2b0d18ebbba9 1660 if (s->currentError != 0)
lorded 8:2b0d18ebbba9 1661 {
lorded 8:2b0d18ebbba9 1662 s->errorChangeFlag = 1;
lorded 8:2b0d18ebbba9 1663 }
lorded 8:2b0d18ebbba9 1664 sprintf(buff, "NO FAULTS(2)\r\n");
lorded 8:2b0d18ebbba9 1665 DebugWrite(buff);
lorded 8:2b0d18ebbba9 1666 s->currentError = 0x00;
lorded 8:2b0d18ebbba9 1667 s->errorHistory[0] = 0x0;
lorded 8:2b0d18ebbba9 1668 s->errorHistory[1] = 0x0;
lorded 8:2b0d18ebbba9 1669 s->errorHistory[2] = 0x0;
lorded 8:2b0d18ebbba9 1670 s->errorHistory[3] = 0x0;
lorded 8:2b0d18ebbba9 1671 s->errorHistory[4] = 0x0;
lorded 8:2b0d18ebbba9 1672 s->errorHistory[5] = 0x0;
lorded 8:2b0d18ebbba9 1673 }
lorded 8:2b0d18ebbba9 1674 else if ((rxMsg.data[0] == 0x10) && (rxMsg.data[1] == 0x0B))
lorded 8:2b0d18ebbba9 1675 {
lorded 8:2b0d18ebbba9 1676 sprintf(buff, " MULTI FAULT: %02X%02X\r\n", rxMsg.data[6], rxMsg.data[7]);
lorded 8:2b0d18ebbba9 1677 DebugWrite(buff);
lorded 8:2b0d18ebbba9 1678 uint16_t newError = rxMsg.data[6];
lorded 8:2b0d18ebbba9 1679 newError *= 256;
lorded 8:2b0d18ebbba9 1680 newError += rxMsg.data[7];
lorded 8:2b0d18ebbba9 1681 if (s->currentError != newError)
lorded 8:2b0d18ebbba9 1682 {
lorded 8:2b0d18ebbba9 1683 s->errorChangeFlag = 1;
lorded 8:2b0d18ebbba9 1684 }
lorded 8:2b0d18ebbba9 1685 s->currentError = newError;
lorded 8:2b0d18ebbba9 1686 s->errorHistory[0] = newError;
lorded 8:2b0d18ebbba9 1687 }
lorded 8:2b0d18ebbba9 1688 else
lorded 8:2b0d18ebbba9 1689 {
lorded 8:2b0d18ebbba9 1690 sprintf(buff, "OTHER RESPONSE\r\n");
lorded 8:2b0d18ebbba9 1691 DebugWrite(buff);
lorded 8:2b0d18ebbba9 1692 printCAN(&rxMsg);
lorded 8:2b0d18ebbba9 1693 }
lorded 8:2b0d18ebbba9 1694 printf("f-d\r\n");
lorded 8:2b0d18ebbba9 1695 }
lorded 8:2b0d18ebbba9 1696
lorded 8:2b0d18ebbba9 1697 void readCAN(struct sHeatVars *s)
lorded 8:2b0d18ebbba9 1698 {
lorded 8:2b0d18ebbba9 1699 // find the heater to update in some cases
lorded 8:2b0d18ebbba9 1700 int count = 0;
lorded 8:2b0d18ebbba9 1701 struct sHeatVars* heaterToUpdate = NULL;
lorded 8:2b0d18ebbba9 1702 //DebugWrite("read\r\n");
lorded 8:2b0d18ebbba9 1703 CANMessage canMsg;
lorded 8:2b0d18ebbba9 1704
lorded 8:2b0d18ebbba9 1705 int incoming = can2.read(canMsg);
lorded 8:2b0d18ebbba9 1706 while ((incoming > 0) && (count++ < 10))
lorded 8:2b0d18ebbba9 1707 {
lorded 8:2b0d18ebbba9 1708
lorded 8:2b0d18ebbba9 1709 // start blank
lorded 10:a82e51837e2b 1710 if ((canMsg.id == 0x0055)) {
lorded 10:a82e51837e2b 1711 // sub our own
lorded 10:a82e51837e2b 1712 DebugWrite("SUBSTITUTE ALTITUDE CMD\r\n");
lorded 10:a82e51837e2b 1713 sendAltitudeMode(s);
lorded 10:a82e51837e2b 1714 }
lorded 10:a82e51837e2b 1715 if ((canMsg.id == 0x07A0) || (canMsg.id == 0x060D) || (canMsg.id == 0x0057) )
lorded 8:2b0d18ebbba9 1716 {
lorded 10:a82e51837e2b 1717 otherControllerDetected = 300;
lorded 8:2b0d18ebbba9 1718 DebugWrite("\r\n****OTHER CONTROLLER ON NETWORK*****\r\n");
lorded 8:2b0d18ebbba9 1719 }
lorded 8:2b0d18ebbba9 1720 if (((canMsg.id != 0x0625) && (canMsg.id != 0x02C4)) && (canMsg.id != 0x02C6) && (canMsg.id != 0x0626) && (canMsg.id != 0x02D0)
lorded 8:2b0d18ebbba9 1721 && (canMsg.id != 0x02CE))
lorded 8:2b0d18ebbba9 1722 {
lorded 10:a82e51837e2b 1723
lorded 10:a82e51837e2b 1724 DebugWrite("0-");
lorded 10:a82e51837e2b 1725 printCAN(&canMsg);
lorded 8:2b0d18ebbba9 1726 }
lorded 8:2b0d18ebbba9 1727 else if ((canMsg.id == 0x0625) || (canMsg.id == 0x0626))
lorded 8:2b0d18ebbba9 1728 {
lorded 8:2b0d18ebbba9 1729 if ((canMsg.id == 0x0625) && (heaterState[0].bustype == HEATERTYPECAN) && (heaterState[0].heaternum == 1))
lorded 8:2b0d18ebbba9 1730 {
lorded 8:2b0d18ebbba9 1731 heaterToUpdate = &(heaterState[0]);
lorded 8:2b0d18ebbba9 1732 }
lorded 8:2b0d18ebbba9 1733 else if ((canMsg.id == 0x0626) && (heaterState[0].bustype == HEATERTYPECAN) && (heaterState[0].heaternum == 2))
lorded 8:2b0d18ebbba9 1734 {
lorded 8:2b0d18ebbba9 1735 heaterToUpdate = &(heaterState[0]);
lorded 8:2b0d18ebbba9 1736 }
lorded 8:2b0d18ebbba9 1737 heaterToUpdate->heaterDetected = 60; // preserve for a min.
lorded 8:2b0d18ebbba9 1738 // unpack and document
lorded 8:2b0d18ebbba9 1739 NM_Heater_1_t heaterInfo;
lorded 8:2b0d18ebbba9 1740 Unpack_NM_Heater_1_mydbc(&heaterInfo, canMsg.data, 0);
lorded 8:2b0d18ebbba9 1741 //DebugWrite("NM_HEATER_");
lorded 8:2b0d18ebbba9 1742
lorded 8:2b0d18ebbba9 1743 /*
lorded 8:2b0d18ebbba9 1744 sprintf(printbuff, "%d,%lu,", heaterToUpdate->heaternum, heaterInfo.SerialNumber);
lorded 8:2b0d18ebbba9 1745 DebugWrite(printbuff);
lorded 8:2b0d18ebbba9 1746 if (heaterInfo.HeaterInitFinished)
lorded 8:2b0d18ebbba9 1747 {
lorded 8:2b0d18ebbba9 1748 DebugWrite("DoneInit,");
lorded 8:2b0d18ebbba9 1749 }
lorded 8:2b0d18ebbba9 1750 else
lorded 8:2b0d18ebbba9 1751 {
lorded 8:2b0d18ebbba9 1752 DebugWrite("NOINIT,");
lorded 8:2b0d18ebbba9 1753 }
lorded 8:2b0d18ebbba9 1754 */
lorded 8:2b0d18ebbba9 1755 if (heaterInfo.HeaterType == 0)
lorded 8:2b0d18ebbba9 1756 {
lorded 8:2b0d18ebbba9 1757 // DebugWrite("Air,");
lorded 8:2b0d18ebbba9 1758 if (heaterToUpdate->setpoint == 0)
lorded 8:2b0d18ebbba9 1759 {
lorded 8:2b0d18ebbba9 1760 heaterToUpdate->setpoint = 250;
lorded 8:2b0d18ebbba9 1761 }
lorded 8:2b0d18ebbba9 1762 }
lorded 8:2b0d18ebbba9 1763 else if (heaterInfo.HeaterType == 1)
lorded 8:2b0d18ebbba9 1764 {
lorded 8:2b0d18ebbba9 1765 // DebugWrite("Water,");
lorded 8:2b0d18ebbba9 1766 heaterToUpdate->setpoint = 0;
lorded 8:2b0d18ebbba9 1767 }
lorded 8:2b0d18ebbba9 1768 else
lorded 8:2b0d18ebbba9 1769 {
lorded 8:2b0d18ebbba9 1770 // DebugWrite("Unknown,");
lorded 8:2b0d18ebbba9 1771 }
lorded 8:2b0d18ebbba9 1772 if (heaterInfo.AltitudeSensorOnBoard)
lorded 8:2b0d18ebbba9 1773 {
lorded 8:2b0d18ebbba9 1774 // DebugWrite("OB Alt,");
lorded 8:2b0d18ebbba9 1775 heaterToUpdate->OBAltitude = WICED_TRUE;
lorded 8:2b0d18ebbba9 1776 }
lorded 8:2b0d18ebbba9 1777 else
lorded 8:2b0d18ebbba9 1778 {
lorded 8:2b0d18ebbba9 1779 // DebugWrite("NO OB ALT,");
lorded 8:2b0d18ebbba9 1780 heaterToUpdate->OBAltitude = WICED_FALSE;
lorded 8:2b0d18ebbba9 1781 }
lorded 8:2b0d18ebbba9 1782 /*(
lorded 8:2b0d18ebbba9 1783 if (heaterInfo.OperateEasyFan)
lorded 8:2b0d18ebbba9 1784 {
lorded 8:2b0d18ebbba9 1785 DebugWrite("EZFAN,");
lorded 8:2b0d18ebbba9 1786 }
lorded 8:2b0d18ebbba9 1787 else
lorded 8:2b0d18ebbba9 1788 {
lorded 8:2b0d18ebbba9 1789 DebugWrite("NO-EZFAN,");
lorded 8:2b0d18ebbba9 1790 }
lorded 8:2b0d18ebbba9 1791 sprintf(printbuff, "Op:%u,", heaterInfo.OperatingModes);
lorded 8:2b0d18ebbba9 1792 DebugWrite(printbuff);
lorded 8:2b0d18ebbba9 1793
lorded 8:2b0d18ebbba9 1794 DebugWrite(",");
lorded 8:2b0d18ebbba9 1795 DebugWrite("\r\n");
lorded 8:2b0d18ebbba9 1796 */
lorded 8:2b0d18ebbba9 1797 }
lorded 8:2b0d18ebbba9 1798 else if ((canMsg.id == 0x02C6) || (canMsg.id == 0x02D0))
lorded 8:2b0d18ebbba9 1799 {
lorded 8:2b0d18ebbba9 1800
lorded 8:2b0d18ebbba9 1801 if (canMsg.id == 0x02C6)
lorded 8:2b0d18ebbba9 1802 {
lorded 8:2b0d18ebbba9 1803 if ((heaterState[0].bustype == HEATERTYPECAN) && (heaterState[0].heaternum == 1))
lorded 8:2b0d18ebbba9 1804 {
lorded 8:2b0d18ebbba9 1805 heaterToUpdate = &(heaterState[0]);
lorded 8:2b0d18ebbba9 1806 }
lorded 8:2b0d18ebbba9 1807 else
lorded 8:2b0d18ebbba9 1808 {
lorded 8:2b0d18ebbba9 1809 DebugWrite("Unable to update 0x02C6\r\n");
lorded 8:2b0d18ebbba9 1810 }
lorded 8:2b0d18ebbba9 1811 }
lorded 8:2b0d18ebbba9 1812 else if (canMsg.id == 0x02D0)
lorded 8:2b0d18ebbba9 1813 {
lorded 8:2b0d18ebbba9 1814 if ((heaterState[0].bustype == HEATERTYPECAN) && (heaterState[0].heaternum == 2))
lorded 8:2b0d18ebbba9 1815 {
lorded 8:2b0d18ebbba9 1816 heaterToUpdate = &(heaterState[0]);
lorded 8:2b0d18ebbba9 1817 }
lorded 8:2b0d18ebbba9 1818 else
lorded 8:2b0d18ebbba9 1819 {
lorded 8:2b0d18ebbba9 1820 DebugWrite("Unable to update 0x02D0\r\n");
lorded 8:2b0d18ebbba9 1821 }
lorded 8:2b0d18ebbba9 1822 }
lorded 8:2b0d18ebbba9 1823 if (heaterToUpdate == NULL)
lorded 8:2b0d18ebbba9 1824 {
lorded 8:2b0d18ebbba9 1825 DebugWrite("HEATERTOUPDATENULL\r\n");
lorded 8:2b0d18ebbba9 1826 return;
lorded 8:2b0d18ebbba9 1827 }
lorded 8:2b0d18ebbba9 1828 int lowRange = canMsg.data[1];
lorded 8:2b0d18ebbba9 1829 lowRange = lowRange << 8;
lorded 8:2b0d18ebbba9 1830 lowRange += canMsg.data[0];
lorded 8:2b0d18ebbba9 1831
lorded 8:2b0d18ebbba9 1832 int highRange = canMsg.data[3];
lorded 8:2b0d18ebbba9 1833 highRange = highRange << 8;
lorded 8:2b0d18ebbba9 1834 highRange += canMsg.data[2];
lorded 8:2b0d18ebbba9 1835 if (lowRange > highRange)
lorded 8:2b0d18ebbba9 1836 {
lorded 8:2b0d18ebbba9 1837 int temp = lowRange;
lorded 8:2b0d18ebbba9 1838 lowRange = highRange;
lorded 8:2b0d18ebbba9 1839 highRange = temp;
lorded 8:2b0d18ebbba9 1840 }
lorded 8:2b0d18ebbba9 1841
lorded 8:2b0d18ebbba9 1842 //sprintf(printbuff, "Temp range %d - %d heater %d\r\n", lowRange, highRange, heaterToUpdate->heaternum);
lorded 8:2b0d18ebbba9 1843 //DebugWrite(printbuff);
lorded 8:2b0d18ebbba9 1844 //printCAN(&canMsg);
lorded 8:2b0d18ebbba9 1845
lorded 8:2b0d18ebbba9 1846 /*
lorded 8:2b0d18ebbba9 1847 * now detected by heater NM command
lorded 8:2b0d18ebbba9 1848 if (heaterToUpdate->heaternum == 2)
lorded 8:2b0d18ebbba9 1849 {
lorded 8:2b0d18ebbba9 1850 // eventually replace with the equivalent of 0x0625
lorded 8:2b0d18ebbba9 1851 if (highRange > 500)
lorded 8:2b0d18ebbba9 1852 {
lorded 8:2b0d18ebbba9 1853 //sprintf(printbuff, "heater %d setpoint > 500\r\n", heaterToUpdate->heaternum);
lorded 8:2b0d18ebbba9 1854 //DebugWrite(printbuff);
lorded 8:2b0d18ebbba9 1855 heaterToUpdate->setpoint = 0;
lorded 8:2b0d18ebbba9 1856
lorded 8:2b0d18ebbba9 1857 // fluid heater
lorded 8:2b0d18ebbba9 1858 }
lorded 8:2b0d18ebbba9 1859 else
lorded 8:2b0d18ebbba9 1860 {
lorded 8:2b0d18ebbba9 1861 //
lorded 8:2b0d18ebbba9 1862 if (heaterToUpdate->setpoint == 0)
lorded 8:2b0d18ebbba9 1863 {
lorded 8:2b0d18ebbba9 1864 // sprintf(printbuff, "heater %d setpoint 250", heaterToUpdate->heaternum);
lorded 8:2b0d18ebbba9 1865 // DebugWrite(printbuff);
lorded 8:2b0d18ebbba9 1866
lorded 8:2b0d18ebbba9 1867 heaterToUpdate->setpoint = 250; // default value. Ignored mostly in CAN land.
lorded 8:2b0d18ebbba9 1868 }
lorded 8:2b0d18ebbba9 1869 }
lorded 8:2b0d18ebbba9 1870 }
lorded 8:2b0d18ebbba9 1871 */
lorded 8:2b0d18ebbba9 1872 }
lorded 8:2b0d18ebbba9 1873 else if ((canMsg.id == 0x02C4) || (canMsg.id == 0x02CE))
lorded 8:2b0d18ebbba9 1874 {
lorded 8:2b0d18ebbba9 1875 int heater = 1;
lorded 8:2b0d18ebbba9 1876 if (canMsg.id == 0x02CE)
lorded 8:2b0d18ebbba9 1877 {
lorded 8:2b0d18ebbba9 1878 heater = 2;
lorded 8:2b0d18ebbba9 1879 }
lorded 8:2b0d18ebbba9 1880 if ((heaterState[0].bustype == HEATERTYPECAN) && (heaterState[0].heaternum == heater))
lorded 8:2b0d18ebbba9 1881 {
lorded 8:2b0d18ebbba9 1882 heaterToUpdate = &(heaterState[0]);
lorded 8:2b0d18ebbba9 1883 }
lorded 8:2b0d18ebbba9 1884 else
lorded 8:2b0d18ebbba9 1885 {
lorded 8:2b0d18ebbba9 1886 DebugWrite("Unable to update 0x02C6\r\n");
lorded 8:2b0d18ebbba9 1887 }
lorded 8:2b0d18ebbba9 1888 //DebugWrite("OBK_STATUS_HEATER_1\r\n");
lorded 8:2b0d18ebbba9 1889 OBK_Status_Heater_1_t heaterStatus;
lorded 8:2b0d18ebbba9 1890 Unpack_OBK_Status_Heater_1_mydbc(&heaterStatus, canMsg.data, 0);
lorded 8:2b0d18ebbba9 1891
lorded 8:2b0d18ebbba9 1892 heaterToUpdate->heaterTemp = heaterStatus.HeaterTemperature;
lorded 8:2b0d18ebbba9 1893 //sprintf(printbuff, "OBK_STATUS_HEATER_%d,temp %ld,", heater, heaterStatus.HeaterTemperature);
lorded 8:2b0d18ebbba9 1894 //DebugWrite(printbuff);
lorded 8:2b0d18ebbba9 1895 if (heaterStatus.isValid)
lorded 8:2b0d18ebbba9 1896 {
lorded 8:2b0d18ebbba9 1897 DebugWrite("Valid,");
lorded 8:2b0d18ebbba9 1898 }
lorded 8:2b0d18ebbba9 1899 else
lorded 8:2b0d18ebbba9 1900 {
lorded 8:2b0d18ebbba9 1901 DebugWrite("!Valid,");
lorded 8:2b0d18ebbba9 1902 }
lorded 8:2b0d18ebbba9 1903 if (heaterStatus.noHeatModeActive)
lorded 8:2b0d18ebbba9 1904 {
lorded 8:2b0d18ebbba9 1905 DebugWrite("NOHEAT,");
lorded 8:2b0d18ebbba9 1906 heaterToUpdate->heatCallDetected = WICED_FALSE;
lorded 8:2b0d18ebbba9 1907 }
lorded 8:2b0d18ebbba9 1908 if (heaterStatus.standbyHeatingActive)
lorded 8:2b0d18ebbba9 1909 {
lorded 8:2b0d18ebbba9 1910 DebugWrite("STANBYHEAT,");
lorded 8:2b0d18ebbba9 1911 heaterToUpdate->heatCallDetected = WICED_TRUE;
lorded 8:2b0d18ebbba9 1912 }
lorded 8:2b0d18ebbba9 1913 if (heaterStatus.standbyHeatingWithSetpointActive)
lorded 8:2b0d18ebbba9 1914 {
lorded 8:2b0d18ebbba9 1915 DebugWrite("STANDBYHEATSETPOINT,");
lorded 8:2b0d18ebbba9 1916 heaterToUpdate->heatCallDetected = WICED_TRUE;
lorded 8:2b0d18ebbba9 1917 }
lorded 8:2b0d18ebbba9 1918 if (heaterStatus.ResidualHeat > 0)
lorded 8:2b0d18ebbba9 1919 {
lorded 8:2b0d18ebbba9 1920 DebugWrite("RESIDUAL,");
lorded 8:2b0d18ebbba9 1921 }
lorded 8:2b0d18ebbba9 1922 if (heaterStatus.ErrorClass1)
lorded 8:2b0d18ebbba9 1923 {
lorded 8:2b0d18ebbba9 1924 DebugWrite("F1,");
lorded 8:2b0d18ebbba9 1925 }
lorded 8:2b0d18ebbba9 1926 if (heaterStatus.ErrorClass2)
lorded 8:2b0d18ebbba9 1927 {
lorded 8:2b0d18ebbba9 1928 DebugWrite("F2,");
lorded 8:2b0d18ebbba9 1929 }
lorded 8:2b0d18ebbba9 1930 if (heaterStatus.ErrorClass3)
lorded 8:2b0d18ebbba9 1931 {
lorded 8:2b0d18ebbba9 1932 DebugWrite("F3,");
lorded 8:2b0d18ebbba9 1933 }
lorded 8:2b0d18ebbba9 1934 if (heaterStatus.ErrorClass4)
lorded 8:2b0d18ebbba9 1935 {
lorded 8:2b0d18ebbba9 1936 DebugWrite("F4,");
lorded 8:2b0d18ebbba9 1937 }
lorded 8:2b0d18ebbba9 1938 if (heaterStatus.ErrorClass5)
lorded 8:2b0d18ebbba9 1939 {
lorded 8:2b0d18ebbba9 1940 DebugWrite("F5,");
lorded 8:2b0d18ebbba9 1941 }
lorded 8:2b0d18ebbba9 1942 if (heaterStatus.ErrorClass6)
lorded 8:2b0d18ebbba9 1943 {
lorded 8:2b0d18ebbba9 1944 DebugWrite("F6,");
lorded 8:2b0d18ebbba9 1945 }
lorded 8:2b0d18ebbba9 1946 if (heaterStatus.HeatingUpActive)
lorded 8:2b0d18ebbba9 1947 {
lorded 8:2b0d18ebbba9 1948 DebugWrite("HUA,");
lorded 8:2b0d18ebbba9 1949 }
lorded 8:2b0d18ebbba9 1950 if (heaterStatus.SetpointInvalid)
lorded 8:2b0d18ebbba9 1951 {
lorded 8:2b0d18ebbba9 1952 DebugWrite("SetpointInvalid,");
lorded 8:2b0d18ebbba9 1953 }
lorded 8:2b0d18ebbba9 1954 else
lorded 8:2b0d18ebbba9 1955 {
lorded 8:2b0d18ebbba9 1956 DebugWrite("SetpointValid,");
lorded 8:2b0d18ebbba9 1957 }
lorded 8:2b0d18ebbba9 1958 if (heaterStatus.AltitudeModeActive)
lorded 8:2b0d18ebbba9 1959 {
lorded 8:2b0d18ebbba9 1960 DebugWrite("!!**ALT**!!,");
lorded 8:2b0d18ebbba9 1961 }
lorded 8:2b0d18ebbba9 1962 else
lorded 8:2b0d18ebbba9 1963 {
lorded 8:2b0d18ebbba9 1964 DebugWrite("NoALT,");
lorded 8:2b0d18ebbba9 1965 }
lorded 8:2b0d18ebbba9 1966
lorded 8:2b0d18ebbba9 1967 DebugWrite("V");
lorded 8:2b0d18ebbba9 1968 sprintf(printbuff, "%d", heaterStatus.ventilationActive);
lorded 8:2b0d18ebbba9 1969 DebugWrite(printbuff);
lorded 8:2b0d18ebbba9 1970 DebugWrite("\r\n");
lorded 8:2b0d18ebbba9 1971
lorded 8:2b0d18ebbba9 1972 }
lorded 8:2b0d18ebbba9 1973 incoming = can2.read(canMsg);
lorded 8:2b0d18ebbba9 1974 }
lorded 8:2b0d18ebbba9 1975 //incoming = CAN_MessagePending(CAN1, CAN_FIFO1);
lorded 8:2b0d18ebbba9 1976
lorded 8:2b0d18ebbba9 1977 //DebugWrite("doneread\r\n");
lorded 8:2b0d18ebbba9 1978 }
lorded 8:2b0d18ebbba9 1979
lorded 8:2b0d18ebbba9 1980 //#define LISTENONLY
lorded 8:2b0d18ebbba9 1981 /* primary heat task start */
lorded 8:2b0d18ebbba9 1982
lorded 8:2b0d18ebbba9 1983 wiced_bool_t repeatSent = WICED_FALSE;
lorded 8:2b0d18ebbba9 1984
lorded 8:2b0d18ebbba9 1985 void doHeatTaskCAN(struct sHeatVars *s)
lorded 8:2b0d18ebbba9 1986 {
lorded 8:2b0d18ebbba9 1987 if (!(s->bustype == HEATERTYPECAN))
lorded 8:2b0d18ebbba9 1988 {
lorded 8:2b0d18ebbba9 1989 return;
lorded 8:2b0d18ebbba9 1990 }
lorded 8:2b0d18ebbba9 1991
lorded 8:2b0d18ebbba9 1992 char buff[256];
lorded 8:2b0d18ebbba9 1993
lorded 8:2b0d18ebbba9 1994 #ifdef LISTENONLY
lorded 8:2b0d18ebbba9 1995 // sprintf(buff,"heattask %d\r\n", s->tasksequence);
lorded 8:2b0d18ebbba9 1996 // DebugWrite(buff);
lorded 8:2b0d18ebbba9 1997 #endif
lorded 9:6126b83608be 1998 sprintf(buff,"heattask %d\r\n", s->tasksequence);
lorded 9:6126b83608be 1999 DebugWrite(buff);
lorded 8:2b0d18ebbba9 2000 //DebugWrite("Listen Only\r\n");
lorded 8:2b0d18ebbba9 2001
lorded 8:2b0d18ebbba9 2002 readCAN(s);
lorded 10:a82e51837e2b 2003 if ((otherControllerDetected > 0))
lorded 8:2b0d18ebbba9 2004 {
lorded 8:2b0d18ebbba9 2005 s->tasksequence = 0;
lorded 8:2b0d18ebbba9 2006 s->heatOn = HEATCALLOFF;
lorded 10:a82e51837e2b 2007
lorded 10:a82e51837e2b 2008 return; // don't send anything.
lorded 8:2b0d18ebbba9 2009 }
lorded 8:2b0d18ebbba9 2010 #ifdef LISTENONLY
lorded 8:2b0d18ebbba9 2011 return;
lorded 8:2b0d18ebbba9 2012 #endif
lorded 8:2b0d18ebbba9 2013 //return; // listen only.
lorded 8:2b0d18ebbba9 2014 idletimer = 60; // disable idle
lorded 8:2b0d18ebbba9 2015 if ((s->heatOn != HEATCALLOFF))
lorded 8:2b0d18ebbba9 2016 {
lorded 8:2b0d18ebbba9 2017 idletimer = 60;
lorded 8:2b0d18ebbba9 2018 }
lorded 8:2b0d18ebbba9 2019 if ((idletimer <= 0) && (s->heatOn == HEATCALLOFF))
lorded 8:2b0d18ebbba9 2020 {
lorded 8:2b0d18ebbba9 2021 s->tasksequence = -1;
lorded 8:2b0d18ebbba9 2022 DebugWrite("*idle*\r\n");
lorded 8:2b0d18ebbba9 2023 return;
lorded 8:2b0d18ebbba9 2024 }
lorded 8:2b0d18ebbba9 2025 if (s->initTimer > 0)
lorded 8:2b0d18ebbba9 2026 {
lorded 9:6126b83608be 2027 sprintf(printbuff,"InitTimer %d\r\n", s->initTimer);
lorded 9:6126b83608be 2028 DebugWrite(printbuff);
lorded 8:2b0d18ebbba9 2029 s->tasksequence = 0;
lorded 8:2b0d18ebbba9 2030 }
lorded 8:2b0d18ebbba9 2031 else if (s->primeFuelPump == WICED_TRUE)
lorded 8:2b0d18ebbba9 2032 {
lorded 8:2b0d18ebbba9 2033 s->tasksequence = 2;
lorded 8:2b0d18ebbba9 2034 }
lorded 8:2b0d18ebbba9 2035 else if (s->reset_fault_codes == WICED_TRUE)
lorded 8:2b0d18ebbba9 2036 {
lorded 8:2b0d18ebbba9 2037 s->tasksequence = 2;
lorded 8:2b0d18ebbba9 2038 }
lorded 8:2b0d18ebbba9 2039 switch (s->tasksequence++)
lorded 8:2b0d18ebbba9 2040 {
lorded 8:2b0d18ebbba9 2041 case 4:
lorded 8:2b0d18ebbba9 2042 //60F: 0F 11 C9 22 00 20 60 00
lorded 8:2b0d18ebbba9 2043 if ((s->heaterDetected > 0) && s->heaternum == 1) // only send if heater is detected.
lorded 8:2b0d18ebbba9 2044 {
lorded 8:2b0d18ebbba9 2045 if (!repeatSent)
lorded 8:2b0d18ebbba9 2046 {
lorded 8:2b0d18ebbba9 2047 repeatSent = WICED_TRUE;
lorded 8:2b0d18ebbba9 2048 sendRepeatMode(s);
lorded 8:2b0d18ebbba9 2049 break;
lorded 8:2b0d18ebbba9 2050 }
lorded 8:2b0d18ebbba9 2051 }
lorded 8:2b0d18ebbba9 2052 //no break
lorded 8:2b0d18ebbba9 2053 case 0:
lorded 8:2b0d18ebbba9 2054 case 8:
lorded 8:2b0d18ebbba9 2055 case 12:
lorded 8:2b0d18ebbba9 2056 printf("SendWake\r\n");
lorded 8:2b0d18ebbba9 2057 sendWakeCommand(s);
lorded 8:2b0d18ebbba9 2058
lorded 8:2b0d18ebbba9 2059 break;
lorded 8:2b0d18ebbba9 2060 case 1:
lorded 8:2b0d18ebbba9 2061 case 5:
lorded 8:2b0d18ebbba9 2062 case 9:
lorded 8:2b0d18ebbba9 2063 case 13:
lorded 8:2b0d18ebbba9 2064 sendGetBattery(s, buff);
lorded 8:2b0d18ebbba9 2065 sendAltitudeMode(s);
lorded 8:2b0d18ebbba9 2066 if ((s->heatOn == HEATCALLINIT) || (s->heatOn == HEATCALLON))
lorded 8:2b0d18ebbba9 2067 {
lorded 8:2b0d18ebbba9 2068
lorded 8:2b0d18ebbba9 2069 // a cyclic heat call is always required.
lorded 8:2b0d18ebbba9 2070 if (s->setpoint > 0)
lorded 8:2b0d18ebbba9 2071 {
lorded 8:2b0d18ebbba9 2072 if (s->heaterSetpointChange != s->setpoint)
lorded 8:2b0d18ebbba9 2073 {
lorded 8:2b0d18ebbba9 2074 s->setpoint = s->heaterSetpointChange;
lorded 8:2b0d18ebbba9 2075 }
lorded 8:2b0d18ebbba9 2076 sendHeatOnCommandSetpoint(s);
lorded 8:2b0d18ebbba9 2077 }
lorded 8:2b0d18ebbba9 2078 else
lorded 8:2b0d18ebbba9 2079 {
lorded 8:2b0d18ebbba9 2080 sendHeatOnCommand(s);
lorded 8:2b0d18ebbba9 2081 }
lorded 8:2b0d18ebbba9 2082
lorded 8:2b0d18ebbba9 2083 if (s->heatOn == HEATCALLINIT)
lorded 8:2b0d18ebbba9 2084 {
lorded 8:2b0d18ebbba9 2085 s->heatOn = HEATCALLON;
lorded 8:2b0d18ebbba9 2086 }
lorded 8:2b0d18ebbba9 2087 }
lorded 8:2b0d18ebbba9 2088 else if (s->heatOn == HEATCALLOFF)
lorded 8:2b0d18ebbba9 2089 {
lorded 8:2b0d18ebbba9 2090 sendHeatOffCommand(s);
lorded 8:2b0d18ebbba9 2091 // double-if just for clarity
lorded 8:2b0d18ebbba9 2092 if ((s->OBAltitude == WICED_FALSE) && (s->heatCallDetected))
lorded 8:2b0d18ebbba9 2093 {
lorded 8:2b0d18ebbba9 2094 if ((s->altitudeMode == WICED_TRUE) || (s->internalAltitude > 0))
lorded 8:2b0d18ebbba9 2095 {
lorded 8:2b0d18ebbba9 2096 // send ONLY if heater is in "ON" state.
lorded 8:2b0d18ebbba9 2097 char mysteryCommand[8] =
lorded 8:2b0d18ebbba9 2098 { 0x0F, 0x00, 0xC9, 0x22, 0x00, 0x00, 0x00, 0x00 };
lorded 8:2b0d18ebbba9 2099 sendCANCommand(0x060D, mysteryCommand, 8);
lorded 8:2b0d18ebbba9 2100 }
lorded 8:2b0d18ebbba9 2101
lorded 8:2b0d18ebbba9 2102 }
lorded 8:2b0d18ebbba9 2103 }
lorded 8:2b0d18ebbba9 2104 break;
lorded 8:2b0d18ebbba9 2105 case 2:
lorded 8:2b0d18ebbba9 2106 case 6:
lorded 8:2b0d18ebbba9 2107 case 10:
lorded 8:2b0d18ebbba9 2108 case 14:
lorded 8:2b0d18ebbba9 2109 if ((s->heatOn == HEATCALLOFF) && (s->primeFuelPump == WICED_TRUE))
lorded 8:2b0d18ebbba9 2110 {
lorded 8:2b0d18ebbba9 2111 DebugWrite("IN prime call\r\n");
lorded 8:2b0d18ebbba9 2112 s->primeFuelPump = WICED_FALSE; // no prime allowed if heat on
lorded 8:2b0d18ebbba9 2113 doPrimeSequence(s);
lorded 8:2b0d18ebbba9 2114 }
lorded 8:2b0d18ebbba9 2115 else if (s->primeFuelPump == WICED_TRUE)
lorded 8:2b0d18ebbba9 2116 {
lorded 8:2b0d18ebbba9 2117 DebugWrite("IN prime call FORCED FALSE\r\n");
lorded 8:2b0d18ebbba9 2118 s->primeFuelPump = WICED_FALSE; // no prime allowed if heat on
lorded 8:2b0d18ebbba9 2119 }
lorded 8:2b0d18ebbba9 2120 if (s->reset_fault_codes == WICED_TRUE)
lorded 8:2b0d18ebbba9 2121 {
lorded 8:2b0d18ebbba9 2122 // doPrimeSequence(s);
lorded 8:2b0d18ebbba9 2123 // s->reset_fault_codes = WICED_FALSE;
lorded 8:2b0d18ebbba9 2124
lorded 8:2b0d18ebbba9 2125 printf("RESET faults\r\n");
lorded 8:2b0d18ebbba9 2126 s->reset_fault_codes = WICED_FALSE;
lorded 8:2b0d18ebbba9 2127 doResetSequence(s);
lorded 8:2b0d18ebbba9 2128 // reset fault codes
lorded 8:2b0d18ebbba9 2129 printf("****sendGetFaults***\r\n");
lorded 8:2b0d18ebbba9 2130 sendGetFault(s, buff);
lorded 8:2b0d18ebbba9 2131 printf("***doneGetFaults***\r\n");
lorded 8:2b0d18ebbba9 2132 }
lorded 8:2b0d18ebbba9 2133 else
lorded 8:2b0d18ebbba9 2134 {
lorded 8:2b0d18ebbba9 2135 printf("****sendGetFaults***\r\n");
lorded 8:2b0d18ebbba9 2136 sendGetFault(s, buff);
lorded 8:2b0d18ebbba9 2137 if ((s->errorHistory[0] == 0) || (s->errorHistory[0] == 255))
lorded 8:2b0d18ebbba9 2138 {
lorded 8:2b0d18ebbba9 2139 s->reset_fault_codes = WICED_FALSE;
lorded 8:2b0d18ebbba9 2140 }
lorded 8:2b0d18ebbba9 2141 printf("***doneGetFaults***\r\n");
lorded 8:2b0d18ebbba9 2142 }
lorded 8:2b0d18ebbba9 2143 // check faults
lorded 8:2b0d18ebbba9 2144 break;
lorded 8:2b0d18ebbba9 2145 case 3:
lorded 8:2b0d18ebbba9 2146 sendGetTemperatures(s, buff);
lorded 8:2b0d18ebbba9 2147 break;
lorded 8:2b0d18ebbba9 2148 case 7:
lorded 8:2b0d18ebbba9 2149 sendGetRuntime(s, buff);
lorded 8:2b0d18ebbba9 2150 break;
lorded 8:2b0d18ebbba9 2151 case 11:
lorded 8:2b0d18ebbba9 2152 sendGetBattery(s, buff);
lorded 8:2b0d18ebbba9 2153 break;
lorded 8:2b0d18ebbba9 2154 //case 4:
lorded 8:2b0d18ebbba9 2155 case 15:
lorded 8:2b0d18ebbba9 2156 sendGetAltitude(s, buff);
lorded 8:2b0d18ebbba9 2157 break;
lorded 8:2b0d18ebbba9 2158 default:
lorded 8:2b0d18ebbba9 2159 s->tasksequence = 0;
lorded 8:2b0d18ebbba9 2160 break;
lorded 8:2b0d18ebbba9 2161 }
lorded 8:2b0d18ebbba9 2162 printf("/done\r\n");
lorded 8:2b0d18ebbba9 2163 // start with "Wake" message
lorded 8:2b0d18ebbba9 2164
lorded 8:2b0d18ebbba9 2165 return;
lorded 8:2b0d18ebbba9 2166 }
lorded 8:2b0d18ebbba9 2167
lorded 8:2b0d18ebbba9 2168
lorded 8:2b0d18ebbba9 2169
lorded 8:2b0d18ebbba9 2170 // imported from picus
lorded 8:2b0d18ebbba9 2171
lorded 8:2b0d18ebbba9 2172 void doHeatLogicTask(struct sHeatVars* s)
lorded 8:2b0d18ebbba9 2173 {
lorded 8:2b0d18ebbba9 2174 // error flag valid after LINPulse 0.
lorded 8:2b0d18ebbba9 2175 if (s->errorChangeFlag == 1)
lorded 8:2b0d18ebbba9 2176 {
lorded 8:2b0d18ebbba9 2177 s->errorChangeFlag = 0;
lorded 8:2b0d18ebbba9 2178 //printf("Error Change %d \r\n",currentError);
lorded 8:2b0d18ebbba9 2179
lorded 8:2b0d18ebbba9 2180 //printf("History %d,%d,%d,%d,%d\r\n",errorHistory[0],errorHistory[1],errorHistory[2],errorHistory[3],errorHistory[4]);
lorded 8:2b0d18ebbba9 2181
lorded 8:2b0d18ebbba9 2182 // reset timer
lorded 8:2b0d18ebbba9 2183 resetTimer(s);
lorded 8:2b0d18ebbba9 2184 s->reportflag = 1;
lorded 8:2b0d18ebbba9 2185 //UARTWrite(1,"Timer reset\r\n");
lorded 8:2b0d18ebbba9 2186 }
lorded 8:2b0d18ebbba9 2187 //sprintf(printbuff, "tickcount: %d, heaton: %d, heattime: %d\n", s->tickcount, s->heatOn, s->heattime);
lorded 8:2b0d18ebbba9 2188 //DebugWrite(printbuff);
lorded 8:2b0d18ebbba9 2189 // if the error is stable for 15 seconds, report.
lorded 8:2b0d18ebbba9 2190 if (s->reportflag == 1 && s->tickcount > 15000 && s->heatOn > 0 && (s->heatcontrolstate != IDLE) && s->resettick == 0)
lorded 8:2b0d18ebbba9 2191 {
lorded 8:2b0d18ebbba9 2192 // stable for 15 seconds, do report
lorded 8:2b0d18ebbba9 2193 if (s->currentError == 0 && s->heatOn > 0)
lorded 8:2b0d18ebbba9 2194 {
lorded 8:2b0d18ebbba9 2195 s->reportflag = 0;
lorded 8:2b0d18ebbba9 2196 }
lorded 8:2b0d18ebbba9 2197 else if (s->currentError != 0xFF)
lorded 8:2b0d18ebbba9 2198 {
lorded 8:2b0d18ebbba9 2199 //printf("Error (heatOn & currentError !=0xFF) \r\n");
lorded 8:2b0d18ebbba9 2200 s->reportflag = 0;
lorded 8:2b0d18ebbba9 2201 s->heatOn = HEATCALLOFF;
lorded 8:2b0d18ebbba9 2202 // disabled retry function per neil at this point.
lorded 8:2b0d18ebbba9 2203 }
lorded 8:2b0d18ebbba9 2204 else
lorded 8:2b0d18ebbba9 2205 {
lorded 8:2b0d18ebbba9 2206 //printf( "Error FF: No communication. Allow heat to continue, but report\r\n");
lorded 8:2b0d18ebbba9 2207 // -OR-
lorded 8:2b0d18ebbba9 2208 // Retry algorighm on LIN pulse
lorded 8:2b0d18ebbba9 2209 s->reportflag = 0;
lorded 8:2b0d18ebbba9 2210 }
lorded 8:2b0d18ebbba9 2211 }
lorded 8:2b0d18ebbba9 2212 else
lorded 8:2b0d18ebbba9 2213 {
lorded 8:2b0d18ebbba9 2214 //sprintf(printbuff,"%d\r\n",tickcount);
lorded 8:2b0d18ebbba9 2215 //UARTWrite(1,printbuff);
lorded 8:2b0d18ebbba9 2216 }
lorded 8:2b0d18ebbba9 2217 if (s->heatOn == HEATCALLON && (s->heattime == 0 || s->heattime > 86400))
lorded 8:2b0d18ebbba9 2218 {
lorded 8:2b0d18ebbba9 2219 //printf("Heat off due to time expiry.");
lorded 8:2b0d18ebbba9 2220 // no final report.
lorded 8:2b0d18ebbba9 2221
lorded 8:2b0d18ebbba9 2222 if (s->heattime > 0)
lorded 8:2b0d18ebbba9 2223 {
lorded 8:2b0d18ebbba9 2224 s->heatOn = HEATCALLLONGRUN;
lorded 8:2b0d18ebbba9 2225 s->heatresettime = RESETHEATTIME
lorded 8:2b0d18ebbba9 2226 ; // reset heat timer
lorded 8:2b0d18ebbba9 2227 }
lorded 8:2b0d18ebbba9 2228 else
lorded 8:2b0d18ebbba9 2229 {
lorded 8:2b0d18ebbba9 2230 s->heatOn = HEATCALLOFF;
lorded 8:2b0d18ebbba9 2231 }
lorded 8:2b0d18ebbba9 2232
lorded 8:2b0d18ebbba9 2233 s->reportflag = 0;
lorded 8:2b0d18ebbba9 2234 }
lorded 8:2b0d18ebbba9 2235 }
lorded 8:2b0d18ebbba9 2236
lorded 8:2b0d18ebbba9 2237 //=========================================================
lorded 8:2b0d18ebbba9 2238 unsigned char fromHexAscii(char ascii)
lorded 8:2b0d18ebbba9 2239 {
lorded 8:2b0d18ebbba9 2240 if (ascii >= '0' && ascii <= '9')
lorded 8:2b0d18ebbba9 2241 {
lorded 8:2b0d18ebbba9 2242 return ascii - '0';
lorded 8:2b0d18ebbba9 2243 }
lorded 8:2b0d18ebbba9 2244 else if (ascii >= 'A' && ascii <= 'F')
lorded 8:2b0d18ebbba9 2245 {
lorded 8:2b0d18ebbba9 2246 return ascii - 'A' + 10;
lorded 8:2b0d18ebbba9 2247 }
lorded 8:2b0d18ebbba9 2248 else
lorded 8:2b0d18ebbba9 2249 {
lorded 8:2b0d18ebbba9 2250 return 255;
lorded 8:2b0d18ebbba9 2251 }
lorded 8:2b0d18ebbba9 2252 }
lorded 8:2b0d18ebbba9 2253
lorded 8:2b0d18ebbba9 2254