Team Walter / Mbed OS PICO_I2C_FW

PICO I2C FW

Dependencies:   USBDevice

main.cpp@18:d913ec9dd9c2, 2018-08-31 (annotated)

Committer:
cyberjoey
Date:
Fri Aug 31 19:47:40 2018 +0000
Revision:
18:d913ec9dd9c2
Parent:
17:401a5bb8d403
Child:
19:7081d6f6288b
First attempt full conversion to I2C

Who changed what in which revision?

UserRevisionLine numberNew contents of line
switches 0:60a522ae2e35 1 #include "mbed.h"
switches 1:90313362ec11 2 #include "SDFileSystem.h"
cyberjoey 9:36ba3626aab7 3 #include "max32630fthr.h"
cyberjoey 9:36ba3626aab7 4 #include "USBSerial.h"
cyberjoey 11:94a7379c0db8 5 #include <ctype.h>
switches 0:60a522ae2e35 6
cyberjoey 9:36ba3626aab7 7 #define PERIOD 10 // Logging period in seconds
cyberjoey 9:36ba3626aab7 8
cyberjoey 9:36ba3626aab7 9 //OT07 Registers
cyberjoey 9:36ba3626aab7 10 #define OT07_STATUS 0x00 // OT07 status regiter
cyberjoey 9:36ba3626aab7 11 #define OT07_INT_EN 0x01 // OT07 Interrupt Enable
cyberjoey 9:36ba3626aab7 12 #define OT07_FIFO_W 0x04 // OT07 FIFO Write Pointer
cyberjoey 9:36ba3626aab7 13 #define OT07_FIFO_R 0x05 // OT07 FIFO Read Pointer
cyberjoey 9:36ba3626aab7 14 #define OT07_FIFO_OF 0x06 // OT07 FIFO Overflow Counter
cyberjoey 9:36ba3626aab7 15 #define OT07_FIFO_COUNT 0x07 // OT07 FIFO Data Count
cyberjoey 9:36ba3626aab7 16 #define OT07_FIFO_DATA 0x08 // OT07 FIFO Data
cyberjoey 9:36ba3626aab7 17 #define OT07_FIFO_CNFG1 0x09 // OT07 FIFO Configuration 1 (FIFO_A_FULL)
cyberjoey 9:36ba3626aab7 18 #define OT07_FIFO_CNFG2 0x0A // OT07 FIFO Configuration 2
cyberjoey 9:36ba3626aab7 19 #define OT07_SYS 0x0C // OT07 System Configuration
cyberjoey 9:36ba3626aab7 20 #define OT07_ALARM_HIGH_MSB 0x10 // OT07 Alarm High MSB
cyberjoey 9:36ba3626aab7 21 #define OT07_ALARM_HIGH_LSB 0x11 // OT07 Alarm High LSB
cyberjoey 9:36ba3626aab7 22 #define OT07_ALARM_LOW_MSB 0x12 // OT07 Alarm Low MSB
cyberjoey 9:36ba3626aab7 23 #define OT07_ALARM_LOW_LSB 0x13 // OT07 Alarm LOW LSB
cyberjoey 17:401a5bb8d403 24 #define OT07_ADC_SETUP 0x14 // OT07 Temp Seneor Setup (ADC_RES[7:6]) & Convert Temperature [0]
cyberjoey 9:36ba3626aab7 25 #define OT07_GPIO_SETUP 0x20 // OT07 GPIO Setup, sets GPIO modes
cyberjoey 17:401a5bb8d403 26 #define OT07_GPIO_CTRL 0x21 // OT07 GPIO control
cyberjoey 9:36ba3626aab7 27 #define OT07_ROM_ID 0x30 // OT07 ROM_ID address of LSB?
cyberjoey 9:36ba3626aab7 28
cyberjoey 9:36ba3626aab7 29
cyberjoey 9:36ba3626aab7 30 #define MAX_DEVICES 64 // Maximum number of rom devices allowed
cyberjoey 9:36ba3626aab7 31 #define ID_LENGTH 8 // Rom ID length in bytes
cyberjoey 9:36ba3626aab7 32
cyberjoey 9:36ba3626aab7 33
cyberjoey 9:36ba3626aab7 34 #define BS 8 // ASCII Back Space
cyberjoey 9:36ba3626aab7 35 #define CR 13 // ASCII Carriage Return
cyberjoey 9:36ba3626aab7 36
cyberjoey 17:401a5bb8d403 37 struct OT07_struct {
cyberjoey 17:401a5bb8d403 38 char rom_id[ID_LENGTH]; // device 8 byte ROM ID
cyberjoey 17:401a5bb8d403 39 char I2C_address; // I2C addess, based on GPIO0 and GPIO1 at power up
cyberjoey 17:401a5bb8d403 40 };
cyberjoey 17:401a5bb8d403 41
cyberjoey 10:148da21c297e 42 const char* settings_file = "/sd/settings.txt";
cyberjoey 10:148da21c297e 43 const char* log_file = "/sd/MAX30207Log.csv";
cyberjoey 10:148da21c297e 44
cyberjoey 9:36ba3626aab7 45 //global variable
cyberjoey 9:36ba3626aab7 46
cyberjoey 9:36ba3626aab7 47 //******************** init Feather Boared Hardware ***********************
cyberjoey 9:36ba3626aab7 48
cyberjoey 9:36ba3626aab7 49 MAX32630FTHR pegasus(MAX32630FTHR::VIO_3V3);
cyberjoey 9:36ba3626aab7 50
cyberjoey 9:36ba3626aab7 51 //microSD logging file system setup
cyberjoey 9:36ba3626aab7 52 SDFileSystem sd(P0_5, P0_6, P0_4, P0_7, "sd"); // mosi, miso, sclk, cs
cyberjoey 9:36ba3626aab7 53
cyberjoey 9:36ba3626aab7 54 //SD card insertion detection pin
cyberjoey 9:36ba3626aab7 55 DigitalIn SDDetect(P2_2, PullUp);
cyberjoey 11:94a7379c0db8 56 InterruptIn SDInsert(P2_2);
cyberjoey 9:36ba3626aab7 57
cyberjoey 9:36ba3626aab7 58
cyberjoey 9:36ba3626aab7 59 // Virtual serial port over USB
cyberjoey 15:61dce4bef44f 60 USBSerial pc(0x0B6A, 0x0042, 0x0001, false);
cyberjoey 9:36ba3626aab7 61
cyberjoey 9:36ba3626aab7 62 // I2C setup
cyberjoey 9:36ba3626aab7 63 I2C i2c(P3_4,P3_5); // P3_4 -> I2C1_SDA, P3_5-> I2C1_SCL
cyberjoey 9:36ba3626aab7 64
cyberjoey 9:36ba3626aab7 65 //Timer setup
cyberjoey 9:36ba3626aab7 66 Ticker timer_1; // timer for blinking led heartbeat
cyberjoey 9:36ba3626aab7 67
cyberjoey 9:36ba3626aab7 68 bool tick_flag; // used for counting seconds
cyberjoey 9:36ba3626aab7 69 bool log_flag = false;
cyberjoey 9:36ba3626aab7 70 bool led_toggle_flag = false;
cyberjoey 9:36ba3626aab7 71 bool button_flag = false;
cyberjoey 11:94a7379c0db8 72 bool sd_insert_flag = false;
cyberjoey 9:36ba3626aab7 73 bool error_flag;
cyberjoey 9:36ba3626aab7 74 int error_ticks;
cyberjoey 9:36ba3626aab7 75
cyberjoey 9:36ba3626aab7 76 //LED blink setup
switches 1:90313362ec11 77 DigitalOut rLED(LED1);
switches 1:90313362ec11 78 DigitalOut gLED(LED2);
cyberjoey 9:36ba3626aab7 79 DigitalOut bLED(LED3);
switches 0:60a522ae2e35 80
cyberjoey 9:36ba3626aab7 81 InterruptIn button(SW1);
cyberjoey 9:36ba3626aab7 82
cyberjoey 9:36ba3626aab7 83
cyberjoey 9:36ba3626aab7 84 void LED_blink_callback(){ // LED Heart beat
cyberjoey 9:36ba3626aab7 85
cyberjoey 9:36ba3626aab7 86 led_toggle_flag = !led_toggle_flag;
cyberjoey 9:36ba3626aab7 87
cyberjoey 9:36ba3626aab7 88 if(log_flag) //if logging
cyberjoey 9:36ba3626aab7 89 {
cyberjoey 9:36ba3626aab7 90
cyberjoey 9:36ba3626aab7 91 if(led_toggle_flag)
cyberjoey 9:36ba3626aab7 92 {
cyberjoey 9:36ba3626aab7 93 //toggle red led
cyberjoey 9:36ba3626aab7 94 rLED = LED_ON;
cyberjoey 9:36ba3626aab7 95 }
cyberjoey 9:36ba3626aab7 96 else
cyberjoey 9:36ba3626aab7 97 {
cyberjoey 9:36ba3626aab7 98 rLED = LED_OFF;
cyberjoey 9:36ba3626aab7 99 gLED = LED_OFF;
cyberjoey 9:36ba3626aab7 100 bLED = LED_OFF;
cyberjoey 9:36ba3626aab7 101 }
cyberjoey 9:36ba3626aab7 102 }
cyberjoey 9:36ba3626aab7 103 else if(error_flag) //if error (no sd card)
cyberjoey 9:36ba3626aab7 104 {
cyberjoey 9:36ba3626aab7 105 if(led_toggle_flag)
cyberjoey 9:36ba3626aab7 106 {
cyberjoey 9:36ba3626aab7 107 //toggle red led
cyberjoey 9:36ba3626aab7 108 rLED = LED_ON;
cyberjoey 9:36ba3626aab7 109 gLED = LED_ON;
cyberjoey 9:36ba3626aab7 110 }
cyberjoey 9:36ba3626aab7 111 else
cyberjoey 9:36ba3626aab7 112 {
cyberjoey 9:36ba3626aab7 113 rLED = LED_OFF;
cyberjoey 9:36ba3626aab7 114 gLED = LED_OFF;
cyberjoey 9:36ba3626aab7 115 bLED = LED_OFF;
cyberjoey 9:36ba3626aab7 116 }
cyberjoey 9:36ba3626aab7 117 error_ticks--;
cyberjoey 9:36ba3626aab7 118 if(error_ticks <= 0)
cyberjoey 9:36ba3626aab7 119 error_flag = false;
cyberjoey 9:36ba3626aab7 120 }
cyberjoey 9:36ba3626aab7 121 else
cyberjoey 9:36ba3626aab7 122 {
cyberjoey 9:36ba3626aab7 123 if(led_toggle_flag)
cyberjoey 9:36ba3626aab7 124 {
cyberjoey 9:36ba3626aab7 125 //toggle teal leds
cyberjoey 9:36ba3626aab7 126 gLED = LED_ON;
cyberjoey 9:36ba3626aab7 127 bLED = LED_ON;
cyberjoey 9:36ba3626aab7 128 }
cyberjoey 9:36ba3626aab7 129 else
cyberjoey 9:36ba3626aab7 130 {
cyberjoey 9:36ba3626aab7 131 rLED = LED_OFF;
cyberjoey 9:36ba3626aab7 132 gLED = LED_OFF;
cyberjoey 9:36ba3626aab7 133 bLED = LED_OFF;
cyberjoey 9:36ba3626aab7 134 }
cyberjoey 9:36ba3626aab7 135 }
cyberjoey 9:36ba3626aab7 136
cyberjoey 9:36ba3626aab7 137 tick_flag = true;
cyberjoey 9:36ba3626aab7 138 }
cyberjoey 9:36ba3626aab7 139
cyberjoey 9:36ba3626aab7 140 void btn_pressed() //button pressed isr
cyberjoey 9:36ba3626aab7 141 {
cyberjoey 9:36ba3626aab7 142 button_flag = true;
cyberjoey 9:36ba3626aab7 143 }
cyberjoey 9:36ba3626aab7 144
cyberjoey 11:94a7379c0db8 145 void sd_insert() //sd_insert pressed isr
cyberjoey 11:94a7379c0db8 146 {
cyberjoey 11:94a7379c0db8 147 sd_insert_flag = true;
cyberjoey 11:94a7379c0db8 148 }
cyberjoey 11:94a7379c0db8 149
cyberjoey 9:36ba3626aab7 150
cyberjoey 9:36ba3626aab7 151 // *****************************************************************************
cyberjoey 9:36ba3626aab7 152 // Define CRC-8 Table
cyberjoey 9:36ba3626aab7 153 // *****************************************************************************
cyberjoey 9:36ba3626aab7 154
cyberjoey 9:36ba3626aab7 155 static unsigned char crc_table[] = {
cyberjoey 9:36ba3626aab7 156 0, 94,188,226, 97, 63,221,131,194,156,126, 32,163,253, 31, 65,
cyberjoey 9:36ba3626aab7 157 157,195, 33,127,252,162, 64, 30, 95, 1,227,189, 62, 96,130,220,
cyberjoey 9:36ba3626aab7 158 35,125,159,193, 66, 28,254,160,225,191, 93, 3,128,222, 60, 98,
cyberjoey 9:36ba3626aab7 159 190,224, 2, 92,223,129, 99, 61,124, 34,192,158, 29, 67,161,255,
cyberjoey 9:36ba3626aab7 160 70, 24,250,164, 39,121,155,197,132,218, 56,102,229,187, 89, 7,
cyberjoey 9:36ba3626aab7 161 219,133,103, 57,186,228, 6, 88, 25, 71,165,251,120, 38,196,154,
cyberjoey 9:36ba3626aab7 162 101, 59,217,135, 4, 90,184,230,167,249, 27, 69,198,152,122, 36,
cyberjoey 9:36ba3626aab7 163 248,166, 68, 26,153,199, 37,123, 58,100,134,216, 91, 5,231,185,
cyberjoey 9:36ba3626aab7 164 140,210, 48,110,237,179, 81, 15, 78, 16,242,172, 47,113,147,205,
cyberjoey 9:36ba3626aab7 165 17, 79,173,243,112, 46,204,146,211,141,111, 49,178,236, 14, 80,
cyberjoey 9:36ba3626aab7 166 175,241, 19, 77,206,144,114, 44,109, 51,209,143, 12, 82,176,238,
cyberjoey 9:36ba3626aab7 167 50,108,142,208, 83, 13,239,177,240,174, 76, 18,145,207, 45,115,
cyberjoey 9:36ba3626aab7 168 202,148,118, 40,171,245, 23, 73, 8, 86,180,234,105, 55,213,139,
cyberjoey 9:36ba3626aab7 169 87, 9,235,181, 54,104,138,212,149,203, 41,119,244,170, 72, 22,
cyberjoey 9:36ba3626aab7 170 233,183, 85, 11,136,214, 52,106, 43,117,151,201, 74, 20,246,168,
cyberjoey 9:36ba3626aab7 171 116, 42,200,150, 21, 75,169,247,182,232, 10, 84,215,137,107, 53};
cyberjoey 9:36ba3626aab7 172
cyberjoey 9:36ba3626aab7 173
cyberjoey 9:36ba3626aab7 174
cyberjoey 9:36ba3626aab7 175 // -----------------------------------------------------------------------------
cyberjoey 9:36ba3626aab7 176 // Calculate the CRC8 of the byte value provided with the current total
cyberjoey 9:36ba3626aab7 177 // calc_crc8(unsigned char, unsigned char) crc8 total, byte to add
cyberjoey 9:36ba3626aab7 178 // pass crc8 total = 0 to start new crc sum.
cyberjoey 9:36ba3626aab7 179
cyberjoey 9:36ba3626aab7 180 // Returns new crc8 total
cyberjoey 9:36ba3626aab7 181 // -----------------------------------------------------------------------------
cyberjoey 9:36ba3626aab7 182
cyberjoey 9:36ba3626aab7 183 unsigned char calc_crc8(unsigned char crc8, unsigned char value){
cyberjoey 9:36ba3626aab7 184
cyberjoey 9:36ba3626aab7 185 return crc_table[crc8 ^ value];
cyberjoey 9:36ba3626aab7 186 }
cyberjoey 9:36ba3626aab7 187
cyberjoey 9:36ba3626aab7 188 // *****************************************************************************
cyberjoey 17:401a5bb8d403 189 // OT07_write_register(char, char, char) writes single byte to OT07
cyberjoey 17:401a5bb8d403 190 // char I2C address
cyberjoey 17:401a5bb8d403 191 // char OT07 register address
cyberjoey 17:401a5bb8d403 192 // char data byte to be writen
cyberjoey 17:401a5bb8d403 193 // returns 0 on success ACK, 1 on NACK
cyberjoey 17:401a5bb8d403 194 // *****************************************************************************
cyberjoey 17:401a5bb8d403 195
cyberjoey 17:401a5bb8d403 196 int OT07_write_register(char I2C_add, char reg_add, char byte){
cyberjoey 17:401a5bb8d403 197 char data[2];
cyberjoey 17:401a5bb8d403 198 int error;
cyberjoey 17:401a5bb8d403 199 data[0] = reg_add;
cyberjoey 17:401a5bb8d403 200 data[1] = byte;
cyberjoey 17:401a5bb8d403 201 error = i2c.write(I2C_add,data,2);
cyberjoey 17:401a5bb8d403 202 //if(DEBUG)db.printf("wr[%02X %02X %d]\r\n", data[0], data[1], error);
cyberjoey 17:401a5bb8d403 203 return error;
cyberjoey 17:401a5bb8d403 204
cyberjoey 17:401a5bb8d403 205 }
cyberjoey 17:401a5bb8d403 206
cyberjoey 17:401a5bb8d403 207 /// ****************************************************************************
cyberjoey 17:401a5bb8d403 208 // OT07_write_register(char, char, char *, int) writes multiple bytes to OT07
cyberjoey 17:401a5bb8d403 209 // char I2C address
cyberjoey 17:401a5bb8d403 210 // char OT07 register address
cyberjoey 17:401a5bb8d403 211 // char * data vector of bytes to be written
cyberjoey 17:401a5bb8d403 212 // int number of bytes to write
cyberjoey 17:401a5bb8d403 213 // returns 0 on success ACK, 1 on NACK
cyberjoey 17:401a5bb8d403 214 // *****************************************************************************
cyberjoey 17:401a5bb8d403 215
cyberjoey 17:401a5bb8d403 216 int OT07_write_register(char I2C_add, char reg_add, char *bytes, int n){
cyberjoey 17:401a5bb8d403 217 int i;
cyberjoey 17:401a5bb8d403 218 //set start address
cyberjoey 17:401a5bb8d403 219 char data[16];
cyberjoey 17:401a5bb8d403 220 int error;
cyberjoey 17:401a5bb8d403 221 data[0] = reg_add;
cyberjoey 17:401a5bb8d403 222 for(i=1;i<=n;i++){
cyberjoey 17:401a5bb8d403 223 data[i] = bytes[i-1];
cyberjoey 17:401a5bb8d403 224 }
cyberjoey 17:401a5bb8d403 225 error = i2c.write(I2C_add,data,n+1); // send n bytes of data
cyberjoey 17:401a5bb8d403 226
cyberjoey 17:401a5bb8d403 227 return error;
cyberjoey 17:401a5bb8d403 228 }
cyberjoey 17:401a5bb8d403 229
cyberjoey 17:401a5bb8d403 230 // *****************************************************************************
cyberjoey 17:401a5bb8d403 231 // OT07_read_register(char, char, char *, int) writes single byte to OT07
cyberjoey 17:401a5bb8d403 232 // char I2C address
cyberjoey 17:401a5bb8d403 233 // char OT07 register address
cyberjoey 17:401a5bb8d403 234 // char * data vector for read bytes to be stored in
cyberjoey 17:401a5bb8d403 235 // int number of bytes to read
cyberjoey 17:401a5bb8d403 236 // returns 0 on success, 1 on fail
cyberjoey 17:401a5bb8d403 237 // *****************************************************************************
cyberjoey 17:401a5bb8d403 238
cyberjoey 17:401a5bb8d403 239 int OT07_read_register(char I2C_add, char reg_add, char *bytes, int n){
cyberjoey 17:401a5bb8d403 240 int error;
cyberjoey 17:401a5bb8d403 241 error = i2c.write(I2C_add,&reg_add,1,1);
cyberjoey 17:401a5bb8d403 242 if(error)return error;
cyberjoey 17:401a5bb8d403 243 error = i2c.read(I2C_add,bytes,n);
cyberjoey 17:401a5bb8d403 244 //if(DEBUG)db.printf("rr e[%d]\r\n",error);
cyberjoey 17:401a5bb8d403 245 return error;
cyberjoey 17:401a5bb8d403 246 }
cyberjoey 17:401a5bb8d403 247
cyberjoey 17:401a5bb8d403 248 // *****************************************************************************
cyberjoey 17:401a5bb8d403 249 // search_I2C_bus(OT07_struct *) searches I2C address 0xA0, 0xA2, 0xA4 and 0xA6
cyberjoey 17:401a5bb8d403 250 // OT07_struct * structure array to holds I2C address and rom_ids
cyberjoey 17:401a5bb8d403 251 // returns number of devices found
cyberjoey 17:401a5bb8d403 252 // *****************************************************************************
cyberjoey 17:401a5bb8d403 253
cyberjoey 17:401a5bb8d403 254 int search_I2C_bus(OT07_struct OT07[]){
cyberjoey 17:401a5bb8d403 255 char data[16];
cyberjoey 17:401a5bb8d403 256 char I2C_add;
cyberjoey 17:401a5bb8d403 257 //char GPIO;
cyberjoey 17:401a5bb8d403 258 int error;
cyberjoey 17:401a5bb8d403 259 int device_count = 0;
cyberjoey 17:401a5bb8d403 260 int i;
cyberjoey 17:401a5bb8d403 261 int j;
cyberjoey 17:401a5bb8d403 262 for(i = 0;i<4;i++){
cyberjoey 17:401a5bb8d403 263 I2C_add = 0xA0 + i*2;
cyberjoey 17:401a5bb8d403 264 error = OT07_read_register(I2C_add,0xff,data,1);
cyberjoey 17:401a5bb8d403 265
cyberjoey 17:401a5bb8d403 266 if(error == 0){
cyberjoey 17:401a5bb8d403 267 if(data[0] == 0x30){
cyberjoey 17:401a5bb8d403 268
cyberjoey 17:401a5bb8d403 269 OT07[device_count].I2C_address = I2C_add;
cyberjoey 17:401a5bb8d403 270
cyberjoey 17:401a5bb8d403 271 OT07_read_register(I2C_add,OT07_ROM_ID,data,8);
cyberjoey 17:401a5bb8d403 272 for(j=7;j>=0;j--){
cyberjoey 17:401a5bb8d403 273 OT07[device_count].rom_id[j] = data[j];
cyberjoey 17:401a5bb8d403 274
cyberjoey 17:401a5bb8d403 275 }
cyberjoey 17:401a5bb8d403 276 device_count++;
cyberjoey 17:401a5bb8d403 277 }
cyberjoey 17:401a5bb8d403 278 }
cyberjoey 17:401a5bb8d403 279
cyberjoey 17:401a5bb8d403 280 }
cyberjoey 17:401a5bb8d403 281 return device_count;
cyberjoey 17:401a5bb8d403 282 }
cyberjoey 17:401a5bb8d403 283
cyberjoey 17:401a5bb8d403 284 // *****************************************************************************
cyberjoey 17:401a5bb8d403 285 // convert_temperature(char) sends convert command to OT07 device
cyberjoey 17:401a5bb8d403 286 // char I2C address
cyberjoey 17:401a5bb8d403 287 // *****************************************************************************
cyberjoey 17:401a5bb8d403 288
cyberjoey 17:401a5bb8d403 289 void convert_temperature(char I2C_add){ // set convert bit to start conversion
cyberjoey 17:401a5bb8d403 290
cyberjoey 17:401a5bb8d403 291 char data[2];
cyberjoey 17:401a5bb8d403 292
cyberjoey 17:401a5bb8d403 293 //read ADC_SETUP register 0x14
cyberjoey 17:401a5bb8d403 294 OT07_read_register(I2C_add, OT07_ADC_SETUP,data,1);
cyberjoey 17:401a5bb8d403 295
cyberjoey 17:401a5bb8d403 296 //mask convert register value with 0x01 and write back register 0x14
cyberjoey 17:401a5bb8d403 297 OT07_write_register(I2C_add, OT07_ADC_SETUP, data[0]|0x01);
cyberjoey 17:401a5bb8d403 298 }
cyberjoey 17:401a5bb8d403 299
cyberjoey 17:401a5bb8d403 300 //******************************************************************************
cyberjoey 17:401a5bb8d403 301 // get_temperature(char) read temperature from OT07 device FIFO register
cyberjoey 17:401a5bb8d403 302 // char I2C address
cyberjoey 17:401a5bb8d403 303 // returns double temperature in oC
cyberjoey 17:401a5bb8d403 304 //******************************************************************************
cyberjoey 17:401a5bb8d403 305
cyberjoey 17:401a5bb8d403 306 double get_temperature(char I2C_add){
cyberjoey 17:401a5bb8d403 307 char data[2];
cyberjoey 17:401a5bb8d403 308 double T;
cyberjoey 17:401a5bb8d403 309 int count;
cyberjoey 17:401a5bb8d403 310
cyberjoey 17:401a5bb8d403 311 OT07_read_register(I2C_add,OT07_FIFO_DATA,data,2); // Read temperature from FIFO, 2 bytes
cyberjoey 17:401a5bb8d403 312 //if(DEBUG)db.printf("get_temperature -- FIFO[%02X %02X]\r\n",data[0],data[1]);
cyberjoey 17:401a5bb8d403 313 //calculate temperture from data
cyberjoey 17:401a5bb8d403 314 count = (int)(data[0]*256 + data[1]);
cyberjoey 17:401a5bb8d403 315 if (count >= 32768)count = count - 65536; // 2s comp
cyberjoey 17:401a5bb8d403 316 T = (double)count*0.005;
cyberjoey 17:401a5bb8d403 317
cyberjoey 17:401a5bb8d403 318 return T;
cyberjoey 17:401a5bb8d403 319 }
cyberjoey 17:401a5bb8d403 320
cyberjoey 9:36ba3626aab7 321
cyberjoey 10:148da21c297e 322 void write_settings_file(int interval, bool device_logged[MAX_DEVICES])
cyberjoey 10:148da21c297e 323 {
cyberjoey 10:148da21c297e 324 FILE *fp = fopen(settings_file, "w");
cyberjoey 10:148da21c297e 325 if (fp != NULL)
cyberjoey 10:148da21c297e 326 {
cyberjoey 10:148da21c297e 327 fprintf(fp, "i %d\r\n", interval);
cyberjoey 10:148da21c297e 328
cyberjoey 10:148da21c297e 329 fprintf(fp, "d");
cyberjoey 10:148da21c297e 330
cyberjoey 10:148da21c297e 331 for(int i = 0; i < MAX_DEVICES; i++)
cyberjoey 10:148da21c297e 332 {
cyberjoey 10:148da21c297e 333 if(device_logged[i] == true)
cyberjoey 10:148da21c297e 334 {
cyberjoey 10:148da21c297e 335 fprintf(fp," %d", i);
cyberjoey 10:148da21c297e 336 }
cyberjoey 10:148da21c297e 337 }
cyberjoey 10:148da21c297e 338 fprintf(fp,"\r\n");
cyberjoey 10:148da21c297e 339
cyberjoey 10:148da21c297e 340 fclose(fp);
cyberjoey 10:148da21c297e 341 }
cyberjoey 10:148da21c297e 342 return;
cyberjoey 10:148da21c297e 343 }
cyberjoey 10:148da21c297e 344
cyberjoey 10:148da21c297e 345 bool print_settings_file()
cyberjoey 10:148da21c297e 346 {
cyberjoey 10:148da21c297e 347 FILE *fp = fopen(settings_file, "r");
cyberjoey 10:148da21c297e 348 if (fp != NULL)
cyberjoey 10:148da21c297e 349 {
cyberjoey 10:148da21c297e 350 pc.printf("*\r\n");
cyberjoey 10:148da21c297e 351
cyberjoey 10:148da21c297e 352 // Read contents from file
cyberjoey 10:148da21c297e 353 char c = fgetc(fp);
cyberjoey 11:94a7379c0db8 354
cyberjoey 10:148da21c297e 355 while (!feof(fp))
cyberjoey 10:148da21c297e 356 {
cyberjoey 10:148da21c297e 357 pc.printf("%c", c);
cyberjoey 10:148da21c297e 358 c = fgetc(fp);
cyberjoey 10:148da21c297e 359 }
cyberjoey 10:148da21c297e 360
cyberjoey 10:148da21c297e 361 pc.printf("*\r\n");
cyberjoey 10:148da21c297e 362
cyberjoey 10:148da21c297e 363 fclose(fp);
cyberjoey 10:148da21c297e 364 }
cyberjoey 10:148da21c297e 365 else
cyberjoey 10:148da21c297e 366 {
cyberjoey 10:148da21c297e 367 return false;
cyberjoey 10:148da21c297e 368 }
cyberjoey 10:148da21c297e 369 return true;
cyberjoey 10:148da21c297e 370 }
cyberjoey 10:148da21c297e 371
cyberjoey 10:148da21c297e 372 bool print_log_file()
cyberjoey 10:148da21c297e 373 {
cyberjoey 10:148da21c297e 374 FILE *fp = fopen(log_file, "r");
cyberjoey 10:148da21c297e 375 if (fp != NULL)
cyberjoey 10:148da21c297e 376 {
cyberjoey 10:148da21c297e 377 pc.printf("*\r\n");
cyberjoey 10:148da21c297e 378
cyberjoey 10:148da21c297e 379 // Read contents from file
cyberjoey 10:148da21c297e 380 char c = fgetc(fp);
cyberjoey 10:148da21c297e 381 while (!feof(fp))
cyberjoey 10:148da21c297e 382 {
cyberjoey 10:148da21c297e 383 pc.printf("%c", c);
cyberjoey 10:148da21c297e 384 c = fgetc(fp);
cyberjoey 10:148da21c297e 385 }
cyberjoey 10:148da21c297e 386
cyberjoey 10:148da21c297e 387 pc.printf("*\r\n");
cyberjoey 10:148da21c297e 388
cyberjoey 10:148da21c297e 389 fclose(fp);
cyberjoey 10:148da21c297e 390 }
cyberjoey 10:148da21c297e 391 else
cyberjoey 10:148da21c297e 392 {
cyberjoey 10:148da21c297e 393 return false;
cyberjoey 10:148da21c297e 394 }
cyberjoey 10:148da21c297e 395 return true;
cyberjoey 10:148da21c297e 396 }
cyberjoey 10:148da21c297e 397
cyberjoey 11:94a7379c0db8 398 int getline(char **lineptr, int *n, FILE *stream) {
cyberjoey 11:94a7379c0db8 399 char *bufptr = NULL;
cyberjoey 11:94a7379c0db8 400 char *p = bufptr;
cyberjoey 11:94a7379c0db8 401 size_t size;
cyberjoey 11:94a7379c0db8 402 int c;
cyberjoey 11:94a7379c0db8 403
cyberjoey 11:94a7379c0db8 404 if (lineptr == NULL) {
cyberjoey 11:94a7379c0db8 405 return -1;
cyberjoey 11:94a7379c0db8 406 }
cyberjoey 11:94a7379c0db8 407 if (stream == NULL) {
cyberjoey 11:94a7379c0db8 408 return -1;
cyberjoey 11:94a7379c0db8 409 }
cyberjoey 11:94a7379c0db8 410 if (n == NULL) {
cyberjoey 11:94a7379c0db8 411 return -1;
cyberjoey 11:94a7379c0db8 412 }
cyberjoey 11:94a7379c0db8 413 bufptr = *lineptr;
cyberjoey 11:94a7379c0db8 414 size = *n;
cyberjoey 11:94a7379c0db8 415
cyberjoey 11:94a7379c0db8 416 c = fgetc(stream);
cyberjoey 11:94a7379c0db8 417 if (c == EOF) {
cyberjoey 11:94a7379c0db8 418 return -1;
cyberjoey 11:94a7379c0db8 419 }
cyberjoey 11:94a7379c0db8 420 if (bufptr == NULL) {
cyberjoey 11:94a7379c0db8 421 bufptr = (char *)malloc(128);
cyberjoey 11:94a7379c0db8 422 if (bufptr == NULL) {
cyberjoey 11:94a7379c0db8 423 return -1;
cyberjoey 11:94a7379c0db8 424 }
cyberjoey 11:94a7379c0db8 425 size = 128;
cyberjoey 11:94a7379c0db8 426 }
cyberjoey 11:94a7379c0db8 427 p = bufptr;
cyberjoey 11:94a7379c0db8 428 while(c != EOF) {
cyberjoey 11:94a7379c0db8 429 if ((p - bufptr) > (size - 1)) {
cyberjoey 11:94a7379c0db8 430 size = size + 128;
cyberjoey 11:94a7379c0db8 431 bufptr = (char *)realloc(bufptr, size);
cyberjoey 11:94a7379c0db8 432 if (bufptr == NULL) {
cyberjoey 11:94a7379c0db8 433 return -1;
cyberjoey 11:94a7379c0db8 434 }
cyberjoey 11:94a7379c0db8 435 }
cyberjoey 11:94a7379c0db8 436 *p++ = c;
cyberjoey 11:94a7379c0db8 437 if (c == '\n') {
cyberjoey 11:94a7379c0db8 438 break;
cyberjoey 11:94a7379c0db8 439 }
cyberjoey 11:94a7379c0db8 440 c = fgetc(stream);
cyberjoey 11:94a7379c0db8 441 }
cyberjoey 11:94a7379c0db8 442
cyberjoey 11:94a7379c0db8 443 *p++ = '\0';
cyberjoey 11:94a7379c0db8 444 *lineptr = bufptr;
cyberjoey 11:94a7379c0db8 445 *n = size;
cyberjoey 11:94a7379c0db8 446
cyberjoey 11:94a7379c0db8 447 return p - bufptr - 1;
cyberjoey 11:94a7379c0db8 448 }
cyberjoey 11:94a7379c0db8 449
cyberjoey 14:480f2398fe6a 450 bool print_settings_file_2()
cyberjoey 14:480f2398fe6a 451 {
cyberjoey 14:480f2398fe6a 452 char * line = NULL;
cyberjoey 14:480f2398fe6a 453 int len = 0;
cyberjoey 14:480f2398fe6a 454
cyberjoey 14:480f2398fe6a 455 FILE *fp = fopen(settings_file, "r");
cyberjoey 14:480f2398fe6a 456 if (fp != NULL)
cyberjoey 14:480f2398fe6a 457 {
cyberjoey 14:480f2398fe6a 458 pc.printf("*\r\n");
cyberjoey 14:480f2398fe6a 459
cyberjoey 14:480f2398fe6a 460 // Read contents from file
cyberjoey 14:480f2398fe6a 461 while ((getline(&line, &len, fp)) != -1)
cyberjoey 14:480f2398fe6a 462 {
cyberjoey 14:480f2398fe6a 463 pc.printf("%s", line);
cyberjoey 14:480f2398fe6a 464 }
cyberjoey 14:480f2398fe6a 465 pc.printf("*\r\n");
cyberjoey 14:480f2398fe6a 466
cyberjoey 14:480f2398fe6a 467 fclose(fp);
cyberjoey 14:480f2398fe6a 468 }
cyberjoey 14:480f2398fe6a 469 else
cyberjoey 14:480f2398fe6a 470 {
cyberjoey 14:480f2398fe6a 471 return false;
cyberjoey 14:480f2398fe6a 472 }
cyberjoey 14:480f2398fe6a 473 return true;
cyberjoey 14:480f2398fe6a 474 }
cyberjoey 14:480f2398fe6a 475
cyberjoey 11:94a7379c0db8 476 //returns true if settings file exists and is in the proper format
cyberjoey 11:94a7379c0db8 477 bool apply_settings_file(bool (&logged_devices)[MAX_DEVICES], int& interval)
cyberjoey 11:94a7379c0db8 478 {
cyberjoey 11:94a7379c0db8 479
cyberjoey 11:94a7379c0db8 480 char * line = NULL;
cyberjoey 11:94a7379c0db8 481 int len = 0;
cyberjoey 11:94a7379c0db8 482 int line_number = 0;
cyberjoey 11:94a7379c0db8 483
cyberjoey 11:94a7379c0db8 484
cyberjoey 11:94a7379c0db8 485 FILE *fp = fopen("/sd/settings.txt", "r");
cyberjoey 11:94a7379c0db8 486 if (fp != NULL)
cyberjoey 11:94a7379c0db8 487 {
cyberjoey 11:94a7379c0db8 488
cyberjoey 11:94a7379c0db8 489 //initialize devices to all false;
cyberjoey 11:94a7379c0db8 490 for(int i = 0; i < MAX_DEVICES; i++)
cyberjoey 11:94a7379c0db8 491 {
cyberjoey 11:94a7379c0db8 492 logged_devices[i] = false;
cyberjoey 11:94a7379c0db8 493 }
cyberjoey 11:94a7379c0db8 494
cyberjoey 11:94a7379c0db8 495 // Read contents from file
cyberjoey 11:94a7379c0db8 496 while ((getline(&line, &len, fp)) != -1)
cyberjoey 11:94a7379c0db8 497 {
cyberjoey 11:94a7379c0db8 498 line_number++;
cyberjoey 11:94a7379c0db8 499
cyberjoey 11:94a7379c0db8 500 char i = 0;
cyberjoey 11:94a7379c0db8 501 char c = line[i];
cyberjoey 11:94a7379c0db8 502 while(c != '\0')
cyberjoey 11:94a7379c0db8 503 {
cyberjoey 11:94a7379c0db8 504 int number;
cyberjoey 11:94a7379c0db8 505 int n;
cyberjoey 11:94a7379c0db8 506 sscanf((line+i), "%d%n", &number, &n);
cyberjoey 11:94a7379c0db8 507 if(isdigit(c))
cyberjoey 11:94a7379c0db8 508 {
cyberjoey 11:94a7379c0db8 509 if(line_number == 1)
cyberjoey 11:94a7379c0db8 510 {
cyberjoey 11:94a7379c0db8 511 interval = number;
cyberjoey 11:94a7379c0db8 512 }
cyberjoey 11:94a7379c0db8 513 else if(line_number == 2)
cyberjoey 11:94a7379c0db8 514 {
cyberjoey 11:94a7379c0db8 515 logged_devices[number] = true;
cyberjoey 11:94a7379c0db8 516 }
cyberjoey 11:94a7379c0db8 517 if(n > 1)
cyberjoey 11:94a7379c0db8 518 i = i + (n - 1);
cyberjoey 11:94a7379c0db8 519 }
cyberjoey 11:94a7379c0db8 520 i++;
cyberjoey 11:94a7379c0db8 521 c = line[i];
cyberjoey 11:94a7379c0db8 522 }
cyberjoey 11:94a7379c0db8 523 }
cyberjoey 11:94a7379c0db8 524
cyberjoey 11:94a7379c0db8 525 fclose(fp);
cyberjoey 11:94a7379c0db8 526 }
cyberjoey 11:94a7379c0db8 527 else
cyberjoey 11:94a7379c0db8 528 {
cyberjoey 11:94a7379c0db8 529 return false;
cyberjoey 11:94a7379c0db8 530 }
cyberjoey 11:94a7379c0db8 531
cyberjoey 11:94a7379c0db8 532 return true;
cyberjoey 11:94a7379c0db8 533
cyberjoey 11:94a7379c0db8 534 }
cyberjoey 11:94a7379c0db8 535
cyberjoey 9:36ba3626aab7 536 //******************************************************************************
cyberjoey 9:36ba3626aab7 537 // main()
cyberjoey 9:36ba3626aab7 538 //******************************************************************************
cyberjoey 9:36ba3626aab7 539
cyberjoey 9:36ba3626aab7 540
switches 0:60a522ae2e35 541 int main()
switches 0:60a522ae2e35 542 {
cyberjoey 17:401a5bb8d403 543 OT07_struct OT07[4]; // structure that holds I2C address and ROM_ID
cyberjoey 9:36ba3626aab7 544 char data[130];
cyberjoey 9:36ba3626aab7 545 int device_count = 0; // number of OW devices found by search_rom()
cyberjoey 9:36ba3626aab7 546 int i;
cyberjoey 9:36ba3626aab7 547 int j;
cyberjoey 9:36ba3626aab7 548 int k;
cyberjoey 9:36ba3626aab7 549
cyberjoey 9:36ba3626aab7 550
cyberjoey 9:36ba3626aab7 551 char device_id[ID_LENGTH]; //8 byte rom id of current slected device
cyberjoey 9:36ba3626aab7 552 char rom_id_list[MAX_DEVICES][ID_LENGTH]; //List of rom id for each device on OW bus
cyberjoey 9:36ba3626aab7 553
cyberjoey 9:36ba3626aab7 554 double T[MAX_DEVICES];
cyberjoey 9:36ba3626aab7 555
cyberjoey 10:148da21c297e 556 bool device_logged[MAX_DEVICES];
cyberjoey 11:94a7379c0db8 557 //initialize device_logged to all false;
cyberjoey 11:94a7379c0db8 558 for(int i = 0; i < MAX_DEVICES; i++)
cyberjoey 11:94a7379c0db8 559 {
cyberjoey 11:94a7379c0db8 560 device_logged[i] = false;
cyberjoey 11:94a7379c0db8 561 }
cyberjoey 10:148da21c297e 562
cyberjoey 9:36ba3626aab7 563 // i/o variables
cyberjoey 9:36ba3626aab7 564 char rx_buff[128]; // comport input buffer
cyberjoey 9:36ba3626aab7 565 int rx_index; // rx_buffer pointer
cyberjoey 9:36ba3626aab7 566 char c; // command type character
cyberjoey 9:36ba3626aab7 567 int n; // argument count
cyberjoey 9:36ba3626aab7 568 int arg1; // argumnet 1
cyberjoey 9:36ba3626aab7 569 int arg2; // argument 2
cyberjoey 9:36ba3626aab7 570 int device; // device argument
cyberjoey 9:36ba3626aab7 571 int num_bytes;
cyberjoey 9:36ba3626aab7 572
cyberjoey 9:36ba3626aab7 573 int time_count;
cyberjoey 9:36ba3626aab7 574 int log_interval = PERIOD;
cyberjoey 9:36ba3626aab7 575 int time_to_sample;
cyberjoey 9:36ba3626aab7 576
cyberjoey 11:94a7379c0db8 577 apply_settings_file(device_logged, log_interval);
cyberjoey 11:94a7379c0db8 578
cyberjoey 9:36ba3626aab7 579 //************* init ticker timer callbacks ****************
cyberjoey 12:aa9fff0aec91 580 timer_1.attach(&LED_blink_callback,0.5); //start ticker, once per sec.
cyberjoey 9:36ba3626aab7 581
cyberjoey 9:36ba3626aab7 582
cyberjoey 12:aa9fff0aec91 583 i2c.frequency(400000); //set I2C clock to 400kHz
cyberjoey 9:36ba3626aab7 584
cyberjoey 9:36ba3626aab7 585 rLED = LED_OFF;
switches 6:96d8d823e292 586 gLED = LED_ON;
cyberjoey 9:36ba3626aab7 587 bLED = LED_ON;
cyberjoey 9:36ba3626aab7 588
cyberjoey 9:36ba3626aab7 589
cyberjoey 9:36ba3626aab7 590 // reset DS2484
cyberjoey 17:401a5bb8d403 591 //data[0] = 0xE1;
cyberjoey 17:401a5bb8d403 592 //data[1] = 0xF0;
cyberjoey 17:401a5bb8d403 593 //i2c.write(DS2484_ADD,data,1,1);
cyberjoey 17:401a5bb8d403 594 //i2c.read(DS2484_ADD,data,1);
cyberjoey 9:36ba3626aab7 595
cyberjoey 9:36ba3626aab7 596 // ****************** search for all OW devices on bus *****************
cyberjoey 9:36ba3626aab7 597
cyberjoey 17:401a5bb8d403 598 //device_count = search_rom(rom_id_list);
cyberjoey 17:401a5bb8d403 599 device_count = search_I2C_bus(OT07);
cyberjoey 9:36ba3626aab7 600
cyberjoey 17:401a5bb8d403 601 /*for(j=0;j<device_count;j++){
cyberjoey 9:36ba3626aab7 602 for(k=0;k<8;k++){
cyberjoey 9:36ba3626aab7 603 device_id[k] = rom_id_list[j][k]; // get device_id from rom_id_list
cyberjoey 9:36ba3626aab7 604 }
cyberjoey 9:36ba3626aab7 605 set_test_mode(device_id);
cyberjoey 17:401a5bb8d403 606 }*/
cyberjoey 9:36ba3626aab7 607
cyberjoey 9:36ba3626aab7 608
cyberjoey 9:36ba3626aab7 609 rx_index = 0; //character buffer index for input from PC
cyberjoey 9:36ba3626aab7 610
cyberjoey 9:36ba3626aab7 611 button.fall(&btn_pressed);
cyberjoey 11:94a7379c0db8 612 SDInsert.fall(&sd_insert);
cyberjoey 11:94a7379c0db8 613
cyberjoey 11:94a7379c0db8 614 sd.disk_initialize(); //initialize sd card
cyberjoey 9:36ba3626aab7 615
cyberjoey 9:36ba3626aab7 616 while(1) { // start main loop, take data if logging, check for input, repeat
cyberjoey 9:36ba3626aab7 617
cyberjoey 11:94a7379c0db8 618 if(sd_insert_flag == true)
cyberjoey 11:94a7379c0db8 619 {
cyberjoey 11:94a7379c0db8 620 sd.disk_initialize();
cyberjoey 11:94a7379c0db8 621 sd_insert_flag = false;
cyberjoey 11:94a7379c0db8 622 }
cyberjoey 11:94a7379c0db8 623
cyberjoey 9:36ba3626aab7 624 if(button_flag == true)
cyberjoey 9:36ba3626aab7 625 {
cyberjoey 9:36ba3626aab7 626 if(log_flag == false){ //start logging
cyberjoey 9:36ba3626aab7 627
cyberjoey 9:36ba3626aab7 628 if(SDDetect)//if SD card not detected
cyberjoey 9:36ba3626aab7 629 {
cyberjoey 9:36ba3626aab7 630 error_flag = true;
cyberjoey 9:36ba3626aab7 631 error_ticks = 6;
cyberjoey 9:36ba3626aab7 632 log_flag = false;
cyberjoey 9:36ba3626aab7 633 }
cyberjoey 9:36ba3626aab7 634 else
cyberjoey 9:36ba3626aab7 635 {
cyberjoey 11:94a7379c0db8 636 apply_settings_file(device_logged, log_interval);
cyberjoey 11:94a7379c0db8 637
cyberjoey 10:148da21c297e 638 FILE *fp = fopen(log_file, "a");
cyberjoey 9:36ba3626aab7 639 if (fp != NULL)
cyberjoey 9:36ba3626aab7 640 {
cyberjoey 17:401a5bb8d403 641 fprintf(fp,"Device List\r\n");
cyberjoey 17:401a5bb8d403 642 fprintf(fp,"Device Number, ROM Code\r\n");
cyberjoey 17:401a5bb8d403 643 for(j=0;j<device_count;j++)
cyberjoey 17:401a5bb8d403 644 {
cyberjoey 17:401a5bb8d403 645 if(device_logged[j])
cyberjoey 17:401a5bb8d403 646 {
cyberjoey 17:401a5bb8d403 647 fprintf(fp,"%d,0x",j);
cyberjoey 17:401a5bb8d403 648 for(i=7;i>=0;i--)
cyberjoey 17:401a5bb8d403 649 {
cyberjoey 17:401a5bb8d403 650 fprintf(fp,"%02X",rom_id_list[j][i]);
cyberjoey 17:401a5bb8d403 651 }
cyberjoey 17:401a5bb8d403 652 fprintf(fp,"\r\n");
cyberjoey 17:401a5bb8d403 653 }
cyberjoey 17:401a5bb8d403 654 }
cyberjoey 17:401a5bb8d403 655
cyberjoey 9:36ba3626aab7 656 fprintf(fp, "Time(s)");
cyberjoey 9:36ba3626aab7 657
cyberjoey 9:36ba3626aab7 658 for(j=0;j<device_count;j++)
cyberjoey 9:36ba3626aab7 659 {
cyberjoey 11:94a7379c0db8 660 if(device_logged[j])
cyberjoey 16:2f373d3c8214 661 fprintf(fp,",Device %d Temperature (C)",j);
cyberjoey 9:36ba3626aab7 662 }
cyberjoey 9:36ba3626aab7 663 fprintf(fp,"\r\n");
cyberjoey 9:36ba3626aab7 664
cyberjoey 9:36ba3626aab7 665 fclose(fp);
cyberjoey 9:36ba3626aab7 666 }
cyberjoey 9:36ba3626aab7 667
cyberjoey 9:36ba3626aab7 668 time_count = 0;
cyberjoey 9:36ba3626aab7 669
cyberjoey 9:36ba3626aab7 670 time_to_sample = 0; // force sample at time = 0;
cyberjoey 9:36ba3626aab7 671 tick_flag = true; // force sample at time = 0;
cyberjoey 9:36ba3626aab7 672 log_flag = true;
cyberjoey 9:36ba3626aab7 673 }
cyberjoey 9:36ba3626aab7 674 }else{
cyberjoey 9:36ba3626aab7 675 log_flag = false;
cyberjoey 9:36ba3626aab7 676 }
cyberjoey 9:36ba3626aab7 677 button_flag = false;
cyberjoey 9:36ba3626aab7 678 }
switches 1:90313362ec11 679
cyberjoey 9:36ba3626aab7 680 while(tick_flag == false){ //check for input while waiting for next tick
cyberjoey 9:36ba3626aab7 681
cyberjoey 9:36ba3626aab7 682 // ----------------------------------------------------------------------------
cyberjoey 9:36ba3626aab7 683 // test for charater input for USB com port
cyberjoey 9:36ba3626aab7 684 // ----------------------------------------------------------------------------
cyberjoey 9:36ba3626aab7 685
cyberjoey 9:36ba3626aab7 686 //test if PC sent some charaters
cyberjoey 9:36ba3626aab7 687 while(pc.readable()){ //characters in buffer, get them
cyberjoey 9:36ba3626aab7 688 rx_buff[rx_index] = pc.getc();
cyberjoey 9:36ba3626aab7 689
cyberjoey 9:36ba3626aab7 690 if(rx_buff[rx_index] == CR){
cyberjoey 9:36ba3626aab7 691 rx_buff[++rx_index] = 0;
cyberjoey 9:36ba3626aab7 692 rx_index = -1; // because i++ at end of while give i=0 on next loop
cyberjoey 9:36ba3626aab7 693 device = 0;
cyberjoey 9:36ba3626aab7 694 arg1 = 0;
cyberjoey 9:36ba3626aab7 695 arg2 = 0;
cyberjoey 9:36ba3626aab7 696
cyberjoey 9:36ba3626aab7 697 n = sscanf(rx_buff, " %c %d %x %x", &c, & device, &arg1, &arg2);
cyberjoey 9:36ba3626aab7 698 //process input
cyberjoey 9:36ba3626aab7 699 if(n > 0){//got input so process it
cyberjoey 9:36ba3626aab7 700 switch(c){
cyberjoey 9:36ba3626aab7 701 case 'a':
cyberjoey 9:36ba3626aab7 702 case 'A': // alarm search
cyberjoey 9:36ba3626aab7 703 // ****************** search for all OW devices with alarm triggered on bus *****************
cyberjoey 17:401a5bb8d403 704 /*
cyberjoey 9:36ba3626aab7 705 device_count = alarm_search(rom_id_list);
cyberjoey 9:36ba3626aab7 706
cyberjoey 9:36ba3626aab7 707 pc.printf("%d devices:\r\n", device_count);
cyberjoey 9:36ba3626aab7 708 for(j=0;j<device_count;j++){
cyberjoey 9:36ba3626aab7 709 pc.printf("device[%02X] rom id[",j);
cyberjoey 9:36ba3626aab7 710 for(i=7;i>=0;i--){
cyberjoey 9:36ba3626aab7 711 pc.printf("%02X",rom_id_list[j][i]);
cyberjoey 9:36ba3626aab7 712 }
cyberjoey 9:36ba3626aab7 713 pc.printf("]\r\n");
cyberjoey 17:401a5bb8d403 714 } */
cyberjoey 9:36ba3626aab7 715 break;
cyberjoey 11:94a7379c0db8 716 case 'c':
cyberjoey 11:94a7379c0db8 717 case 'C':
cyberjoey 11:94a7379c0db8 718 if(!SDDetect)
cyberjoey 11:94a7379c0db8 719 pc.printf("y\r\n");
cyberjoey 11:94a7379c0db8 720 else
cyberjoey 11:94a7379c0db8 721 pc.printf("n\r\n");
cyberjoey 11:94a7379c0db8 722 break;
cyberjoey 10:148da21c297e 723 case 'd':
cyberjoey 10:148da21c297e 724 case 'D':
cyberjoey 10:148da21c297e 725 if(n==1) // if no device number is given
cyberjoey 10:148da21c297e 726 {
cyberjoey 10:148da21c297e 727 //clear device_logged array
cyberjoey 10:148da21c297e 728 for(int i = 0; i < MAX_DEVICES; i++)
cyberjoey 10:148da21c297e 729 {
cyberjoey 10:148da21c297e 730 device_logged[i] = false;
cyberjoey 10:148da21c297e 731 }
cyberjoey 10:148da21c297e 732
cyberjoey 10:148da21c297e 733 write_settings_file(log_interval, device_logged);
cyberjoey 10:148da21c297e 734 }
cyberjoey 10:148da21c297e 735 if(n == 2)
cyberjoey 10:148da21c297e 736 {
cyberjoey 10:148da21c297e 737 device_logged[device] = true;
cyberjoey 10:148da21c297e 738 write_settings_file(log_interval, device_logged);
cyberjoey 10:148da21c297e 739 }
cyberjoey 10:148da21c297e 740 break;
cyberjoey 9:36ba3626aab7 741 case 'f':
cyberjoey 9:36ba3626aab7 742 case 'F': //f is for "flash" for microSD
cyberjoey 12:aa9fff0aec91 743 if(!SDDetect)
cyberjoey 9:36ba3626aab7 744 pc.printf("y\r\n");
cyberjoey 9:36ba3626aab7 745 else
cyberjoey 12:aa9fff0aec91 746 pc.printf("n\r\n");
cyberjoey 9:36ba3626aab7 747 break;
cyberjoey 10:148da21c297e 748 case 'g':
cyberjoey 10:148da21c297e 749 case 'G':
cyberjoey 10:148da21c297e 750 //0 means get config, 1 means get log
cyberjoey 10:148da21c297e 751 if(n == 2)
cyberjoey 10:148da21c297e 752 {
cyberjoey 10:148da21c297e 753 bool fileExists = false;
cyberjoey 10:148da21c297e 754 if(device == 0)//get config
cyberjoey 10:148da21c297e 755 {
cyberjoey 10:148da21c297e 756 fileExists = print_settings_file();
cyberjoey 14:480f2398fe6a 757 //fileExists = print_settings_file_2();
cyberjoey 10:148da21c297e 758 }
cyberjoey 10:148da21c297e 759 if(device == 1)//get log
cyberjoey 10:148da21c297e 760 {
cyberjoey 10:148da21c297e 761 fileExists = print_log_file();
cyberjoey 10:148da21c297e 762 }
cyberjoey 10:148da21c297e 763 if(!fileExists)
cyberjoey 10:148da21c297e 764 {
cyberjoey 10:148da21c297e 765 pc.printf("no_file\r\n");
cyberjoey 10:148da21c297e 766 }
cyberjoey 10:148da21c297e 767 }
cyberjoey 10:148da21c297e 768 break;
cyberjoey 9:36ba3626aab7 769 case 'i':
cyberjoey 9:36ba3626aab7 770 case 'I': //Set Logging sample intreval in seconds
cyberjoey 9:36ba3626aab7 771
cyberjoey 9:36ba3626aab7 772 log_interval = device;
cyberjoey 9:36ba3626aab7 773 if(log_interval < 1)log_interval = 1;
cyberjoey 10:148da21c297e 774 if(log_interval > 60)log_interval = 60;
cyberjoey 10:148da21c297e 775 write_settings_file(log_interval, device_logged);
cyberjoey 9:36ba3626aab7 776 break;
cyberjoey 9:36ba3626aab7 777 case 'l':
cyberjoey 17:401a5bb8d403 778 case 'L':
cyberjoey 17:401a5bb8d403 779
cyberjoey 17:401a5bb8d403 780 /*
cyberjoey 17:401a5bb8d403 781 // Toggle logging
cyberjoey 9:36ba3626aab7 782
cyberjoey 9:36ba3626aab7 783 if(log_flag == false){ //start logging
cyberjoey 9:36ba3626aab7 784 if(SDDetect)//if SD card not detected
cyberjoey 9:36ba3626aab7 785 {
cyberjoey 9:36ba3626aab7 786 error_flag = true;
cyberjoey 9:36ba3626aab7 787 error_ticks = 6;
cyberjoey 9:36ba3626aab7 788 log_flag = false;
cyberjoey 9:36ba3626aab7 789 }
cyberjoey 9:36ba3626aab7 790 else
cyberjoey 9:36ba3626aab7 791 {
cyberjoey 10:148da21c297e 792 FILE *fp = fopen(log_file, "a");
cyberjoey 9:36ba3626aab7 793 if (fp != NULL)
cyberjoey 9:36ba3626aab7 794 {
cyberjoey 9:36ba3626aab7 795 fprintf(fp, "Time(s)");
cyberjoey 9:36ba3626aab7 796
cyberjoey 9:36ba3626aab7 797 for(j=0;j<device_count;j++)
cyberjoey 9:36ba3626aab7 798 {
cyberjoey 16:2f373d3c8214 799 fprintf(fp,",Device %d Temperature (C)",j);
cyberjoey 9:36ba3626aab7 800 }
cyberjoey 9:36ba3626aab7 801 fprintf(fp,"\r\n");
cyberjoey 9:36ba3626aab7 802
cyberjoey 9:36ba3626aab7 803 fclose(fp);
cyberjoey 9:36ba3626aab7 804 }
cyberjoey 9:36ba3626aab7 805
cyberjoey 9:36ba3626aab7 806 time_count = 0;
cyberjoey 9:36ba3626aab7 807
cyberjoey 9:36ba3626aab7 808 time_to_sample = 0; // force sample at time = 0;
cyberjoey 9:36ba3626aab7 809 tick_flag = true; // force sample at time = 0;
cyberjoey 9:36ba3626aab7 810 log_flag = true;
cyberjoey 9:36ba3626aab7 811 }
cyberjoey 9:36ba3626aab7 812 }else{
cyberjoey 9:36ba3626aab7 813 //pc.printf("<stop logging>\r\n");
cyberjoey 9:36ba3626aab7 814 log_flag = false;
cyberjoey 17:401a5bb8d403 815 }*/
cyberjoey 9:36ba3626aab7 816 break;
cyberjoey 9:36ba3626aab7 817 case 'P':
cyberjoey 9:36ba3626aab7 818 case 'p': // power down One Wire buss
cyberjoey 17:401a5bb8d403 819 /*if(n == 2){
cyberjoey 9:36ba3626aab7 820 if (device == 0){ // power down mode ON.
cyberjoey 9:36ba3626aab7 821 data[0] = WDC; // 0xD2 Write Device Config
cyberjoey 9:36ba3626aab7 822 data[1] = 0xD2; // 1101 0010 set 1WS = 0, SPU = 0, PDN = 1, APU = 0
cyberjoey 9:36ba3626aab7 823 i2c.write(DS2484_ADD,data,2,0);
cyberjoey 9:36ba3626aab7 824 pc.printf("<Power down DQ>\r\n");
cyberjoey 9:36ba3626aab7 825 }else{ // power down mode OFF
cyberjoey 9:36ba3626aab7 826 data[0] = WDC; // 0xD2 Write Device Config
cyberjoey 9:36ba3626aab7 827 data[1] = 0xE1; // 1110 0001 set 1WS = 0, SPU = 0, PDN = 0, APU = 1
cyberjoey 9:36ba3626aab7 828 i2c.write(DS2484_ADD,data,2,0);
cyberjoey 9:36ba3626aab7 829 pc.printf("<Power up DQ>\r\n");
cyberjoey 9:36ba3626aab7 830 }
cyberjoey 17:401a5bb8d403 831 }*/
cyberjoey 9:36ba3626aab7 832 break;
cyberjoey 9:36ba3626aab7 833 case 'r':
cyberjoey 17:401a5bb8d403 834 case 'R':
cyberjoey 17:401a5bb8d403 835 //read register "r device radd.start radd.end"
cyberjoey 9:36ba3626aab7 836 if(n==3){ //read single register from selected device
cyberjoey 17:401a5bb8d403 837 OT07_read_register(OT07[device].I2C_address,arg1,data,1);
cyberjoey 17:401a5bb8d403 838 pc.printf("device[%02X] add[%02X] data[%02X] crc[FF FF]\r\n",device,arg1,data[0]);
cyberjoey 9:36ba3626aab7 839 }
cyberjoey 9:36ba3626aab7 840 if(n==4){ //read a range of regesters from selected device
cyberjoey 9:36ba3626aab7 841 num_bytes = arg2-arg1 + 1; // calculate number of bytes to read
cyberjoey 9:36ba3626aab7 842 if (num_bytes < 1) num_bytes = 1; // if arg2 <= arg 1 just read arg1 address.
cyberjoey 17:401a5bb8d403 843 OT07_read_register(OT07[device].I2C_address,arg1,data,num_bytes);
cyberjoey 9:36ba3626aab7 844 for(i=0;i<num_bytes;i++){
cyberjoey 9:36ba3626aab7 845 pc.printf("\r\ndevice[%02X] add[%02X] data[%02X]",device,arg1+i,data[i]);
cyberjoey 17:401a5bb8d403 846 }
cyberjoey 9:36ba3626aab7 847 }
cyberjoey 9:36ba3626aab7 848 break;
cyberjoey 9:36ba3626aab7 849
cyberjoey 9:36ba3626aab7 850 case 's':
cyberjoey 9:36ba3626aab7 851 case 'S': // search rom
cyberjoey 17:401a5bb8d403 852 // ****************** search for I2C devices on bus *****************
cyberjoey 17:401a5bb8d403 853 //NOTE: MUST ADD I2C ADDRESS TODO
cyberjoey 17:401a5bb8d403 854 device_count = search_I2C_bus(OT07);
cyberjoey 9:36ba3626aab7 855 pc.printf("%d devices:\r\n", device_count);
cyberjoey 9:36ba3626aab7 856 for(j=0;j<device_count;j++){
cyberjoey 9:36ba3626aab7 857 pc.printf("device[%02X] rom id[",j);
cyberjoey 9:36ba3626aab7 858 for(i=7;i>=0;i--){
cyberjoey 17:401a5bb8d403 859 pc.printf("%02X",OT07[j].rom_id[i]);
cyberjoey 9:36ba3626aab7 860 }
cyberjoey 9:36ba3626aab7 861 pc.printf("]\r\n");
cyberjoey 13:674c647d12dd 862 }
cyberjoey 17:401a5bb8d403 863
cyberjoey 9:36ba3626aab7 864 break;
cyberjoey 9:36ba3626aab7 865
cyberjoey 9:36ba3626aab7 866 case 'T':
cyberjoey 9:36ba3626aab7 867 case 't':
cyberjoey 17:401a5bb8d403 868
cyberjoey 17:401a5bb8d403 869 if(n == 2){//get temperatures from selected device
cyberjoey 17:401a5bb8d403 870
cyberjoey 17:401a5bb8d403 871 convert_temperature(OT07[device].I2C_address); //send OW convert selected device
cyberjoey 17:401a5bb8d403 872 wait(0.02); //wait 20 ms for convert temperature to complete
cyberjoey 17:401a5bb8d403 873 T[device] = get_temperature(OT07[device].I2C_address);
cyberjoey 17:401a5bb8d403 874 pc.printf("device[%02X] temperature[%.3f]\r\n",device,T[device]);
cyberjoey 17:401a5bb8d403 875 }
cyberjoey 17:401a5bb8d403 876
cyberjoey 17:401a5bb8d403 877 if(n == 3){ // "t 1 3" get temperature for devices 1 thru 3
cyberjoey 17:401a5bb8d403 878 //sprintf(str,"%x",arg1); //convert arg1 input as hex to decimal i.e. 0x10 becomes 10 dec
cyberjoey 17:401a5bb8d403 879 //sscanf(str,"%d",&arg1);
cyberjoey 17:401a5bb8d403 880 //IS THIS NEEDED? ^^^
cyberjoey 17:401a5bb8d403 881
cyberjoey 17:401a5bb8d403 882 for(j=device;j<=arg1;j++){
cyberjoey 17:401a5bb8d403 883 convert_temperature(OT07[j].I2C_address); //send convert to all devices
cyberjoey 17:401a5bb8d403 884 wait(0.02); //wait 20ms for convert temperature to complete
cyberjoey 17:401a5bb8d403 885 T[j] = get_temperature(OT07[j].I2C_address);
cyberjoey 17:401a5bb8d403 886 }
cyberjoey 17:401a5bb8d403 887
cyberjoey 17:401a5bb8d403 888 for(j=device;j<=arg1;j++){
cyberjoey 17:401a5bb8d403 889 pc.printf("device[%02X] temperature[%.3f]\r\n",j,T[j]);
cyberjoey 17:401a5bb8d403 890 }
cyberjoey 17:401a5bb8d403 891 }
cyberjoey 17:401a5bb8d403 892
cyberjoey 9:36ba3626aab7 893 break;
cyberjoey 9:36ba3626aab7 894
cyberjoey 9:36ba3626aab7 895 case 'w':
cyberjoey 17:401a5bb8d403 896 case 'W': //write register "w device w.addr data"
cyberjoey 9:36ba3626aab7 897
cyberjoey 17:401a5bb8d403 898 OT07_write_register(OT07[device].I2C_address,arg1, arg2);
cyberjoey 17:401a5bb8d403 899 pc.printf("write -- device[%02X] add[%02X] data[%02X] crc[FF FF]\r\n",device,arg1,arg2);
cyberjoey 9:36ba3626aab7 900 break;
cyberjoey 9:36ba3626aab7 901
cyberjoey 9:36ba3626aab7 902 case 'x':
cyberjoey 9:36ba3626aab7 903 case 'X': // experimental modes
cyberjoey 9:36ba3626aab7 904 // ****************** set up ADC enabled in test mode*****************
cyberjoey 18:d913ec9dd9c2 905 /*
cyberjoey 9:36ba3626aab7 906 pc.printf("<set ADC_ENABLED in test mode>\r\n");
cyberjoey 9:36ba3626aab7 907
cyberjoey 9:36ba3626aab7 908 for(j=0;j<device_count;j++){
cyberjoey 9:36ba3626aab7 909 for(k=0;k<8;k++){
cyberjoey 9:36ba3626aab7 910 device_id[k] = rom_id_list[j][k]; // get device_id from rom_id_list
cyberjoey 9:36ba3626aab7 911 }
cyberjoey 9:36ba3626aab7 912 set_test_mode(device_id);
cyberjoey 18:d913ec9dd9c2 913 } */
cyberjoey 9:36ba3626aab7 914 break;
cyberjoey 9:36ba3626aab7 915
cyberjoey 9:36ba3626aab7 916
cyberjoey 9:36ba3626aab7 917 }//end switch(c)
cyberjoey 9:36ba3626aab7 918 }//if(n>0)
cyberjoey 9:36ba3626aab7 919 }//end if(CR)
cyberjoey 9:36ba3626aab7 920 if(rx_buff[rx_index] == BS){//backspace received, back up buffer pointer
cyberjoey 9:36ba3626aab7 921 if(rx_index>0)rx_index--;//remove last char from buffer if not at start.
cyberjoey 9:36ba3626aab7 922 }else rx_index++;
cyberjoey 9:36ba3626aab7 923 }//end while(pc.redable())
cyberjoey 9:36ba3626aab7 924 wait(0.1); // slow down polling
switches 0:60a522ae2e35 925
cyberjoey 9:36ba3626aab7 926 }// end (while tick == false)
cyberjoey 9:36ba3626aab7 927 tick_flag = false; // set to false for next time
cyberjoey 9:36ba3626aab7 928
cyberjoey 9:36ba3626aab7 929 // only reached when tick_flag = true otherwise stuck in pc.readable() loop
cyberjoey 13:674c647d12dd 930 if(log_flag == true){
cyberjoey 9:36ba3626aab7 931 if(time_count >= time_to_sample){ //take next sample
cyberjoey 9:36ba3626aab7 932 time_to_sample += log_interval; // calculate time for next sample
cyberjoey 18:d913ec9dd9c2 933
cyberjoey 18:d913ec9dd9c2 934 ///////////////////////temp conversion and assignment to T[]//////////////////////////////////////
cyberjoey 9:36ba3626aab7 935 // start conversion
cyberjoey 18:d913ec9dd9c2 936 /*convert_temperature();
cyberjoey 9:36ba3626aab7 937 wait(0.02); //wait 20ms for convert to complete
cyberjoey 9:36ba3626aab7 938 for(j=0;j<device_count;j++){
cyberjoey 9:36ba3626aab7 939 for(k=0;k<8;k++){
cyberjoey 9:36ba3626aab7 940 device_id[k] = rom_id_list[j][k]; // get device_id from rom_id_list
cyberjoey 9:36ba3626aab7 941 }
cyberjoey 9:36ba3626aab7 942 T[j] = get_temperature(device_id);
cyberjoey 18:d913ec9dd9c2 943 }*/
cyberjoey 18:d913ec9dd9c2 944 for(j=0;j<device_count;j++){
cyberjoey 18:d913ec9dd9c2 945 convert_temperature(OT07[j].I2C_address);
cyberjoey 18:d913ec9dd9c2 946 wait(0.02); //wait 20ms for convert temperature to complete
cyberjoey 18:d913ec9dd9c2 947 T[j] = get_temperature(OT07[j].I2C_address);
cyberjoey 9:36ba3626aab7 948 }
cyberjoey 18:d913ec9dd9c2 949 /////////////////////////////////////////////////////////////////////////////////////////////////
cyberjoey 13:674c647d12dd 950
cyberjoey 13:674c647d12dd 951 //open file for microSD logging
cyberjoey 10:148da21c297e 952 FILE *fp = fopen(log_file, "a");
cyberjoey 9:36ba3626aab7 953 if (fp != NULL)
cyberjoey 9:36ba3626aab7 954 {
cyberjoey 9:36ba3626aab7 955 //fprintf(fp, "\n");
cyberjoey 10:148da21c297e 956 fprintf(fp, "%d",time_count);
cyberjoey 9:36ba3626aab7 957 for(j=0;j<device_count;j++)
cyberjoey 9:36ba3626aab7 958 {
cyberjoey 11:94a7379c0db8 959 if(device_logged[j])
cyberjoey 11:94a7379c0db8 960 {
cyberjoey 16:2f373d3c8214 961 fprintf(fp,",%.3f",T[j]);
cyberjoey 11:94a7379c0db8 962 }
cyberjoey 11:94a7379c0db8 963
cyberjoey 9:36ba3626aab7 964 }
cyberjoey 9:36ba3626aab7 965 fprintf(fp,"\r\n");
cyberjoey 9:36ba3626aab7 966
cyberjoey 9:36ba3626aab7 967 fclose(fp);
cyberjoey 9:36ba3626aab7 968 }
cyberjoey 9:36ba3626aab7 969 }// end if(time_count >= time_to_sample)
cyberjoey 9:36ba3626aab7 970 time_count ++; //
cyberjoey 9:36ba3626aab7 971
cyberjoey 9:36ba3626aab7 972 }// end if(log_flag)
cyberjoey 9:36ba3626aab7 973
cyberjoey 9:36ba3626aab7 974 }//end while(1)
switches 0:60a522ae2e35 975 }