Rivian Irvine Team / Mbed 2 deprecated TCTF_Control_Main

Control Code with I/O and ADC working

Dependencies:   MODSERIAL mbed

main.cpp@20:cdeed4dad690, 2018-07-16 (annotated)

Committer:
jrodenburg
Date:
Mon Jul 16 03:53:59 2018 +0000
Revision:
20:cdeed4dad690
Parent:
19:0946665b37c7
Child:
21:f87464a7e7c6
New code running on boards without diagnostics

Who changed what in which revision?

UserRevisionLine numberNew contents of line
jrodenburg 4:168a446bd0da 1 // MBED SCRIPT FOR CONTROLLING THE TEMPERATURE CONTROLLED TEST FIXTURE (TCTF)
jrodenburg 0:a28a1035c31b 2 // DATE: SEPTEMBER 2017
jrodenburg 0:a28a1035c31b 3
jrodenburg 0:a28a1035c31b 4 #include "mbed.h"
jrodenburg 0:a28a1035c31b 5 #include "MODSERIAL.h"
jrodenburg 8:dbf8bd4815f8 6 #include "MCP23008.h"
jrodenburg 0:a28a1035c31b 7 #include "LTC2487.h"
jrodenburg 2:bd118a724f03 8 #include <string>
jrodenburg 0:a28a1035c31b 9
jrodenburg 20:cdeed4dad690 10
jrodenburg 0:a28a1035c31b 11 //DEFINITIVE VARIABLES
jrodenburg 20:cdeed4dad690 12 #define DEBUG_LOOP_TIME 0x00000001
jrodenburg 20:cdeed4dad690 13 #define RXDATA_PRINT 0x00000002
jrodenburg 20:cdeed4dad690 14 #define UID_PRINT 0x00000004
jrodenburg 20:cdeed4dad690 15 #define ERROR_PRINT 0x00000008
jrodenburg 20:cdeed4dad690 16 #define ADC_VAL_PRINT 0x00000010
jrodenburg 20:cdeed4dad690 17 #define HEATER_CHILLER_PRINT 0x00000020
jrodenburg 20:cdeed4dad690 18 #define HEATER_ON_TIME_PRINT 0x00000040
jrodenburg 20:cdeed4dad690 19 #define LED_PRINT 0x00000080
jrodenburg 20:cdeed4dad690 20 #define TEMP_PRINT 0x00000100
jrodenburg 20:cdeed4dad690 21 #define I2C_PRINT 0x00000200
jrodenburg 20:cdeed4dad690 22
jrodenburg 20:cdeed4dad690 23 #define IO_I2C_LINE 1
jrodenburg 20:cdeed4dad690 24 #define ADC_I2C_LINE 2
jrodenburg 20:cdeed4dad690 25
jrodenburg 20:cdeed4dad690 26
jrodenburg 20:cdeed4dad690 27 #define CHAN_COUNT 8
jrodenburg 16:82d941b1ef21 28 #define MIN_TEMP 10
jrodenburg 16:82d941b1ef21 29 #define MAX_TEMP 65
jrodenburg 20:cdeed4dad690 30 #define MEGA_MAX_TEMP 75
jrodenburg 20:cdeed4dad690 31 #define TEMP_MARGIN 10
jrodenburg 16:82d941b1ef21 32 #define HYST_LOW 0.3
jrodenburg 16:82d941b1ef21 33 #define HYST_HIGH 1
jrodenburg 16:82d941b1ef21 34 #define SAMPLES 5
jrodenburg 16:82d941b1ef21 35 #define I2C_Freq 2000
jrodenburg 16:82d941b1ef21 36 #define VALVE 1
jrodenburg 16:82d941b1ef21 37 #define HEATER 2
jrodenburg 20:cdeed4dad690 38 #define GREEN_STATUS_ON 3
jrodenburg 20:cdeed4dad690 39 #define RED_STATUS_ON 0
jrodenburg 20:cdeed4dad690 40 #define ERROR_STATUS_ON 1
jrodenburg 20:cdeed4dad690 41 #define STATUS_OFF 4
jrodenburg 16:82d941b1ef21 42 #define sizeLUT 34
jrodenburg 16:82d941b1ef21 43 #define BACK_THERM 0
jrodenburg 16:82d941b1ef21 44 #define FRONT_THERM 1
jrodenburg 16:82d941b1ef21 45 #define HEAT_FET_AMP 2
jrodenburg 16:82d941b1ef21 46 #define VALVE_FET_AMP 3
jrodenburg 16:82d941b1ef21 47 #define FET_ON_CURRENT 1.12
jrodenburg 16:82d941b1ef21 48 #define ROOM_TEMP 22
jrodenburg 14:69cd53434783 49 #define MAX_HEATER_ON_TIME 25
jrodenburg 14:69cd53434783 50 #define MAX_CHILL_TIME 10 //10sec
jrodenburg 20:cdeed4dad690 51 #define MIN_ERROR_CNT_1 4 //ALL SAFETY RELATEDD CHECKS
jrodenburg 20:cdeed4dad690 52 #define MIN_ERROR_CNT_2 600 //PEFORMANCE TIME (HAVE TO GIVE FIXTURE TIME TO SETTLE)
jrodenburg 20:cdeed4dad690 53 #define MIN_ERROR_CNT_3 60
jrodenburg 20:cdeed4dad690 54 #define NUM_EMAIL_SEND 2
jrodenburg 20:cdeed4dad690 55 #define STATUS_COOLING 1
jrodenburg 20:cdeed4dad690 56 #define STATUS_HEATING 2
jrodenburg 20:cdeed4dad690 57 #define STATUS_INACTIVE 3
jrodenburg 20:cdeed4dad690 58 #define STATUS_STANDBY 4
jrodenburg 20:cdeed4dad690 59
jrodenburg 20:cdeed4dad690 60 #define READ_TEMP_TASK_TIME .300f //300ms to read one A/D value
jrodenburg 20:cdeed4dad690 61 #define I2C_READ_WAIT_TIME 0.08f
jrodenburg 12:1cada1fe4743 62
jrodenburg 8:dbf8bd4815f8 63 // Defines for use with Serial communication
jrodenburg 8:dbf8bd4815f8 64 #pragma pack (1)
jrodenburg 8:dbf8bd4815f8 65 #define RX_SOF 0x7B
jrodenburg 8:dbf8bd4815f8 66 #define RX_EOF 0x7D
jrodenburg 8:dbf8bd4815f8 67 #define TX_SOF 0x7B
jrodenburg 8:dbf8bd4815f8 68 #define TX_EOF 0x7D
jrodenburg 8:dbf8bd4815f8 69 #define DELIMETER 0x2E
jrodenburg 8:dbf8bd4815f8 70 #define SET_TEMPERATURE 0xB0
jrodenburg 8:dbf8bd4815f8 71 #define SELECT_CHANNEL 0xB1
jrodenburg 15:74a01aaeb60e 72 #define READ_UID 0xB2
jrodenburg 20:cdeed4dad690 73 #define READ_FW_VERSION 0xB3
jrodenburg 20:cdeed4dad690 74 #define DEBUG_CONTROL 0xB4
jrodenburg 15:74a01aaeb60e 75 #define RESPONSE_DATA 0xD0
jrodenburg 15:74a01aaeb60e 76 #define TEMP_DATA 0xD1
jrodenburg 15:74a01aaeb60e 77 #define UID_DATA 0xD2
jrodenburg 20:cdeed4dad690 78 #define FW_VERSION_DATA 0xD3
jrodenburg 15:74a01aaeb60e 79 #define ERROR_DATA 0xDF
jrodenburg 12:1cada1fe4743 80
jrodenburg 0:a28a1035c31b 81
jrodenburg 20:cdeed4dad690 82 const char FW_Version[8] = "V0.01C";
jrodenburg 8:dbf8bd4815f8 83 unsigned int chanSel_SendTemp = 0;
jrodenburg 8:dbf8bd4815f8 84 unsigned int chanSel_SetTemp = 0;
jrodenburg 8:dbf8bd4815f8 85 // Default to chan 0
jrodenburg 8:dbf8bd4815f8 86 int currChan = 0;
jrodenburg 8:dbf8bd4815f8 87 bool newTempSet = false;
jrodenburg 20:cdeed4dad690 88 bool readFrontThermistor = true;
jrodenburg 20:cdeed4dad690 89 bool newTempData = false;
jrodenburg 20:cdeed4dad690 90 bool newTempDataAvailable = false;
jrodenburg 20:cdeed4dad690 91 unsigned int UID_print_count = 0;
jrodenburg 20:cdeed4dad690 92 unsigned int debug_control = 0x2;
jrodenburg 8:dbf8bd4815f8 93
jrodenburg 20:cdeed4dad690 94 //***********************************************
jrodenburg 20:cdeed4dad690 95 // Timers
jrodenburg 20:cdeed4dad690 96 //***********************************************
jrodenburg 20:cdeed4dad690 97 Ticker frontTempDoneTicker;
jrodenburg 20:cdeed4dad690 98 Ticker backTempDoneTicker;
jrodenburg 20:cdeed4dad690 99 Ticker readThermistorTicker;
jrodenburg 20:cdeed4dad690 100 Ticker frontTempInProgTicker;
jrodenburg 20:cdeed4dad690 101 Ticker backTempInProgTicker;
jrodenburg 20:cdeed4dad690 102
jrodenburg 20:cdeed4dad690 103 //***********************************************
jrodenburg 20:cdeed4dad690 104 // LEDs
jrodenburg 20:cdeed4dad690 105 //***********************************************
jrodenburg 20:cdeed4dad690 106 DigitalOut rLed(LED1);
jrodenburg 20:cdeed4dad690 107 DigitalOut gLed(LED2);
jrodenburg 20:cdeed4dad690 108
jrodenburg 20:cdeed4dad690 109 //***********************************************
jrodenburg 20:cdeed4dad690 110 // Functions Declarations
jrodenburg 20:cdeed4dad690 111 //***********************************************
jrodenburg 20:cdeed4dad690 112 void sendUID ();
jrodenburg 20:cdeed4dad690 113 void sendFWVersion();
jrodenburg 20:cdeed4dad690 114 void read_front_temp();
jrodenburg 20:cdeed4dad690 115 void read_back_temp();
jrodenburg 20:cdeed4dad690 116 void update_front_temp_data();
jrodenburg 20:cdeed4dad690 117 void update_back_temp_data();
jrodenburg 20:cdeed4dad690 118 void temperatureDataReady();
jrodenburg 12:1cada1fe4743 119
jrodenburg 8:dbf8bd4815f8 120 //***********************************************
jrodenburg 8:dbf8bd4815f8 121 // Serial Rx Packet Format
jrodenburg 8:dbf8bd4815f8 122 //***********************************************
jrodenburg 8:dbf8bd4815f8 123 typedef struct {
jrodenburg 8:dbf8bd4815f8 124 unsigned char SOF_flag;
jrodenburg 8:dbf8bd4815f8 125 unsigned char cmd_type;
jrodenburg 8:dbf8bd4815f8 126 unsigned char len;
jrodenburg 8:dbf8bd4815f8 127 unsigned char Delim;
jrodenburg 8:dbf8bd4815f8 128 } HOST_CMD_HEADER;
jrodenburg 8:dbf8bd4815f8 129
jrodenburg 8:dbf8bd4815f8 130 typedef struct {
jrodenburg 8:dbf8bd4815f8 131 HOST_CMD_HEADER cmd_header;
jrodenburg 8:dbf8bd4815f8 132 unsigned char chanID;
jrodenburg 8:dbf8bd4815f8 133 unsigned char tempDelim;
jrodenburg 8:dbf8bd4815f8 134 float setTemp;
jrodenburg 8:dbf8bd4815f8 135 unsigned char chanStatDelim;
jrodenburg 8:dbf8bd4815f8 136 unsigned char chanStat;
jrodenburg 8:dbf8bd4815f8 137 } SET_TEMPERATURE_CMD;
jrodenburg 8:dbf8bd4815f8 138
jrodenburg 8:dbf8bd4815f8 139 typedef struct {
jrodenburg 8:dbf8bd4815f8 140 HOST_CMD_HEADER cmd_header;
jrodenburg 8:dbf8bd4815f8 141 unsigned char chanIDSel;
jrodenburg 8:dbf8bd4815f8 142 unsigned char chanDelim;
jrodenburg 8:dbf8bd4815f8 143 unsigned char chanStat;
jrodenburg 8:dbf8bd4815f8 144 } SELECT_CHANNEL_CMD;
jrodenburg 8:dbf8bd4815f8 145
jrodenburg 8:dbf8bd4815f8 146 typedef struct {
jrodenburg 8:dbf8bd4815f8 147 unsigned char SOF_flag;
jrodenburg 8:dbf8bd4815f8 148 unsigned char cmd_type;
jrodenburg 8:dbf8bd4815f8 149 unsigned char len;
jrodenburg 8:dbf8bd4815f8 150 unsigned char Delim;
jrodenburg 20:cdeed4dad690 151 uint32_t channel;
jrodenburg 8:dbf8bd4815f8 152 float data;
jrodenburg 8:dbf8bd4815f8 153 unsigned char EOF_flag;
jrodenburg 8:dbf8bd4815f8 154 } RESPONSE_CMD;
jrodenburg 2:bd118a724f03 155
jrodenburg 15:74a01aaeb60e 156 typedef struct {
jrodenburg 16:82d941b1ef21 157 unsigned char SOF_flag;
jrodenburg 16:82d941b1ef21 158 unsigned char cmd_type;
jrodenburg 16:82d941b1ef21 159 unsigned char len;
jrodenburg 16:82d941b1ef21 160 unsigned char Delim;
jrodenburg 20:cdeed4dad690 161 float chTemp[CHAN_COUNT];
jrodenburg 16:82d941b1ef21 162 unsigned char EOF_flag;
jrodenburg 16:82d941b1ef21 163 } RESPONSE_TEMP_CMD;
jrodenburg 16:82d941b1ef21 164
jrodenburg 16:82d941b1ef21 165 typedef struct {
jrodenburg 15:74a01aaeb60e 166 HOST_CMD_HEADER cmd_header;
jrodenburg 15:74a01aaeb60e 167 unsigned char chanIDSel;
jrodenburg 15:74a01aaeb60e 168 unsigned char chanDelim;
jrodenburg 15:74a01aaeb60e 169 unsigned char chanStat;
jrodenburg 15:74a01aaeb60e 170 } READ_UID_CMD;
jrodenburg 15:74a01aaeb60e 171
jrodenburg 15:74a01aaeb60e 172 typedef struct {
jrodenburg 20:cdeed4dad690 173 HOST_CMD_HEADER cmd_header;
jrodenburg 20:cdeed4dad690 174 unsigned char chanIDSel;
jrodenburg 20:cdeed4dad690 175 unsigned char chanDelim;
jrodenburg 20:cdeed4dad690 176 uint32_t commandData;
jrodenburg 20:cdeed4dad690 177 } GUI_STANDARD_CMD;
jrodenburg 20:cdeed4dad690 178
jrodenburg 20:cdeed4dad690 179 typedef struct {
jrodenburg 20:cdeed4dad690 180 unsigned char SOF_flag;
jrodenburg 20:cdeed4dad690 181 unsigned char cmd_type;
jrodenburg 20:cdeed4dad690 182 unsigned char len;
jrodenburg 20:cdeed4dad690 183 unsigned char Delim;
jrodenburg 20:cdeed4dad690 184 unsigned char FW_Version[8];
jrodenburg 20:cdeed4dad690 185 unsigned char EOF_flag;
jrodenburg 20:cdeed4dad690 186 } FW_VERSION_RESPONSE;
jrodenburg 20:cdeed4dad690 187
jrodenburg 20:cdeed4dad690 188 typedef struct {
jrodenburg 15:74a01aaeb60e 189 unsigned char SOF_flag;
jrodenburg 15:74a01aaeb60e 190 unsigned char cmd_type;
jrodenburg 15:74a01aaeb60e 191 unsigned char len;
jrodenburg 15:74a01aaeb60e 192 unsigned char Delim;
jrodenburg 15:74a01aaeb60e 193 uint32_t UIDMH;
jrodenburg 15:74a01aaeb60e 194 uint32_t UIDML;
jrodenburg 15:74a01aaeb60e 195 uint32_t UIDL;
jrodenburg 15:74a01aaeb60e 196 unsigned char EOF_flag;
jrodenburg 15:74a01aaeb60e 197 } UID_RESPONSE;
jrodenburg 15:74a01aaeb60e 198
jrodenburg 2:bd118a724f03 199 //TCTF CHANNEL DATA
jrodenburg 2:bd118a724f03 200 struct CHNL_DATA{
jrodenburg 2:bd118a724f03 201 bool status;
jrodenburg 2:bd118a724f03 202 float setTemp;
jrodenburg 20:cdeed4dad690 203 int error;
jrodenburg 20:cdeed4dad690 204 int state;
jrodenburg 20:cdeed4dad690 205 int errorEmailSent;
jrodenburg 20:cdeed4dad690 206 int i2cRxed;
jrodenburg 2:bd118a724f03 207 };
jrodenburg 2:bd118a724f03 208
jrodenburg 4:168a446bd0da 209 CHNL_DATA chnlStatus[] = {
jrodenburg 20:cdeed4dad690 210 {0, NULL, 0, 0, 0, 1},
jrodenburg 20:cdeed4dad690 211 {0, NULL, 0, 0, 0, 1},
jrodenburg 20:cdeed4dad690 212 {0, NULL, 0, 0, 0, 1},
jrodenburg 20:cdeed4dad690 213 {0, NULL, 0, 0, 0, 1},
jrodenburg 20:cdeed4dad690 214 {0, NULL, 0, 0, 0, 1},
jrodenburg 20:cdeed4dad690 215 {0, NULL, 0, 0, 0, 1},
jrodenburg 20:cdeed4dad690 216 {0, NULL, 0, 0, 0, 1},
jrodenburg 20:cdeed4dad690 217 {0, NULL, 0, 0, 0, 1}
jrodenburg 2:bd118a724f03 218 };
jrodenburg 2:bd118a724f03 219
jrodenburg 2:bd118a724f03 220
jrodenburg 0:a28a1035c31b 221 //I2C AADRESS LOOK UP TABLE, CREATED IN EXCEL SHEET (COUNT, TEMP)
jrodenburg 2:bd118a724f03 222 struct I2C_ADDR_LUT{
jrodenburg 0:a28a1035c31b 223 int adc;
jrodenburg 0:a28a1035c31b 224 int io;
jrodenburg 0:a28a1035c31b 225 };
jrodenburg 0:a28a1035c31b 226
jrodenburg 0:a28a1035c31b 227 I2C_ADDR_LUT addrLUT[] = {
jrodenburg 0:a28a1035c31b 228 {0x23, 0x10},
jrodenburg 0:a28a1035c31b 229 {0x53, 0x60},
jrodenburg 0:a28a1035c31b 230 {0x43, 0x70},
jrodenburg 0:a28a1035c31b 231 {0x73, 0x40},
jrodenburg 0:a28a1035c31b 232 {0x63, 0x50},
jrodenburg 0:a28a1035c31b 233 {0x22, 0x11},
jrodenburg 0:a28a1035c31b 234 {0x52, 0x61},
jrodenburg 20:cdeed4dad690 235 {0x42, 0x71}
jrodenburg 0:a28a1035c31b 236 };
jrodenburg 0:a28a1035c31b 237
jrodenburg 0:a28a1035c31b 238 //THERMISTOR LOOK UP TABLE, CREATED IN EXCEL SHEET (COUNT, TEMP)
jrodenburg 2:bd118a724f03 239 struct THERM_LUT{
jrodenburg 0:a28a1035c31b 240 int adc;
jrodenburg 0:a28a1035c31b 241 int temp;
jrodenburg 0:a28a1035c31b 242 };
jrodenburg 0:a28a1035c31b 243
jrodenburg 0:a28a1035c31b 244 THERM_LUT thermLUT[] = {
jrodenburg 0:a28a1035c31b 245 {113779,-40},
jrodenburg 0:a28a1035c31b 246 {109152,-35},
jrodenburg 0:a28a1035c31b 247 {103830,-30},
jrodenburg 0:a28a1035c31b 248 {97855,-25},
jrodenburg 0:a28a1035c31b 249 {91319,-20},
jrodenburg 0:a28a1035c31b 250 {84352,-15},
jrodenburg 0:a28a1035c31b 251 {77124,-10},
jrodenburg 0:a28a1035c31b 252 {69820,-5},
jrodenburg 0:a28a1035c31b 253 {62621,0},
jrodenburg 0:a28a1035c31b 254 {55693,5},
jrodenburg 0:a28a1035c31b 255 {49169,10},
jrodenburg 0:a28a1035c31b 256 {43144,15},
jrodenburg 0:a28a1035c31b 257 {37669,20},
jrodenburg 0:a28a1035c31b 258 {32768,25},
jrodenburg 0:a28a1035c31b 259 {28429,30},
jrodenburg 0:a28a1035c31b 260 {24622,35},
jrodenburg 0:a28a1035c31b 261 {21309,40},
jrodenburg 0:a28a1035c31b 262 {18439,45},
jrodenburg 0:a28a1035c31b 263 {15962,50},
jrodenburg 0:a28a1035c31b 264 {13831,55},
jrodenburg 0:a28a1035c31b 265 {12002,60},
jrodenburg 0:a28a1035c31b 266 {10428,65},
jrodenburg 0:a28a1035c31b 267 {9080,70},
jrodenburg 0:a28a1035c31b 268 {7919,75},
jrodenburg 0:a28a1035c31b 269 {6923,80},
jrodenburg 0:a28a1035c31b 270 {6063,85},
jrodenburg 0:a28a1035c31b 271 {5323,90},
jrodenburg 0:a28a1035c31b 272 {4685,95},
jrodenburg 0:a28a1035c31b 273 {4130,100},
jrodenburg 0:a28a1035c31b 274 {3653,105},
jrodenburg 0:a28a1035c31b 275 {3234,110},
jrodenburg 0:a28a1035c31b 276 {2876,115},
jrodenburg 0:a28a1035c31b 277 {2563,120},
jrodenburg 0:a28a1035c31b 278 {2284,125}
jrodenburg 0:a28a1035c31b 279 };
jrodenburg 0:a28a1035c31b 280
jrodenburg 20:cdeed4dad690 281
jrodenburg 20:cdeed4dad690 282
jrodenburg 16:82d941b1ef21 283 //TCTF CHANNEL TEMPERATURE
jrodenburg 16:82d941b1ef21 284 typedef struct{
jrodenburg 16:82d941b1ef21 285 float currTempFront;
jrodenburg 16:82d941b1ef21 286 float currTempBack;
jrodenburg 16:82d941b1ef21 287 }CHNL_TEMP;
jrodenburg 16:82d941b1ef21 288
jrodenburg 20:cdeed4dad690 289 CHNL_TEMP channelTempData[CHAN_COUNT];
jrodenburg 16:82d941b1ef21 290
jrodenburg 2:bd118a724f03 291 //SERIAL COMMUNICATION SETUP
jrodenburg 2:bd118a724f03 292 MODSERIAL pc(USBTX, USBRX);
jrodenburg 1:0182b86f9bd4 293
jrodenburg 0:a28a1035c31b 294 //DEFINE PINS
jrodenburg 0:a28a1035c31b 295 DigitalOut myled(LED2);
jrodenburg 0:a28a1035c31b 296
jrodenburg 0:a28a1035c31b 297 //I2C FOR MCP23008 (I/O Control)
jrodenburg 12:1cada1fe4743 298 MCP23008 io_control(PTC9, PTC8, 0x10, 100000); //sda, scl
jrodenburg 0:a28a1035c31b 299
jrodenburg 0:a28a1035c31b 300 //I2C FOR LTC2487 (ADC Control)
jrodenburg 12:1cada1fe4743 301 LTC2487 ltc2487(PTC11, PTC10, 0x23, 100000); //sda, scl
jrodenburg 0:a28a1035c31b 302
jrodenburg 0:a28a1035c31b 303 //GLOBAL VARIABLES
jrodenburg 12:1cada1fe4743 304 volatile bool dataReceived = false; //used to check if data has been received
jrodenburg 8:dbf8bd4815f8 305 volatile bool dataTxReady = false;
jrodenburg 2:bd118a724f03 306 char rxBuf[50];
jrodenburg 2:bd118a724f03 307 int chnlSel;
jrodenburg 20:cdeed4dad690 308 bool standbyLED[CHAN_COUNT] = {false,false,false,false,false,false,false,false};
jrodenburg 7:8a5e65e63e2a 309
jrodenburg 7:8a5e65e63e2a 310 /* Function: turnOffChannel
jrodenburg 7:8a5e65e63e2a 311 **************************************************************
jrodenburg 7:8a5e65e63e2a 312 Description: Turns off a channel
jrodenburg 7:8a5e65e63e2a 313 Recieves: chnl: channel to turn off
jrodenburg 7:8a5e65e63e2a 314 Returns: N/A
jrodenburg 7:8a5e65e63e2a 315 */
jrodenburg 7:8a5e65e63e2a 316
jrodenburg 7:8a5e65e63e2a 317 void turnOffChannel(int chnl){
jrodenburg 7:8a5e65e63e2a 318 io_control.setAddress(addrLUT[chnl].io);
jrodenburg 7:8a5e65e63e2a 319 io_control.init();
jrodenburg 7:8a5e65e63e2a 320 io_control.writeOutput(0,0,0,0);
jrodenburg 7:8a5e65e63e2a 321 }
jrodenburg 7:8a5e65e63e2a 322
jrodenburg 8:dbf8bd4815f8 323
jrodenburg 2:bd118a724f03 324 /* Function: rxInterrupt
jrodenburg 1:0182b86f9bd4 325 **************************************************************
jrodenburg 8:dbf8bd4815f8 326 Description: serial rx interupt handler
jrodenburg 8:dbf8bd4815f8 327 Receives: N/A
jrodenburg 8:dbf8bd4815f8 328 Returns: N/A
jrodenburg 2:bd118a724f03 329 */
jrodenburg 2:bd118a724f03 330
jrodenburg 8:dbf8bd4815f8 331 //***********************************************
jrodenburg 8:dbf8bd4815f8 332 // Rx Interrupt from serial Host interface
jrodenburg 8:dbf8bd4815f8 333 //***********************************************
jrodenburg 8:dbf8bd4815f8 334 void rxInterrupt(MODSERIAL_IRQ_INFO *info)
jrodenburg 8:dbf8bd4815f8 335 {
jrodenburg 8:dbf8bd4815f8 336 gLed = 0;
jrodenburg 8:dbf8bd4815f8 337 dataReceived = true;
jrodenburg 20:cdeed4dad690 338 //wait(.5);
jrodenburg 8:dbf8bd4815f8 339 gLed = 1;
jrodenburg 2:bd118a724f03 340 }
jrodenburg 2:bd118a724f03 341
jrodenburg 8:dbf8bd4815f8 342
jrodenburg 8:dbf8bd4815f8 343 //***************************************************************
jrodenburg 8:dbf8bd4815f8 344 // Tx Interrupt from serial Host interface
jrodenburg 8:dbf8bd4815f8 345 //***************************************************************
jrodenburg 8:dbf8bd4815f8 346 void txInterrupt(MODSERIAL_IRQ_INFO *info)
jrodenburg 8:dbf8bd4815f8 347 {
jrodenburg 20:cdeed4dad690 348 gLed = 1;
jrodenburg 8:dbf8bd4815f8 349 dataTxReady = true;
jrodenburg 20:cdeed4dad690 350 gLed = 1;
jrodenburg 8:dbf8bd4815f8 351 }
jrodenburg 8:dbf8bd4815f8 352
jrodenburg 8:dbf8bd4815f8 353
jrodenburg 2:bd118a724f03 354 /* Function: parseRXData
jrodenburg 2:bd118a724f03 355 **************************************************************
jrodenburg 12:1cada1fe4743 356 Description: The parse received data into
jrodenburg 12:1cada1fe4743 357 Receives: chn: The channel we want to put into the channel
jrodenburg 12:1cada1fe4743 358 Returns: N/A
jrodenburg 1:0182b86f9bd4 359 */
jrodenburg 20:cdeed4dad690 360 void processRxUARTData()
jrodenburg 8:dbf8bd4815f8 361 {
jrodenburg 8:dbf8bd4815f8 362 HOST_CMD_HEADER *pRxPktHdr;
jrodenburg 2:bd118a724f03 363 string data = "";
jrodenburg 8:dbf8bd4815f8 364
jrodenburg 8:dbf8bd4815f8 365 pRxPktHdr = (HOST_CMD_HEADER *)rxBuf;
jrodenburg 8:dbf8bd4815f8 366
jrodenburg 20:cdeed4dad690 367 if (debug_control & RXDATA_PRINT) {
jrodenburg 20:cdeed4dad690 368 pc.printf("DBG: SOF=%02x, Len=%02x, CMD=%02x\r\n", pRxPktHdr->SOF_flag, pRxPktHdr->len, pRxPktHdr->cmd_type);
jrodenburg 20:cdeed4dad690 369 pc.printf("DBG: ");
jrodenburg 20:cdeed4dad690 370 for (int i=0; i <5; i++)
jrodenburg 20:cdeed4dad690 371 pc.printf("%02x ", rxBuf[i]);
jrodenburg 20:cdeed4dad690 372 pc.printf("\n");
jrodenburg 20:cdeed4dad690 373 }
jrodenburg 8:dbf8bd4815f8 374
jrodenburg 8:dbf8bd4815f8 375 // Exit if the packet does not contain correct header
jrodenburg 8:dbf8bd4815f8 376 // Maybe send NAK?
jrodenburg 8:dbf8bd4815f8 377 if ((pRxPktHdr->SOF_flag != RX_SOF) || (pRxPktHdr->Delim != DELIMETER))
jrodenburg 8:dbf8bd4815f8 378 return;
jrodenburg 2:bd118a724f03 379
jrodenburg 8:dbf8bd4815f8 380 switch (pRxPktHdr->cmd_type)
jrodenburg 8:dbf8bd4815f8 381 {
jrodenburg 8:dbf8bd4815f8 382 case SET_TEMPERATURE:
jrodenburg 8:dbf8bd4815f8 383 // Process set temp for specified channel
jrodenburg 8:dbf8bd4815f8 384 {
jrodenburg 8:dbf8bd4815f8 385 SET_TEMPERATURE_CMD *pRxPkt = (SET_TEMPERATURE_CMD *)(rxBuf);
jrodenburg 20:cdeed4dad690 386
jrodenburg 20:cdeed4dad690 387 if (debug_control & RXDATA_PRINT)
jrodenburg 20:cdeed4dad690 388 pc.printf("DBG: SETTEMP: ch = %02x, tempSet = %f, chanStat = %02x\r\n",
jrodenburg 20:cdeed4dad690 389 pRxPkt->chanID, pRxPkt->setTemp, pRxPkt->chanStat);
jrodenburg 20:cdeed4dad690 390
jrodenburg 8:dbf8bd4815f8 391 if ((pRxPkt->tempDelim != DELIMETER) || (pRxPkt->chanStatDelim != DELIMETER)) {
jrodenburg 8:dbf8bd4815f8 392 // Send NAK back
jrodenburg 8:dbf8bd4815f8 393 pc.printf("DBG: Error\n");
jrodenburg 2:bd118a724f03 394 }
jrodenburg 8:dbf8bd4815f8 395 else {
jrodenburg 8:dbf8bd4815f8 396 chanSel_SetTemp = pRxPkt->chanID;
jrodenburg 8:dbf8bd4815f8 397 chnlStatus[pRxPkt->chanID].status = pRxPkt->chanStat;
jrodenburg 20:cdeed4dad690 398 chnlStatus[pRxPkt->chanID].state = STATUS_INACTIVE;
jrodenburg 8:dbf8bd4815f8 399 chnlStatus[pRxPkt->chanID].setTemp = pRxPkt->setTemp;
jrodenburg 12:1cada1fe4743 400 chnlStatus[pRxPkt->chanID].error = 0;
jrodenburg 20:cdeed4dad690 401 chnlStatus[pRxPkt->chanID].errorEmailSent = 0;
jrodenburg 20:cdeed4dad690 402 chnlStatus[pRxPkt->chanID].i2cRxed = 0;
jrodenburg 8:dbf8bd4815f8 403 newTempSet = true;
jrodenburg 2:bd118a724f03 404 }
jrodenburg 2:bd118a724f03 405 }
jrodenburg 8:dbf8bd4815f8 406 break;
jrodenburg 8:dbf8bd4815f8 407
jrodenburg 8:dbf8bd4815f8 408 case SELECT_CHANNEL:
jrodenburg 8:dbf8bd4815f8 409 // Select channel to send temp data to
jrodenburg 8:dbf8bd4815f8 410 {
jrodenburg 8:dbf8bd4815f8 411 SELECT_CHANNEL_CMD *pRxPkt = (SELECT_CHANNEL_CMD *)(rxBuf);
jrodenburg 8:dbf8bd4815f8 412
jrodenburg 8:dbf8bd4815f8 413 chanSel_SendTemp = pRxPkt->chanIDSel;
jrodenburg 20:cdeed4dad690 414
jrodenburg 20:cdeed4dad690 415 // Send back FW version for each select channel
jrodenburg 20:cdeed4dad690 416 sendFWVersion();
jrodenburg 20:cdeed4dad690 417 if (debug_control & RXDATA_PRINT)
jrodenburg 20:cdeed4dad690 418 pc.printf("DBG: CHAN_SEL: chan=%02x, chanStat = %02x\r\n", pRxPkt->chanIDSel, pRxPkt->chanStat);
jrodenburg 20:cdeed4dad690 419
jrodenburg 2:bd118a724f03 420 }
jrodenburg 8:dbf8bd4815f8 421 break;
jrodenburg 8:dbf8bd4815f8 422
jrodenburg 15:74a01aaeb60e 423 case READ_UID:
jrodenburg 15:74a01aaeb60e 424 {
jrodenburg 15:74a01aaeb60e 425 READ_UID_CMD *pRxPkt = (READ_UID_CMD *)(rxBuf);
jrodenburg 20:cdeed4dad690 426 if (debug_control & RXDATA_PRINT)
jrodenburg 20:cdeed4dad690 427 pc.printf("DBG: Read UID: chan%02x\n", pRxPkt->chanIDSel);
jrodenburg 20:cdeed4dad690 428
jrodenburg 15:74a01aaeb60e 429 sendUID();
jrodenburg 15:74a01aaeb60e 430 }
jrodenburg 15:74a01aaeb60e 431 break;
jrodenburg 15:74a01aaeb60e 432
jrodenburg 20:cdeed4dad690 433 case READ_FW_VERSION:
jrodenburg 20:cdeed4dad690 434 {
jrodenburg 20:cdeed4dad690 435 sendFWVersion();
jrodenburg 20:cdeed4dad690 436 if (debug_control & RXDATA_PRINT)
jrodenburg 20:cdeed4dad690 437 pc.printf("DBG: Read SW Version\r\n");
jrodenburg 20:cdeed4dad690 438
jrodenburg 20:cdeed4dad690 439 }
jrodenburg 20:cdeed4dad690 440 break;
jrodenburg 20:cdeed4dad690 441
jrodenburg 20:cdeed4dad690 442 case DEBUG_CONTROL:
jrodenburg 20:cdeed4dad690 443 {
jrodenburg 20:cdeed4dad690 444 GUI_STANDARD_CMD *pRxPkt = (GUI_STANDARD_CMD *)rxBuf;
jrodenburg 20:cdeed4dad690 445 debug_control = pRxPkt->commandData;
jrodenburg 20:cdeed4dad690 446 if (debug_control & RXDATA_PRINT)
jrodenburg 20:cdeed4dad690 447 pc.printf ("DBG: Rx'd DEBUG CMD: %04x\r\n", pRxPkt->commandData);
jrodenburg 20:cdeed4dad690 448 }
jrodenburg 20:cdeed4dad690 449 break;
jrodenburg 20:cdeed4dad690 450
jrodenburg 20:cdeed4dad690 451
jrodenburg 8:dbf8bd4815f8 452 default:
jrodenburg 8:dbf8bd4815f8 453 // Error
jrodenburg 8:dbf8bd4815f8 454 break;
jrodenburg 2:bd118a724f03 455 }
jrodenburg 1:0182b86f9bd4 456 }
jrodenburg 0:a28a1035c31b 457
jrodenburg 0:a28a1035c31b 458 /* Function: get_temp
jrodenburg 0:a28a1035c31b 459 **************************************************************
jrodenburg 16:82d941b1ef21 460 Description: Convert A/D count to temperature value
jrodenburg 16:82d941b1ef21 461 Receives: ADC_val: the count from the A/D reading
jrodenburg 20:cdeed4dad690 462 Returns: the temp. of the A/D reading
jrodenburg 0:a28a1035c31b 463 */
jrodenburg 0:a28a1035c31b 464
jrodenburg 16:82d941b1ef21 465 float get_temp(float ADC_val){
jrodenburg 1:0182b86f9bd4 466 myled = 1;
jrodenburg 16:82d941b1ef21 467 //ltc2487.setAddress(addrLUT[chn].adc);
jrodenburg 12:1cada1fe4743 468
jrodenburg 16:82d941b1ef21 469 //float ADC_val = ltc2487.readOutput(port); //(65536*1.334)/2.5
jrodenburg 12:1cada1fe4743 470
jrodenburg 0:a28a1035c31b 471 int i = 0;
jrodenburg 12:1cada1fe4743 472
jrodenburg 0:a28a1035c31b 473 while((i < sizeLUT) && (thermLUT[i].adc > ADC_val)){
jrodenburg 12:1cada1fe4743 474 i++;
jrodenburg 0:a28a1035c31b 475 } //find the temp. above therm temp
jrodenburg 12:1cada1fe4743 476
jrodenburg 12:1cada1fe4743 477 //Point slope formula extrapolation:
jrodenburg 14:69cd53434783 478 // m = (y1-y0)/(x1-x0)+ y0 , y = temp. value, x = adc value
jrodenburg 0:a28a1035c31b 479 // y1 = thermLUT[i-1].temp y0 = thermLUT[i].temp
jrodenburg 0:a28a1035c31b 480 // x1 = thermLUT[i-1].adc x0 =thermLUT[i].adc
jrodenburg 0:a28a1035c31b 481 float a = float(thermLUT[i-1].temp - thermLUT[i].temp); //slope of temp between points where therm temp is between (Tmax - Tmin)
jrodenburg 0:a28a1035c31b 482 float b = float(thermLUT[i-1].adc - thermLUT[i].adc); //slope of adc between points where therm adc is between (Amax - Amin)
jrodenburg 12:1cada1fe4743 483
jrodenburg 0:a28a1035c31b 484 float m = a/b;
jrodenburg 0:a28a1035c31b 485 float y = (m*(ADC_val-thermLUT[i].adc))+thermLUT[i].temp;
jrodenburg 12:1cada1fe4743 486
jrodenburg 20:cdeed4dad690 487 if (debug_control & ADC_VAL_PRINT)
jrodenburg 20:cdeed4dad690 488 pc.printf("DBG: ADC VAL: %f TEMP: %f \r\n", ADC_val, y);
jrodenburg 12:1cada1fe4743 489
jrodenburg 12:1cada1fe4743 490 return y;
jrodenburg 0:a28a1035c31b 491 }
jrodenburg 0:a28a1035c31b 492
jrodenburg 20:cdeed4dad690 493 /* Function: get_front_temp_DATA
jrodenburg 16:82d941b1ef21 494 **************************************************************
jrodenburg 20:cdeed4dad690 495 Description: Read A/D data from LTC2487 and set array with front temp.
jrodenburg 20:cdeed4dad690 496 Save values in CHNL_TEMP data struct
jrodenburg 20:cdeed4dad690 497 Receives: N/A
jrodenburg 20:cdeed4dad690 498 Returns: int If the write recieved an ACK
jrodenburg 20:cdeed4dad690 499 */
jrodenburg 20:cdeed4dad690 500 void read_front_temp_data()
jrodenburg 20:cdeed4dad690 501 {
jrodenburg 20:cdeed4dad690 502 readThermistorTicker.detach();
jrodenburg 20:cdeed4dad690 503 //Write to all 8 channels selecting the front port to read
jrodenburg 20:cdeed4dad690 504 for(int chnl = 0; chnl < CHAN_COUNT; chnl++){
jrodenburg 20:cdeed4dad690 505 chnlStatus[chnl].i2cRxed = 0;
jrodenburg 20:cdeed4dad690 506 ltc2487.setAddress(addrLUT[chnl].adc);
jrodenburg 20:cdeed4dad690 507 //Check if write was ack'ed (0 = ACK, (non)0 = NACK)
jrodenburg 20:cdeed4dad690 508 chnlStatus[chnl].i2cRxed = !ltc2487.writePort(FRONT_THERM);
jrodenburg 20:cdeed4dad690 509 }
jrodenburg 20:cdeed4dad690 510 //wait until next clock cycle on LTC
jrodenburg 20:cdeed4dad690 511 //wait(I2C_READ_WAIT_TIME);
jrodenburg 20:cdeed4dad690 512 frontTempInProgTicker.attach(&update_front_temp_data, I2C_READ_WAIT_TIME);
jrodenburg 20:cdeed4dad690 513 }
jrodenburg 20:cdeed4dad690 514
jrodenburg 20:cdeed4dad690 515 void update_front_temp_data()
jrodenburg 20:cdeed4dad690 516 {
jrodenburg 20:cdeed4dad690 517 frontTempInProgTicker.detach();
jrodenburg 20:cdeed4dad690 518 for(int chnl = 0; chnl < CHAN_COUNT; chnl++){
jrodenburg 20:cdeed4dad690 519 ltc2487.setAddress(addrLUT[chnl].adc);
jrodenburg 20:cdeed4dad690 520 channelTempData[chnl].currTempFront = get_temp(ltc2487.read());
jrodenburg 20:cdeed4dad690 521 }
jrodenburg 20:cdeed4dad690 522 //wait until next clock cycle on LTC
jrodenburg 20:cdeed4dad690 523 //wait(0.08);
jrodenburg 20:cdeed4dad690 524 frontTempDoneTicker.attach(&read_back_temp, I2C_READ_WAIT_TIME);
jrodenburg 20:cdeed4dad690 525 }
jrodenburg 20:cdeed4dad690 526
jrodenburg 20:cdeed4dad690 527 /* Function: get_back_temp_DATA
jrodenburg 20:cdeed4dad690 528 **************************************************************
jrodenburg 20:cdeed4dad690 529 Description: Read A/D data from LTC2487 and set array with back temp.
jrodenburg 20:cdeed4dad690 530 Save values in CHNL_TEMP data struct
jrodenburg 16:82d941b1ef21 531 Receives: N/A
jrodenburg 16:82d941b1ef21 532 Returns: N/A
jrodenburg 16:82d941b1ef21 533 */
jrodenburg 16:82d941b1ef21 534
jrodenburg 20:cdeed4dad690 535 void read_back_temp()
jrodenburg 20:cdeed4dad690 536 {
jrodenburg 20:cdeed4dad690 537 frontTempDoneTicker.detach();
jrodenburg 16:82d941b1ef21 538 //Write to all 8 channels selecting the front port to read
jrodenburg 20:cdeed4dad690 539 for(int chnl = 0; chnl < CHAN_COUNT; chnl++){
jrodenburg 20:cdeed4dad690 540 chnlStatus[chnl].i2cRxed = 0;
jrodenburg 16:82d941b1ef21 541 ltc2487.setAddress(addrLUT[chnl].adc);
jrodenburg 20:cdeed4dad690 542 //Check if write was ack'ed (0 = ACK, (non)0 = NACK)
jrodenburg 20:cdeed4dad690 543 chnlStatus[chnl].i2cRxed = !ltc2487.writePort(BACK_THERM);
jrodenburg 16:82d941b1ef21 544 }
jrodenburg 20:cdeed4dad690 545
jrodenburg 16:82d941b1ef21 546 //wait until next clock cycle on LTC
jrodenburg 20:cdeed4dad690 547 //wait(I2C_READ_WAIT_TIME);
jrodenburg 20:cdeed4dad690 548 backTempInProgTicker.attach(&update_back_temp_data, I2C_READ_WAIT_TIME);
jrodenburg 20:cdeed4dad690 549 }
jrodenburg 20:cdeed4dad690 550
jrodenburg 20:cdeed4dad690 551 void update_back_temp_data()
jrodenburg 20:cdeed4dad690 552 {
jrodenburg 20:cdeed4dad690 553 backTempInProgTicker.detach();
jrodenburg 20:cdeed4dad690 554 for(int chnl = 0; chnl < CHAN_COUNT; chnl++){
jrodenburg 16:82d941b1ef21 555 ltc2487.setAddress(addrLUT[chnl].adc);
jrodenburg 16:82d941b1ef21 556 channelTempData[chnl].currTempBack = get_temp(ltc2487.read());
jrodenburg 16:82d941b1ef21 557 }
jrodenburg 20:cdeed4dad690 558 //wait until next clock cycle on LTC
jrodenburg 20:cdeed4dad690 559 //wait(0.08);
jrodenburg 20:cdeed4dad690 560 backTempDoneTicker.attach(&temperatureDataReady, I2C_READ_WAIT_TIME);
jrodenburg 20:cdeed4dad690 561
jrodenburg 20:cdeed4dad690 562 }
jrodenburg 20:cdeed4dad690 563
jrodenburg 20:cdeed4dad690 564 /* Function: temperatureDataReady
jrodenburg 20:cdeed4dad690 565 **************************************************************
jrodenburg 20:cdeed4dad690 566 Description: Flag that temperature data is ready to be
jrodenburg 20:cdeed4dad690 567 processed
jrodenburg 20:cdeed4dad690 568 Restart task timer
jrodenburg 20:cdeed4dad690 569 Receives: N/A
jrodenburg 20:cdeed4dad690 570 Returns: N/A
jrodenburg 20:cdeed4dad690 571 */
jrodenburg 20:cdeed4dad690 572 void temperatureDataReady()
jrodenburg 20:cdeed4dad690 573 {
jrodenburg 20:cdeed4dad690 574 backTempDoneTicker.detach();
jrodenburg 20:cdeed4dad690 575 newTempDataAvailable = true;
jrodenburg 20:cdeed4dad690 576 readThermistorTicker.attach(&read_front_temp_data, READ_TEMP_TASK_TIME);
jrodenburg 16:82d941b1ef21 577 }
jrodenburg 16:82d941b1ef21 578
jrodenburg 0:a28a1035c31b 579 /* Function: get_heater_current
jrodenburg 0:a28a1035c31b 580 **************************************************************
jrodenburg 0:a28a1035c31b 581 Description: Retrieve current into heater control MOSFET
jrodenburg 12:1cada1fe4743 582 Receives: chn: the channel of the fixture to read current from
jrodenburg 0:a28a1035c31b 583 Returns: the current into the heater control MOSFET
jrodenburg 0:a28a1035c31b 584 */
jrodenburg 20:cdeed4dad690 585 void get_heater_current(int chn, int port){
jrodenburg 16:82d941b1ef21 586 ltc2487.setAddress(addrLUT[chn].adc);
jrodenburg 16:82d941b1ef21 587 ltc2487.writePort(HEAT_FET_AMP);
jrodenburg 16:82d941b1ef21 588 wait(0.08);
jrodenburg 16:82d941b1ef21 589 ltc2487.read();
jrodenburg 16:82d941b1ef21 590 wait(0.08);
jrodenburg 0:a28a1035c31b 591 }
jrodenburg 0:a28a1035c31b 592
jrodenburg 0:a28a1035c31b 593 /* Function: get_valve_current
jrodenburg 0:a28a1035c31b 594 **************************************************************
jrodenburg 0:a28a1035c31b 595 Description: Retrieve current into valve control MOSFET
jrodenburg 12:1cada1fe4743 596 Receives: chn: the channel of the fixture to read current from
jrodenburg 0:a28a1035c31b 597 Returns: the current into the valve control MOSFET
jrodenburg 0:a28a1035c31b 598 */
jrodenburg 0:a28a1035c31b 599
jrodenburg 20:cdeed4dad690 600 void get_valve_current(int chn, int port){
jrodenburg 16:82d941b1ef21 601 ltc2487.setAddress(addrLUT[chn].adc);
jrodenburg 16:82d941b1ef21 602 ltc2487.writePort(VALVE_FET_AMP);
jrodenburg 16:82d941b1ef21 603 wait(0.08);
jrodenburg 16:82d941b1ef21 604 ltc2487.read();
jrodenburg 16:82d941b1ef21 605 wait(0.08);
jrodenburg 0:a28a1035c31b 606 }
jrodenburg 0:a28a1035c31b 607
jrodenburg 0:a28a1035c31b 608 /* Function: turn_valve_on
jrodenburg 0:a28a1035c31b 609 **************************************************************
jrodenburg 1:0182b86f9bd4 610 Description: Turn valve on and green status LED on
jrodenburg 12:1cada1fe4743 611 Receives: chn: the channel of the fixture
jrodenburg 1:0182b86f9bd4 612 Returns: N/A
jrodenburg 0:a28a1035c31b 613 */
jrodenburg 0:a28a1035c31b 614
jrodenburg 1:0182b86f9bd4 615 void turn_valve_on(int chn){
jrodenburg 0:a28a1035c31b 616 io_control.setAddress(addrLUT[chn].io);
jrodenburg 0:a28a1035c31b 617 io_control.init();
jrodenburg 1:0182b86f9bd4 618 io_control.writeOutput(1,0,1,0);
jrodenburg 0:a28a1035c31b 619 }
jrodenburg 0:a28a1035c31b 620
jrodenburg 0:a28a1035c31b 621 /* Function: turn_valve_off
jrodenburg 0:a28a1035c31b 622 **************************************************************
jrodenburg 1:0182b86f9bd4 623 Description: Turn valve off and green status LED on
jrodenburg 12:1cada1fe4743 624 Receives: chn: the channel of the fixture
jrodenburg 1:0182b86f9bd4 625 Returns: N/A
jrodenburg 0:a28a1035c31b 626 */
jrodenburg 0:a28a1035c31b 627
jrodenburg 1:0182b86f9bd4 628 void turn_valve_off(int chn){
jrodenburg 0:a28a1035c31b 629 io_control.setAddress(addrLUT[chn].io);
jrodenburg 0:a28a1035c31b 630 io_control.init();
jrodenburg 1:0182b86f9bd4 631 io_control.writeOutput(0,0,1,0);
jrodenburg 0:a28a1035c31b 632 }
jrodenburg 0:a28a1035c31b 633
jrodenburg 0:a28a1035c31b 634 /* Function: turn_heater_on
jrodenburg 0:a28a1035c31b 635 **************************************************************
jrodenburg 1:0182b86f9bd4 636 Description: Turn heater on and green status LED on
jrodenburg 12:1cada1fe4743 637 Receives: chn: the channel of the fixture
jrodenburg 1:0182b86f9bd4 638 Returns: N/A
jrodenburg 0:a28a1035c31b 639 */
jrodenburg 0:a28a1035c31b 640
jrodenburg 1:0182b86f9bd4 641 void turn_heater_on(int chn){
jrodenburg 0:a28a1035c31b 642 io_control.setAddress(addrLUT[chn].io);
jrodenburg 0:a28a1035c31b 643 io_control.init();
jrodenburg 1:0182b86f9bd4 644 io_control.writeOutput(0,1,1,0);
jrodenburg 0:a28a1035c31b 645 }
jrodenburg 0:a28a1035c31b 646
jrodenburg 0:a28a1035c31b 647 /* Function: turn_heater_off
jrodenburg 0:a28a1035c31b 648 **************************************************************
jrodenburg 1:0182b86f9bd4 649 Description: Turn heater off and green status LED on
jrodenburg 12:1cada1fe4743 650 Receives: chn: the channel of the fixture
jrodenburg 1:0182b86f9bd4 651 Returns: N/A
jrodenburg 0:a28a1035c31b 652 */
jrodenburg 0:a28a1035c31b 653
jrodenburg 1:0182b86f9bd4 654 void turn_heater_off(int chn){
jrodenburg 0:a28a1035c31b 655 io_control.setAddress(addrLUT[chn].io);
jrodenburg 0:a28a1035c31b 656 io_control.init();
jrodenburg 1:0182b86f9bd4 657 io_control.writeOutput(0,0,1,0);
jrodenburg 0:a28a1035c31b 658 }
jrodenburg 0:a28a1035c31b 659
jrodenburg 0:a28a1035c31b 660 /* Function: status_led
jrodenburg 0:a28a1035c31b 661 **************************************************************
jrodenburg 0:a28a1035c31b 662 Description: Turn status LED on (turns on green or red)
jrodenburg 12:1cada1fe4743 663 Receives: chn: the channel of the fixture
jrodenburg 0:a28a1035c31b 664 status: the status of channel (good (1) or bad (0))
jrodenburg 1:0182b86f9bd4 665 Returns: N/A
jrodenburg 0:a28a1035c31b 666 */
jrodenburg 0:a28a1035c31b 667
jrodenburg 1:0182b86f9bd4 668 void status_led(int chn, int status){
jrodenburg 20:cdeed4dad690 669 if(status == GREEN_STATUS_ON){
jrodenburg 20:cdeed4dad690 670 //green LED
jrodenburg 20:cdeed4dad690 671 if(debug_control & LED_PRINT) pc.printf("GREEN LED %d \r\n", chn);
jrodenburg 20:cdeed4dad690 672 io_control.setAddress(addrLUT[chn].io);
jrodenburg 20:cdeed4dad690 673 io_control.init();
jrodenburg 1:0182b86f9bd4 674 io_control.writeOutput(0,0,1,0);
jrodenburg 0:a28a1035c31b 675 }
jrodenburg 20:cdeed4dad690 676 if(status == RED_STATUS_ON){
jrodenburg 20:cdeed4dad690 677 //red LED
jrodenburg 20:cdeed4dad690 678 if(debug_control & LED_PRINT) pc.printf("RED LED %d \r\n", chn);
jrodenburg 20:cdeed4dad690 679 io_control.setAddress(addrLUT[chn].io);
jrodenburg 20:cdeed4dad690 680 io_control.init();
jrodenburg 20:cdeed4dad690 681 io_control.writeOutput(0,0,0,1);
jrodenburg 20:cdeed4dad690 682 }
jrodenburg 20:cdeed4dad690 683 if(status == ERROR_STATUS_ON){
jrodenburg 8:dbf8bd4815f8 684 //turn valve on too
jrodenburg 20:cdeed4dad690 685 if(debug_control & LED_PRINT) pc.printf("RED AND BLUE LED %d \r\n", chn);
jrodenburg 20:cdeed4dad690 686 io_control.setAddress(addrLUT[chn].io);
jrodenburg 20:cdeed4dad690 687 io_control.init();
jrodenburg 8:dbf8bd4815f8 688 io_control.writeOutput(1,0,0,1);
jrodenburg 0:a28a1035c31b 689 }
jrodenburg 20:cdeed4dad690 690 if(status == STATUS_OFF){
jrodenburg 20:cdeed4dad690 691 //turn valve on too
jrodenburg 20:cdeed4dad690 692 if(debug_control & LED_PRINT) pc.printf("ALL OFF %d \r\n", chn);
jrodenburg 20:cdeed4dad690 693 io_control.setAddress(addrLUT[chn].io);
jrodenburg 20:cdeed4dad690 694 io_control.init();
jrodenburg 20:cdeed4dad690 695 io_control.writeOutput(0,0,0,0);
jrodenburg 20:cdeed4dad690 696 }
jrodenburg 0:a28a1035c31b 697 }
jrodenburg 0:a28a1035c31b 698
jrodenburg 1:0182b86f9bd4 699 /* Function: test_mcp23008
jrodenburg 1:0182b86f9bd4 700 **************************************************************
jrodenburg 1:0182b86f9bd4 701 Description: Test each output of the MCP23009
jrodenburg 12:1cada1fe4743 702 Receives: N/A
jrodenburg 1:0182b86f9bd4 703 Returns: N/A
jrodenburg 1:0182b86f9bd4 704 */
jrodenburg 1:0182b86f9bd4 705
jrodenburg 1:0182b86f9bd4 706 void test_mcp23008(int chn){
jrodenburg 1:0182b86f9bd4 707 turn_valve_on(chn);
jrodenburg 7:8a5e65e63e2a 708 wait(0.5);
jrodenburg 1:0182b86f9bd4 709 turn_valve_off(chn);
jrodenburg 7:8a5e65e63e2a 710 wait(0.5);
jrodenburg 1:0182b86f9bd4 711 turn_heater_on(chn);
jrodenburg 7:8a5e65e63e2a 712 wait(0.5);
jrodenburg 1:0182b86f9bd4 713 turn_heater_off(chn);
jrodenburg 7:8a5e65e63e2a 714 wait(0.5);
jrodenburg 1:0182b86f9bd4 715 status_led(chn, 0);
jrodenburg 7:8a5e65e63e2a 716 wait(0.5);
jrodenburg 1:0182b86f9bd4 717 status_led(chn, 1);
jrodenburg 1:0182b86f9bd4 718 }
jrodenburg 1:0182b86f9bd4 719
jrodenburg 2:bd118a724f03 720 /* Function: test_ltc2487
jrodenburg 2:bd118a724f03 721 **************************************************************
jrodenburg 2:bd118a724f03 722 Description: Test the reading from LTC2487
jrodenburg 12:1cada1fe4743 723 Receives: N/A
jrodenburg 2:bd118a724f03 724 Returns: N/A
jrodenburg 2:bd118a724f03 725 */
jrodenburg 2:bd118a724f03 726
jrodenburg 16:82d941b1ef21 727 void test_ltc2487(){
jrodenburg 20:cdeed4dad690 728 for(int chnl = 0; chnl < CHAN_COUNT; chnl++){
jrodenburg 16:82d941b1ef21 729 float frontTemp = channelTempData[chnl].currTempFront;
jrodenburg 16:82d941b1ef21 730 float backTemp = channelTempData[chnl].currTempBack;
jrodenburg 16:82d941b1ef21 731 pc.printf("TEMPERATURE READING [%i]:: BACK: %f FRONT: %f \r\n", chnl, backTemp, frontTemp);
jrodenburg 16:82d941b1ef21 732 }
jrodenburg 2:bd118a724f03 733 }
jrodenburg 2:bd118a724f03 734
jrodenburg 8:dbf8bd4815f8 735 //***************************************************************
jrodenburg 8:dbf8bd4815f8 736 // Build packet with temperature readings to send to GUI
jrodenburg 8:dbf8bd4815f8 737 //***************************************************************
jrodenburg 20:cdeed4dad690 738 void processTxUARTData()
jrodenburg 20:cdeed4dad690 739 {
jrodenburg 16:82d941b1ef21 740 RESPONSE_TEMP_CMD response;
jrodenburg 8:dbf8bd4815f8 741 unsigned char *ptr = (unsigned char *)&response;
jrodenburg 8:dbf8bd4815f8 742 int i;
jrodenburg 8:dbf8bd4815f8 743
jrodenburg 8:dbf8bd4815f8 744 response.SOF_flag = TX_SOF;
jrodenburg 15:74a01aaeb60e 745 response.cmd_type = TEMP_DATA;
jrodenburg 16:82d941b1ef21 746 response.len = 5+(sizeof(response.chTemp));
jrodenburg 8:dbf8bd4815f8 747 response.Delim = DELIMETER;
jrodenburg 16:82d941b1ef21 748 response.chTemp[0] = channelTempData[0].currTempBack;
jrodenburg 16:82d941b1ef21 749 response.chTemp[1] = channelTempData[1].currTempBack;
jrodenburg 16:82d941b1ef21 750 response.chTemp[2] = channelTempData[2].currTempBack;
jrodenburg 16:82d941b1ef21 751 response.chTemp[3] = channelTempData[3].currTempBack;
jrodenburg 16:82d941b1ef21 752 response.chTemp[4] = channelTempData[4].currTempBack;
jrodenburg 16:82d941b1ef21 753 response.chTemp[5] = channelTempData[5].currTempBack;
jrodenburg 16:82d941b1ef21 754 response.chTemp[6] = channelTempData[6].currTempBack;
jrodenburg 16:82d941b1ef21 755 response.chTemp[7] = channelTempData[7].currTempBack;
jrodenburg 20:cdeed4dad690 756
jrodenburg 20:cdeed4dad690 757 // Send Errors Count/Info
jrodenburg 20:cdeed4dad690 758
jrodenburg 16:82d941b1ef21 759 /*float *dst = (float *)&response.chTemp[0];
jrodenburg 16:82d941b1ef21 760 float *src = (float *)&channelTempData[0];
jrodenburg 16:82d941b1ef21 761 memcpy(dst, src, sizeof(channelTempData));*/
jrodenburg 8:dbf8bd4815f8 762 response.EOF_flag = TX_EOF;
jrodenburg 8:dbf8bd4815f8 763
jrodenburg 8:dbf8bd4815f8 764 // Send response to GUI
jrodenburg 8:dbf8bd4815f8 765 for (i=0; i < response.len; i++, ptr++)
jrodenburg 8:dbf8bd4815f8 766 pc.printf("%02x", *ptr);
jrodenburg 8:dbf8bd4815f8 767 pc.printf("\n");
jrodenburg 8:dbf8bd4815f8 768 }
jrodenburg 8:dbf8bd4815f8 769
jrodenburg 12:1cada1fe4743 770 //***************************************************************
jrodenburg 15:74a01aaeb60e 771 // Build packet with Board UID (Unique Identification)
jrodenburg 15:74a01aaeb60e 772 //***************************************************************
jrodenburg 15:74a01aaeb60e 773 void sendUID ()
jrodenburg 15:74a01aaeb60e 774 {
jrodenburg 15:74a01aaeb60e 775 UID_RESPONSE response;
jrodenburg 15:74a01aaeb60e 776 unsigned char *ptr = (unsigned char *)&response;
jrodenburg 15:74a01aaeb60e 777 int i;
jrodenburg 15:74a01aaeb60e 778
jrodenburg 15:74a01aaeb60e 779 response.SOF_flag = TX_SOF;
jrodenburg 15:74a01aaeb60e 780 response.cmd_type = UID_DATA;
jrodenburg 15:74a01aaeb60e 781 response.len = 17;
jrodenburg 15:74a01aaeb60e 782 response.Delim = DELIMETER;
jrodenburg 15:74a01aaeb60e 783 response.UIDMH = (uint32_t)SIM->UIDMH;
jrodenburg 15:74a01aaeb60e 784 response.UIDML = (uint32_t)SIM->UIDML;
jrodenburg 15:74a01aaeb60e 785 response.UIDL = (uint32_t)SIM->UIDL;
jrodenburg 15:74a01aaeb60e 786 response.EOF_flag = TX_EOF;
jrodenburg 15:74a01aaeb60e 787
jrodenburg 15:74a01aaeb60e 788 // Send response to GUI
jrodenburg 15:74a01aaeb60e 789 for (i=0; i < response.len; i++, ptr++)
jrodenburg 15:74a01aaeb60e 790 pc.printf("%02x", *ptr);
jrodenburg 15:74a01aaeb60e 791 pc.printf("\n");
jrodenburg 15:74a01aaeb60e 792 }
jrodenburg 15:74a01aaeb60e 793
jrodenburg 15:74a01aaeb60e 794 //***************************************************************
jrodenburg 20:cdeed4dad690 795 // Build packet with SW Version
jrodenburg 20:cdeed4dad690 796 //***************************************************************
jrodenburg 20:cdeed4dad690 797 void sendFWVersion()
jrodenburg 20:cdeed4dad690 798 {
jrodenburg 20:cdeed4dad690 799 FW_VERSION_RESPONSE response;
jrodenburg 20:cdeed4dad690 800 unsigned char *ptr = (unsigned char *)&response;
jrodenburg 20:cdeed4dad690 801 int i;
jrodenburg 20:cdeed4dad690 802 rLed = 1;
jrodenburg 20:cdeed4dad690 803
jrodenburg 20:cdeed4dad690 804 for (i=0; i < 20; i++)
jrodenburg 20:cdeed4dad690 805 rLed = 0;
jrodenburg 20:cdeed4dad690 806
jrodenburg 20:cdeed4dad690 807 rLed = 1;
jrodenburg 20:cdeed4dad690 808
jrodenburg 20:cdeed4dad690 809 response.SOF_flag = TX_SOF;
jrodenburg 20:cdeed4dad690 810 response.cmd_type = FW_VERSION_DATA;
jrodenburg 20:cdeed4dad690 811 response.len = 13;
jrodenburg 20:cdeed4dad690 812 response.Delim = DELIMETER;
jrodenburg 20:cdeed4dad690 813 memcpy(response.FW_Version, FW_Version, 8);
jrodenburg 20:cdeed4dad690 814 response.FW_Version[7] = '\0';
jrodenburg 20:cdeed4dad690 815 response.EOF_flag = TX_EOF;
jrodenburg 20:cdeed4dad690 816
jrodenburg 20:cdeed4dad690 817 // Send response to GUI
jrodenburg 20:cdeed4dad690 818 for (i=0; i < response.len; i++, ptr++)
jrodenburg 20:cdeed4dad690 819 pc.printf("%02x", *ptr);
jrodenburg 20:cdeed4dad690 820 pc.printf("\n");
jrodenburg 20:cdeed4dad690 821 }
jrodenburg 20:cdeed4dad690 822
jrodenburg 20:cdeed4dad690 823 //***************************************************************
jrodenburg 12:1cada1fe4743 824 // Build packet with errors to send to GUI
jrodenburg 12:1cada1fe4743 825 //***************************************************************
jrodenburg 12:1cada1fe4743 826 void sendError (int chan, float error)
jrodenburg 12:1cada1fe4743 827 {
jrodenburg 12:1cada1fe4743 828 RESPONSE_CMD response;
jrodenburg 12:1cada1fe4743 829 unsigned char *ptr = (unsigned char *)&response;
jrodenburg 12:1cada1fe4743 830 int i;
jrodenburg 12:1cada1fe4743 831
jrodenburg 20:cdeed4dad690 832 if(chnlStatus[chan].errorEmailSent >= NUM_EMAIL_SEND)
jrodenburg 20:cdeed4dad690 833 return;
jrodenburg 20:cdeed4dad690 834
jrodenburg 12:1cada1fe4743 835 response.SOF_flag = TX_SOF;
jrodenburg 12:1cada1fe4743 836 response.cmd_type = ERROR_DATA;
jrodenburg 20:cdeed4dad690 837 response.len = 13;
jrodenburg 12:1cada1fe4743 838 response.Delim = DELIMETER;
jrodenburg 20:cdeed4dad690 839 response.channel = chan;
jrodenburg 12:1cada1fe4743 840 response.data = (float)error;
jrodenburg 20:cdeed4dad690 841
jrodenburg 12:1cada1fe4743 842 response.EOF_flag = TX_EOF;
jrodenburg 12:1cada1fe4743 843
jrodenburg 12:1cada1fe4743 844 // Send response to GUI
jrodenburg 12:1cada1fe4743 845 for (i=0; i < response.len; i++, ptr++)
jrodenburg 12:1cada1fe4743 846 pc.printf("%02x", *ptr);
jrodenburg 12:1cada1fe4743 847 pc.printf("\n");
jrodenburg 20:cdeed4dad690 848
jrodenburg 20:cdeed4dad690 849 chnlStatus[chan].errorEmailSent++;
jrodenburg 20:cdeed4dad690 850 }
jrodenburg 20:cdeed4dad690 851
jrodenburg 20:cdeed4dad690 852 /* Function: toggleI2C
jrodenburg 20:cdeed4dad690 853 **************************************************************
jrodenburg 20:cdeed4dad690 854 Description: Toggle the I2C line in an attempt to unfreeze it
jrodenburg 20:cdeed4dad690 855 Receives: N/A
jrodenburg 20:cdeed4dad690 856 Returns: N/A
jrodenburg 20:cdeed4dad690 857 */
jrodenburg 20:cdeed4dad690 858
jrodenburg 20:cdeed4dad690 859 void toggleI2C(){
jrodenburg 20:cdeed4dad690 860 DigitalOut ioSDAIn(PTC9);
jrodenburg 20:cdeed4dad690 861 DigitalOut adcSDAIn(PTC11);
jrodenburg 20:cdeed4dad690 862 DigitalOut ioSCLIn(PTC8);
jrodenburg 20:cdeed4dad690 863 DigitalOut adcSCLIn(PTC10);
jrodenburg 20:cdeed4dad690 864
jrodenburg 20:cdeed4dad690 865 ioSDAIn = 1;
jrodenburg 20:cdeed4dad690 866 adcSDAIn = 1;
jrodenburg 20:cdeed4dad690 867 ioSCLIn = 1;
jrodenburg 20:cdeed4dad690 868 adcSCLIn = 1;
jrodenburg 20:cdeed4dad690 869 wait(0.5);
jrodenburg 20:cdeed4dad690 870 ioSDAIn = 0;
jrodenburg 20:cdeed4dad690 871 adcSDAIn = 0;
jrodenburg 20:cdeed4dad690 872 ioSCLIn = 0;
jrodenburg 20:cdeed4dad690 873 adcSCLIn = 0;
jrodenburg 20:cdeed4dad690 874 wait(0.5);
jrodenburg 20:cdeed4dad690 875 ioSDAIn = 1;
jrodenburg 20:cdeed4dad690 876 adcSDAIn = 1;
jrodenburg 20:cdeed4dad690 877 ioSCLIn = 1;
jrodenburg 20:cdeed4dad690 878 adcSCLIn = 1;
jrodenburg 20:cdeed4dad690 879 wait(0.5);
jrodenburg 20:cdeed4dad690 880 ioSDAIn = 0;
jrodenburg 20:cdeed4dad690 881 adcSDAIn = 0;
jrodenburg 20:cdeed4dad690 882 ioSCLIn = 0;
jrodenburg 20:cdeed4dad690 883 adcSCLIn = 0;
jrodenburg 20:cdeed4dad690 884 wait(0.5);
jrodenburg 20:cdeed4dad690 885
jrodenburg 20:cdeed4dad690 886 MCP23008 io_control(PTC9, PTC8, 0x10, 100000); //sda, scl
jrodenburg 20:cdeed4dad690 887 LTC2487 ltc2487(PTC11, PTC10, 0x23, 100000); //sda, scl
jrodenburg 20:cdeed4dad690 888
jrodenburg 20:cdeed4dad690 889 }
jrodenburg 20:cdeed4dad690 890
jrodenburg 20:cdeed4dad690 891 /* Function: softwareReset
jrodenburg 20:cdeed4dad690 892 **************************************************************
jrodenburg 20:cdeed4dad690 893 Description: soft Reset
jrodenburg 20:cdeed4dad690 894 Recieves: N/A
jrodenburg 20:cdeed4dad690 895 Returns: N/A
jrodenburg 20:cdeed4dad690 896 */
jrodenburg 20:cdeed4dad690 897
jrodenburg 20:cdeed4dad690 898 void softwareReset(void){
jrodenburg 20:cdeed4dad690 899 SCB->AIRCR = (0x5FA<<SCB_AIRCR_VECTKEY_Pos)|SCB_AIRCR_SYSRESETREQ_Msk;
jrodenburg 20:cdeed4dad690 900 for(;;){}
jrodenburg 20:cdeed4dad690 901 }
jrodenburg 20:cdeed4dad690 902
jrodenburg 20:cdeed4dad690 903 /* Function: read I2C Line
jrodenburg 20:cdeed4dad690 904 **************************************************************
jrodenburg 20:cdeed4dad690 905 Description: Read the I2C line to check if pulled high
jrodenburg 20:cdeed4dad690 906 Receives: N/A
jrodenburg 20:cdeed4dad690 907 Returns: N/A
jrodenburg 20:cdeed4dad690 908 */
jrodenburg 20:cdeed4dad690 909
jrodenburg 20:cdeed4dad690 910 int readI2CLine(int line)
jrodenburg 20:cdeed4dad690 911 {
jrodenburg 20:cdeed4dad690 912 if(line == IO_I2C_LINE){
jrodenburg 20:cdeed4dad690 913 DigitalIn ioSDAIn(PTC9);
jrodenburg 20:cdeed4dad690 914 int ioSDA = ioSDAIn.read();
jrodenburg 20:cdeed4dad690 915 if(I2C_PRINT) pc.printf("DBG: TEMPERATURE SDA LINE: %d \r\n", ioSDA);
jrodenburg 20:cdeed4dad690 916 MCP23008 io_control(PTC9, PTC8, 0x10, 100000); //sda, scl
jrodenburg 20:cdeed4dad690 917 return ioSDA;
jrodenburg 20:cdeed4dad690 918 }
jrodenburg 20:cdeed4dad690 919 if(line == ADC_I2C_LINE){
jrodenburg 20:cdeed4dad690 920 DigitalIn adcSDAIn(PTC11);
jrodenburg 20:cdeed4dad690 921 int adcSDA = adcSDAIn.read();
jrodenburg 20:cdeed4dad690 922 if(I2C_PRINT) pc.printf("DBG: IO SDA LINE: %d \r\n", adcSDA);
jrodenburg 20:cdeed4dad690 923 LTC2487 ltc2487(PTC11, PTC10, 0x23, 100000); //sda, scl
jrodenburg 20:cdeed4dad690 924 return adcSDA;
jrodenburg 20:cdeed4dad690 925 }
jrodenburg 20:cdeed4dad690 926 return 0;
jrodenburg 12:1cada1fe4743 927 }
jrodenburg 6:c980535393ed 928
jrodenburg 14:69cd53434783 929 /* Function: error_check
jrodenburg 14:69cd53434783 930 **************************************************************
jrodenburg 14:69cd53434783 931 Description: Checks for any system errors
jrodenburg 14:69cd53434783 932 Recieves: frontTemp: temp. of front thermistor
jrodenburg 14:69cd53434783 933 backTemp: temp. of back thermistor
jrodenburg 14:69cd53434783 934 currTimeMin: currentTime in minutes
jrodenburg 20:cdeed4dad690 935 ioSDA: voltage on the SDA line
jrodenburg 20:cdeed4dad690 936 adcSDA: voltage on the SDA line
jrodenburg 14:69cd53434783 937 Returns: N/A
jrodenburg 14:69cd53434783 938 */
jrodenburg 14:69cd53434783 939
jrodenburg 20:cdeed4dad690 940 int error_check(int chnl, float currentTempFront, float currentTempBack, int currTimeMin, int ioSDA, int adcSDA){
jrodenburg 20:cdeed4dad690 941 //check if the thermistors are disconnected
jrodenburg 20:cdeed4dad690 942 if((currentTempFront == 0) || (currentTempBack == 0)){
jrodenburg 20:cdeed4dad690 943 if(chnlStatus[chnl].error >= MIN_ERROR_CNT_1){
jrodenburg 20:cdeed4dad690 944 sendError(chnl, 2);
jrodenburg 20:cdeed4dad690 945 status_led(chnl, RED_STATUS_ON);
jrodenburg 20:cdeed4dad690 946 }
jrodenburg 20:cdeed4dad690 947 else{
jrodenburg 20:cdeed4dad690 948 chnlStatus[chnl].error++;
jrodenburg 20:cdeed4dad690 949 }
jrodenburg 20:cdeed4dad690 950 if(debug_control & ERROR_PRINT) pc.printf("DBG: [%d] ERROR 2 \r\n", chnl);
jrodenburg 20:cdeed4dad690 951 return 1;
jrodenburg 20:cdeed4dad690 952 }
jrodenburg 20:cdeed4dad690 953 //check if the channels are disconnected
jrodenburg 20:cdeed4dad690 954 if(currentTempBack == currentTempFront){
jrodenburg 20:cdeed4dad690 955 if(chnlStatus[chnl].error >= MIN_ERROR_CNT_1){
jrodenburg 20:cdeed4dad690 956 sendError(chnl, 8);
jrodenburg 20:cdeed4dad690 957 status_led(chnl, RED_STATUS_ON);
jrodenburg 20:cdeed4dad690 958 }
jrodenburg 20:cdeed4dad690 959 else{
jrodenburg 20:cdeed4dad690 960 chnlStatus[chnl].error++;
jrodenburg 20:cdeed4dad690 961 }
jrodenburg 20:cdeed4dad690 962 if(debug_control & ERROR_PRINT) pc.printf("DBG: [%d] ERROR 2A \r\n", chnl);
jrodenburg 20:cdeed4dad690 963 return 1;
jrodenburg 14:69cd53434783 964 }
jrodenburg 20:cdeed4dad690 965
jrodenburg 20:cdeed4dad690 966 //check if there is a temperature difference |b| front and back
jrodenburg 20:cdeed4dad690 967 if((abs(currentTempBack - currentTempFront) >= TEMP_MARGIN)){
jrodenburg 20:cdeed4dad690 968 if(chnlStatus[chnl].error >= MIN_ERROR_CNT_2){
jrodenburg 20:cdeed4dad690 969 sendError(chnl, 3);
jrodenburg 20:cdeed4dad690 970 status_led(chnl, RED_STATUS_ON);
jrodenburg 20:cdeed4dad690 971 }
jrodenburg 20:cdeed4dad690 972 else{
jrodenburg 20:cdeed4dad690 973 chnlStatus[chnl].error++;
jrodenburg 20:cdeed4dad690 974 }
jrodenburg 20:cdeed4dad690 975 if(debug_control & ERROR_PRINT) pc.printf("DBG: [%d] ERROR 3 \r\n", chnl);
jrodenburg 20:cdeed4dad690 976 return 1;
jrodenburg 14:69cd53434783 977 }
jrodenburg 20:cdeed4dad690 978 //check if channels are over the MAX temperature
jrodenburg 20:cdeed4dad690 979 if((currentTempFront >= MAX_TEMP) || (currentTempBack >= MAX_TEMP)){
jrodenburg 20:cdeed4dad690 980 //if fixture over 65C for more than ~60s
jrodenburg 20:cdeed4dad690 981 if(chnlStatus[chnl].error >= MIN_ERROR_CNT_3){
jrodenburg 20:cdeed4dad690 982 sendError(chnl, 1);
jrodenburg 20:cdeed4dad690 983 status_led(chnl, RED_STATUS_ON);
jrodenburg 20:cdeed4dad690 984 if(debug_control & ERROR_PRINT) pc.printf("DBG: [%d] ERROR 1 SOFTWARE RESET %d \r\n", chnl, chnlStatus[chnl].error);
jrodenburg 20:cdeed4dad690 985 softwareReset();
jrodenburg 20:cdeed4dad690 986 }
jrodenburg 20:cdeed4dad690 987 //if fixture over 65C for more than ~1s
jrodenburg 20:cdeed4dad690 988 else if(chnlStatus[chnl].error >= MIN_ERROR_CNT_1){
jrodenburg 20:cdeed4dad690 989 sendError(chnl, 1);
jrodenburg 20:cdeed4dad690 990 status_led(chnl, RED_STATUS_ON);
jrodenburg 20:cdeed4dad690 991 if(debug_control & ERROR_PRINT) pc.printf("DBG: [%d] ERROR 1.9 SOFTWARE RESET %d \r\n", chnl, chnlStatus[chnl].error);
jrodenburg 20:cdeed4dad690 992 chnlStatus[chnl].error++;
jrodenburg 20:cdeed4dad690 993 }
jrodenburg 20:cdeed4dad690 994 else{
jrodenburg 20:cdeed4dad690 995 chnlStatus[chnl].error++;
jrodenburg 20:cdeed4dad690 996 }
jrodenburg 20:cdeed4dad690 997 if(debug_control & ERROR_PRINT) pc.printf("DBG: [%d] ERROR 1 \r\n", chnl);
jrodenburg 20:cdeed4dad690 998 return 1;
jrodenburg 14:69cd53434783 999 }
jrodenburg 20:cdeed4dad690 1000 //check if the valves are stuck open
jrodenburg 14:69cd53434783 1001 if(((currentTempFront <= MIN_TEMP) && (currentTempBack <= MIN_TEMP))){
jrodenburg 20:cdeed4dad690 1002 if(chnlStatus[chnl].error >= MIN_ERROR_CNT_1){
jrodenburg 20:cdeed4dad690 1003 sendError(chnl, 4);
jrodenburg 20:cdeed4dad690 1004 status_led(chnl, RED_STATUS_ON );
jrodenburg 20:cdeed4dad690 1005 }
jrodenburg 20:cdeed4dad690 1006 else{
jrodenburg 20:cdeed4dad690 1007 chnlStatus[chnl].error++;
jrodenburg 20:cdeed4dad690 1008 }
jrodenburg 20:cdeed4dad690 1009 if(debug_control & ERROR_PRINT) pc.printf("DBG: [%d] ERROR 4 \r\n", chnl);
jrodenburg 20:cdeed4dad690 1010 return 1;
jrodenburg 14:69cd53434783 1011 }
jrodenburg 14:69cd53434783 1012
jrodenburg 19:0946665b37c7 1013 //check that the SDA lines aren't stuck low
jrodenburg 19:0946665b37c7 1014 if((ioSDA != 1) || (adcSDA != 1)){
jrodenburg 20:cdeed4dad690 1015 if(chnlStatus[chnl].error >= MIN_ERROR_CNT_1){
jrodenburg 20:cdeed4dad690 1016 sendError(chnl, 6);
jrodenburg 20:cdeed4dad690 1017 status_led(chnl, RED_STATUS_ON );
jrodenburg 20:cdeed4dad690 1018 softwareReset();
jrodenburg 20:cdeed4dad690 1019 }
jrodenburg 20:cdeed4dad690 1020 else{
jrodenburg 20:cdeed4dad690 1021 toggleI2C();
jrodenburg 20:cdeed4dad690 1022 chnlStatus[chnl].error++;
jrodenburg 20:cdeed4dad690 1023 }
jrodenburg 20:cdeed4dad690 1024 if(debug_control & ERROR_PRINT) pc.printf("DBG: [%d] ERROR 6 \r\n", chnl);
jrodenburg 20:cdeed4dad690 1025 return 1;
jrodenburg 14:69cd53434783 1026 }
jrodenburg 20:cdeed4dad690 1027 //no errors
jrodenburg 20:cdeed4dad690 1028 return 0;
jrodenburg 14:69cd53434783 1029 }
jrodenburg 14:69cd53434783 1030
jrodenburg 6:c980535393ed 1031
jrodenburg 20:cdeed4dad690 1032 /* Function: systemLogic
jrodenburg 20:cdeed4dad690 1033 **************************************************************
jrodenburg 20:cdeed4dad690 1034 Description: Checks for any system errors
jrodenburg 20:cdeed4dad690 1035 Receives: Channel to modify
jrodenburg 20:cdeed4dad690 1036 Returns: N/A
jrodenburg 20:cdeed4dad690 1037 */
jrodenburg 20:cdeed4dad690 1038
jrodenburg 20:cdeed4dad690 1039 void systemLogic(){
jrodenburg 20:cdeed4dad690 1040 int chan;
jrodenburg 20:cdeed4dad690 1041 float currTemp;
jrodenburg 20:cdeed4dad690 1042
jrodenburg 20:cdeed4dad690 1043 for (chan=0; chan < CHAN_COUNT; chan++)
jrodenburg 20:cdeed4dad690 1044 {
jrodenburg 20:cdeed4dad690 1045 if(chnlStatus[chan].status == 1){
jrodenburg 20:cdeed4dad690 1046 //Current Temperature
jrodenburg 20:cdeed4dad690 1047 currTemp = channelTempData[chan].currTempBack;
jrodenburg 20:cdeed4dad690 1048
jrodenburg 20:cdeed4dad690 1049 if(currTemp > ((chnlStatus[chan].setTemp)+HYST_HIGH)){
jrodenburg 20:cdeed4dad690 1050 //TURN COOLING ON
jrodenburg 20:cdeed4dad690 1051 chnlStatus[chan].state = STATUS_COOLING;
jrodenburg 20:cdeed4dad690 1052 }
jrodenburg 20:cdeed4dad690 1053 else if(currTemp < ((chnlStatus[chan].setTemp)-HYST_LOW)){
jrodenburg 20:cdeed4dad690 1054 //TURN HEATER ON
jrodenburg 20:cdeed4dad690 1055 chnlStatus[chan].state = STATUS_HEATING;
jrodenburg 20:cdeed4dad690 1056 }
jrodenburg 20:cdeed4dad690 1057 else{
jrodenburg 20:cdeed4dad690 1058 //FIXTURE INACTIVE
jrodenburg 20:cdeed4dad690 1059 chnlStatus[chan].state = STATUS_INACTIVE;
jrodenburg 20:cdeed4dad690 1060 }
jrodenburg 20:cdeed4dad690 1061 }
jrodenburg 20:cdeed4dad690 1062 else{
jrodenburg 20:cdeed4dad690 1063 //FIXTURE STANDBY
jrodenburg 20:cdeed4dad690 1064 chnlStatus[chan].state = STATUS_STANDBY;
jrodenburg 20:cdeed4dad690 1065 }
jrodenburg 20:cdeed4dad690 1066 }
jrodenburg 20:cdeed4dad690 1067
jrodenburg 20:cdeed4dad690 1068 }
jrodenburg 20:cdeed4dad690 1069
jrodenburg 20:cdeed4dad690 1070 /* Function: systemControl
jrodenburg 20:cdeed4dad690 1071 **************************************************************
jrodenburg 20:cdeed4dad690 1072 Description: Checks for any system errors
jrodenburg 20:cdeed4dad690 1073 Receives: chn: Channel to modify
jrodenburg 20:cdeed4dad690 1074 Returns: N/A
jrodenburg 20:cdeed4dad690 1075 */
jrodenburg 20:cdeed4dad690 1076
jrodenburg 20:cdeed4dad690 1077 void systemControl()
jrodenburg 20:cdeed4dad690 1078 {
jrodenburg 20:cdeed4dad690 1079 int chan;
jrodenburg 20:cdeed4dad690 1080
jrodenburg 20:cdeed4dad690 1081 for (chan=0; chan < CHAN_COUNT; chan++){
jrodenburg 20:cdeed4dad690 1082 if(chnlStatus[chan].status == 1){
jrodenburg 20:cdeed4dad690 1083 if(chnlStatus[chan].state == STATUS_COOLING){
jrodenburg 20:cdeed4dad690 1084 //TURN COOLING ON
jrodenburg 20:cdeed4dad690 1085 turn_valve_on(chan);
jrodenburg 20:cdeed4dad690 1086 }
jrodenburg 20:cdeed4dad690 1087 else if(chnlStatus[chan].state == STATUS_HEATING){
jrodenburg 20:cdeed4dad690 1088 //TURN HEATER ON
jrodenburg 20:cdeed4dad690 1089 turn_heater_off(chan);
jrodenburg 20:cdeed4dad690 1090 turn_heater_on(chan);
jrodenburg 20:cdeed4dad690 1091 }
jrodenburg 20:cdeed4dad690 1092 else{
jrodenburg 20:cdeed4dad690 1093 //FIXTURE INACTIVE
jrodenburg 20:cdeed4dad690 1094 status_led(chan, GREEN_STATUS_ON );
jrodenburg 20:cdeed4dad690 1095 }
jrodenburg 20:cdeed4dad690 1096 }
jrodenburg 20:cdeed4dad690 1097 else
jrodenburg 20:cdeed4dad690 1098 {
jrodenburg 20:cdeed4dad690 1099 //FIXTURE INACTIVE
jrodenburg 20:cdeed4dad690 1100 if(standbyLED[chan]){
jrodenburg 20:cdeed4dad690 1101 status_led(chan, GREEN_STATUS_ON);
jrodenburg 20:cdeed4dad690 1102 standbyLED[chan] = !standbyLED[chan];
jrodenburg 20:cdeed4dad690 1103 }
jrodenburg 20:cdeed4dad690 1104 else{
jrodenburg 20:cdeed4dad690 1105 status_led(chan, STATUS_OFF);
jrodenburg 20:cdeed4dad690 1106 standbyLED[chan] = !standbyLED[chan];
jrodenburg 20:cdeed4dad690 1107 }
jrodenburg 20:cdeed4dad690 1108 }
jrodenburg 20:cdeed4dad690 1109 }
jrodenburg 20:cdeed4dad690 1110 }
jrodenburg 20:cdeed4dad690 1111
jrodenburg 20:cdeed4dad690 1112 void systemDiagnostic()
jrodenburg 20:cdeed4dad690 1113 {
jrodenburg 20:cdeed4dad690 1114 }
jrodenburg 20:cdeed4dad690 1115
jrodenburg 6:c980535393ed 1116 /*************************************************************/
jrodenburg 20:cdeed4dad690 1117 /* NEW MAIN FUNCTION */
jrodenburg 6:c980535393ed 1118 /*************************************************************/
jrodenburg 0:a28a1035c31b 1119
jrodenburg 20:cdeed4dad690 1120 int main(){
jrodenburg 20:cdeed4dad690 1121 /* INITIALIZATION CODE */
jrodenburg 8:dbf8bd4815f8 1122 // Setup serial port
jrodenburg 8:dbf8bd4815f8 1123 // Look for RX_EOF
jrodenburg 20:cdeed4dad690 1124 uint32_t UIDMH, UIDML, UIDL;
jrodenburg 20:cdeed4dad690 1125 int UID_print_count = 0;
jrodenburg 20:cdeed4dad690 1126
jrodenburg 20:cdeed4dad690 1127
jrodenburg 20:cdeed4dad690 1128 //*********************************
jrodenburg 20:cdeed4dad690 1129 // Initial thermistors readings
jrodenburg 20:cdeed4dad690 1130 // Kick off temperature reding
jrodenburg 20:cdeed4dad690 1131 // state machine
jrodenburg 20:cdeed4dad690 1132 //*********************************
jrodenburg 20:cdeed4dad690 1133 readThermistorTicker.attach(&read_front_temp_data, .0001);
jrodenburg 20:cdeed4dad690 1134
jrodenburg 8:dbf8bd4815f8 1135 pc.baud(9600);
jrodenburg 8:dbf8bd4815f8 1136 pc.autoDetectChar(RX_EOF);
jrodenburg 8:dbf8bd4815f8 1137 pc.attach(&rxInterrupt, MODSERIAL::RxAutoDetect);
jrodenburg 8:dbf8bd4815f8 1138
jrodenburg 15:74a01aaeb60e 1139 UIDMH = (uint32_t)SIM->UIDMH;
jrodenburg 15:74a01aaeb60e 1140 UIDML = (uint32_t)SIM->UIDML;
jrodenburg 15:74a01aaeb60e 1141 UIDL = (uint32_t)SIM->UIDL;
jrodenburg 15:74a01aaeb60e 1142
jrodenburg 20:cdeed4dad690 1143 //print UID three times on start-up to ID Mbed board
jrodenburg 20:cdeed4dad690 1144 if(UID_print_count++ < 3)
jrodenburg 20:cdeed4dad690 1145 pc.printf("DBG: [UID: %04X%08X%08X]\n", UIDMH, UIDML, UIDL);
jrodenburg 20:cdeed4dad690 1146
jrodenburg 18:aaec99ca68c3 1147
jrodenburg 0:a28a1035c31b 1148 while(1) {
jrodenburg 20:cdeed4dad690 1149 //*********************************
jrodenburg 20:cdeed4dad690 1150 // Process Rx UART data from GUI
jrodenburg 20:cdeed4dad690 1151 //*********************************
jrodenburg 20:cdeed4dad690 1152 if (dataReceived)
jrodenburg 20:cdeed4dad690 1153 {
jrodenburg 20:cdeed4dad690 1154 dataReceived = false;
jrodenburg 20:cdeed4dad690 1155 if (debug_control & RXDATA_PRINT)
jrodenburg 20:cdeed4dad690 1156 pc.printf("DBG: %d bytes Rx'd\n", pc.rxBufferGetCount());
jrodenburg 14:69cd53434783 1157
jrodenburg 20:cdeed4dad690 1158 pc.move(rxBuf, 50);
jrodenburg 20:cdeed4dad690 1159 processRxUARTData();
jrodenburg 20:cdeed4dad690 1160 pc.rxBufferFlush();
jrodenburg 13:604e6933366f 1161 }
jrodenburg 14:69cd53434783 1162
jrodenburg 20:cdeed4dad690 1163 //*********************************
jrodenburg 20:cdeed4dad690 1164 // Logic Loop
jrodenburg 20:cdeed4dad690 1165 //*********************************
jrodenburg 20:cdeed4dad690 1166 // System Logic/Control
jrodenburg 20:cdeed4dad690 1167 if (newTempDataAvailable)
jrodenburg 20:cdeed4dad690 1168 systemLogic();
jrodenburg 12:1cada1fe4743 1169
jrodenburg 20:cdeed4dad690 1170 //*********************************
jrodenburg 20:cdeed4dad690 1171 // System Diagnostic & Error Check
jrodenburg 20:cdeed4dad690 1172 //*********************************
jrodenburg 20:cdeed4dad690 1173 systemDiagnostic();
jrodenburg 12:1cada1fe4743 1174
jrodenburg 20:cdeed4dad690 1175 //*********************************
jrodenburg 20:cdeed4dad690 1176 // Process Tx UART data
jrodenburg 20:cdeed4dad690 1177 // Send Temperature Data/Error to GUI
jrodenburg 20:cdeed4dad690 1178 //*********************************
jrodenburg 20:cdeed4dad690 1179 if (newTempDataAvailable)
jrodenburg 20:cdeed4dad690 1180 {
jrodenburg 20:cdeed4dad690 1181 processTxUARTData();
jrodenburg 20:cdeed4dad690 1182
jrodenburg 20:cdeed4dad690 1183 //*********************************
jrodenburg 20:cdeed4dad690 1184 //Actuate Loop
jrodenburg 20:cdeed4dad690 1185 //*********************************
jrodenburg 20:cdeed4dad690 1186 systemControl();
jrodenburg 20:cdeed4dad690 1187 newTempDataAvailable = false;
jrodenburg 2:bd118a724f03 1188 }
jrodenburg 0:a28a1035c31b 1189 }
jrodenburg 20:cdeed4dad690 1190
jrodenburg 20:cdeed4dad690 1191 }