Team Walter / Mbed OS PICO_I2C_FW

PICO I2C FW

Dependencies:   USBDevice

main.cpp@17:401a5bb8d403, 2018-08-31 (annotated)

Committer:
cyberjoey
Date:
Fri Aug 31 19:28:28 2018 +0000
Revision:
17:401a5bb8d403
Parent:
16:2f373d3c8214
Child:
18:d913ec9dd9c2
all commands converted to i2c first attempt

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
cyberjoey 9:36ba3626aab7 8 #define I2C_ADDRESS 0x30 // DS2484 I2C address
cyberjoey 9:36ba3626aab7 9 #define DS2484_ADD 0x30 // DS2484 I2C write address
cyberjoey 9:36ba3626aab7 10
cyberjoey 9:36ba3626aab7 11
cyberjoey 9:36ba3626aab7 12 #define PERIOD 10 // Logging period in seconds
cyberjoey 9:36ba3626aab7 13
cyberjoey 9:36ba3626aab7 14 //DS2484 Status register bits
cyberjoey 9:36ba3626aab7 15 #define OWB 0x01 // status reg, One Wire Busy
cyberjoey 9:36ba3626aab7 16 #define PPD 0x02 // status reg, Presence Pulse Detected
cyberjoey 9:36ba3626aab7 17 #define SD 0x04 // status reg, Short Detected
cyberjoey 9:36ba3626aab7 18 #define LL 0x08 // status reg, Logic Level
cyberjoey 9:36ba3626aab7 19 #define RST 0x10 // status reg, Device Reset (DS2484 Reset)
cyberjoey 9:36ba3626aab7 20 #define SBR 0x20 // status reg, Single Bit Result
cyberjoey 9:36ba3626aab7 21 #define TSB 0x40 // status reg, Triplet Second Bit
cyberjoey 9:36ba3626aab7 22 #define DIR 0x80 // status reg, Branch Direction Taken
cyberjoey 9:36ba3626aab7 23 //DS2484 Command bytes
cyberjoey 9:36ba3626aab7 24 #define RESET 0xF0 // DS2484 Reset
cyberjoey 9:36ba3626aab7 25 #define SRP 0xE1 // DS2484 Set Read Pointer
cyberjoey 9:36ba3626aab7 26 #define WDC 0xD2 // DS2484 Write Device Configuration
cyberjoey 9:36ba3626aab7 27 #define ACP 0xC3 // DS2484 Adjust one wire Control Port
cyberjoey 9:36ba3626aab7 28 #define OW_RESET 0xB4 // DS2484 One Wire Reset
cyberjoey 9:36ba3626aab7 29 #define OW_SB 0x87 // One Wire Single Bit (write or read)
cyberjoey 9:36ba3626aab7 30 #define OWWB 0xA5 // One Wire Write Byte
cyberjoey 9:36ba3626aab7 31 #define OWRB 0x96 // One Wire Read Byte
cyberjoey 9:36ba3626aab7 32 #define OWT 0x78 // One Wire Triplet (read 2 bits, write 1 bit)
cyberjoey 9:36ba3626aab7 33 //One Wire Commands
cyberjoey 9:36ba3626aab7 34 #define OW_SEARCH 0xF0 // Search Rom
cyberjoey 9:36ba3626aab7 35 #define OW_READ 0x33 // Read Rom
cyberjoey 9:36ba3626aab7 36 #define OW_MATCH 0x55 // Match Rom
cyberjoey 9:36ba3626aab7 37 #define OW_SKIP 0xCC // Skip Rom
cyberjoey 9:36ba3626aab7 38 #define OW_OD_MATCH 0x69 // Match Rom
cyberjoey 9:36ba3626aab7 39 #define OW_OD_SKIP 0x3C // Skip Rom
cyberjoey 9:36ba3626aab7 40 #define OW_ALARM 0xEC // Alarm Search
cyberjoey 9:36ba3626aab7 41 // OT07 OW commands
cyberjoey 9:36ba3626aab7 42 #define OT07_OW_CONVERT 0x44 //OT07 OW convert temperature command
cyberjoey 9:36ba3626aab7 43 #define OT07_OW_WRITE 0xCC // OT07 OW Write Register command
cyberjoey 9:36ba3626aab7 44 #define OT07_OW_READ 0x33 // OT07 OW Read Register command
cyberjoey 9:36ba3626aab7 45 #define OT07_OW_RESET 0x82 // OT07 OW Soft Reset command
switches 3:247c750f9f3d 46
cyberjoey 9:36ba3626aab7 47 //OT07 Registers
cyberjoey 9:36ba3626aab7 48 #define OT07_STATUS 0x00 // OT07 status regiter
cyberjoey 9:36ba3626aab7 49 #define OT07_INT_EN 0x01 // OT07 Interrupt Enable
cyberjoey 9:36ba3626aab7 50 #define OT07_FIFO_W 0x04 // OT07 FIFO Write Pointer
cyberjoey 9:36ba3626aab7 51 #define OT07_FIFO_R 0x05 // OT07 FIFO Read Pointer
cyberjoey 9:36ba3626aab7 52 #define OT07_FIFO_OF 0x06 // OT07 FIFO Overflow Counter
cyberjoey 9:36ba3626aab7 53 #define OT07_FIFO_COUNT 0x07 // OT07 FIFO Data Count
cyberjoey 9:36ba3626aab7 54 #define OT07_FIFO_DATA 0x08 // OT07 FIFO Data
cyberjoey 9:36ba3626aab7 55 #define OT07_FIFO_CNFG1 0x09 // OT07 FIFO Configuration 1 (FIFO_A_FULL)
cyberjoey 9:36ba3626aab7 56 #define OT07_FIFO_CNFG2 0x0A // OT07 FIFO Configuration 2
cyberjoey 9:36ba3626aab7 57 #define OT07_SYS 0x0C // OT07 System Configuration
cyberjoey 9:36ba3626aab7 58 #define OT07_ALARM_HIGH_MSB 0x10 // OT07 Alarm High MSB
cyberjoey 9:36ba3626aab7 59 #define OT07_ALARM_HIGH_LSB 0x11 // OT07 Alarm High LSB
cyberjoey 9:36ba3626aab7 60 #define OT07_ALARM_LOW_MSB 0x12 // OT07 Alarm Low MSB
cyberjoey 9:36ba3626aab7 61 #define OT07_ALARM_LOW_LSB 0x13 // OT07 Alarm LOW LSB
cyberjoey 17:401a5bb8d403 62 #define OT07_ADC_SETUP 0x14 // OT07 Temp Seneor Setup (ADC_RES[7:6]) & Convert Temperature [0]
cyberjoey 9:36ba3626aab7 63 #define OT07_GPIO_SETUP 0x20 // OT07 GPIO Setup, sets GPIO modes
cyberjoey 17:401a5bb8d403 64 #define OT07_GPIO_CTRL 0x21 // OT07 GPIO control
cyberjoey 9:36ba3626aab7 65 #define OT07_ROM_ID 0x30 // OT07 ROM_ID address of LSB?
cyberjoey 9:36ba3626aab7 66
cyberjoey 9:36ba3626aab7 67
cyberjoey 9:36ba3626aab7 68 #define MAX_DEVICES 64 // Maximum number of rom devices allowed
cyberjoey 9:36ba3626aab7 69 #define ID_LENGTH 8 // Rom ID length in bytes
cyberjoey 9:36ba3626aab7 70
cyberjoey 9:36ba3626aab7 71
cyberjoey 9:36ba3626aab7 72 #define BS 8 // ASCII Back Space
cyberjoey 9:36ba3626aab7 73 #define CR 13 // ASCII Carriage Return
cyberjoey 9:36ba3626aab7 74
cyberjoey 17:401a5bb8d403 75 struct OT07_struct {
cyberjoey 17:401a5bb8d403 76 char rom_id[ID_LENGTH]; // device 8 byte ROM ID
cyberjoey 17:401a5bb8d403 77 char I2C_address; // I2C addess, based on GPIO0 and GPIO1 at power up
cyberjoey 17:401a5bb8d403 78 };
cyberjoey 17:401a5bb8d403 79
cyberjoey 10:148da21c297e 80 const char* settings_file = "/sd/settings.txt";
cyberjoey 10:148da21c297e 81 const char* log_file = "/sd/MAX30207Log.csv";
cyberjoey 10:148da21c297e 82
cyberjoey 9:36ba3626aab7 83 //global variable
cyberjoey 9:36ba3626aab7 84
cyberjoey 9:36ba3626aab7 85 //******************** init Feather Boared Hardware ***********************
cyberjoey 9:36ba3626aab7 86
cyberjoey 9:36ba3626aab7 87 MAX32630FTHR pegasus(MAX32630FTHR::VIO_3V3);
cyberjoey 9:36ba3626aab7 88
cyberjoey 9:36ba3626aab7 89 //microSD logging file system setup
cyberjoey 9:36ba3626aab7 90 SDFileSystem sd(P0_5, P0_6, P0_4, P0_7, "sd"); // mosi, miso, sclk, cs
cyberjoey 9:36ba3626aab7 91
cyberjoey 9:36ba3626aab7 92 //SD card insertion detection pin
cyberjoey 9:36ba3626aab7 93 DigitalIn SDDetect(P2_2, PullUp);
cyberjoey 11:94a7379c0db8 94 InterruptIn SDInsert(P2_2);
cyberjoey 9:36ba3626aab7 95
cyberjoey 9:36ba3626aab7 96
cyberjoey 9:36ba3626aab7 97 // Virtual serial port over USB
cyberjoey 15:61dce4bef44f 98 USBSerial pc(0x0B6A, 0x0042, 0x0001, false);
cyberjoey 9:36ba3626aab7 99
cyberjoey 9:36ba3626aab7 100 // I2C setup
cyberjoey 9:36ba3626aab7 101 I2C i2c(P3_4,P3_5); // P3_4 -> I2C1_SDA, P3_5-> I2C1_SCL
cyberjoey 9:36ba3626aab7 102
cyberjoey 9:36ba3626aab7 103 //Timer setup
cyberjoey 9:36ba3626aab7 104 Ticker timer_1; // timer for blinking led heartbeat
cyberjoey 9:36ba3626aab7 105
cyberjoey 9:36ba3626aab7 106 bool tick_flag; // used for counting seconds
cyberjoey 9:36ba3626aab7 107 bool log_flag = false;
cyberjoey 9:36ba3626aab7 108 bool led_toggle_flag = false;
cyberjoey 9:36ba3626aab7 109 bool button_flag = false;
cyberjoey 11:94a7379c0db8 110 bool sd_insert_flag = false;
cyberjoey 9:36ba3626aab7 111 bool error_flag;
cyberjoey 9:36ba3626aab7 112 int error_ticks;
cyberjoey 9:36ba3626aab7 113
cyberjoey 9:36ba3626aab7 114 //LED blink setup
switches 1:90313362ec11 115 DigitalOut rLED(LED1);
switches 1:90313362ec11 116 DigitalOut gLED(LED2);
cyberjoey 9:36ba3626aab7 117 DigitalOut bLED(LED3);
switches 0:60a522ae2e35 118
cyberjoey 9:36ba3626aab7 119 InterruptIn button(SW1);
cyberjoey 9:36ba3626aab7 120
cyberjoey 9:36ba3626aab7 121
cyberjoey 9:36ba3626aab7 122 void LED_blink_callback(){ // LED Heart beat
cyberjoey 9:36ba3626aab7 123
cyberjoey 9:36ba3626aab7 124 led_toggle_flag = !led_toggle_flag;
cyberjoey 9:36ba3626aab7 125
cyberjoey 9:36ba3626aab7 126 if(log_flag) //if logging
cyberjoey 9:36ba3626aab7 127 {
cyberjoey 9:36ba3626aab7 128
cyberjoey 9:36ba3626aab7 129 if(led_toggle_flag)
cyberjoey 9:36ba3626aab7 130 {
cyberjoey 9:36ba3626aab7 131 //toggle red led
cyberjoey 9:36ba3626aab7 132 rLED = LED_ON;
cyberjoey 9:36ba3626aab7 133 }
cyberjoey 9:36ba3626aab7 134 else
cyberjoey 9:36ba3626aab7 135 {
cyberjoey 9:36ba3626aab7 136 rLED = LED_OFF;
cyberjoey 9:36ba3626aab7 137 gLED = LED_OFF;
cyberjoey 9:36ba3626aab7 138 bLED = LED_OFF;
cyberjoey 9:36ba3626aab7 139 }
cyberjoey 9:36ba3626aab7 140 }
cyberjoey 9:36ba3626aab7 141 else if(error_flag) //if error (no sd card)
cyberjoey 9:36ba3626aab7 142 {
cyberjoey 9:36ba3626aab7 143 if(led_toggle_flag)
cyberjoey 9:36ba3626aab7 144 {
cyberjoey 9:36ba3626aab7 145 //toggle red led
cyberjoey 9:36ba3626aab7 146 rLED = LED_ON;
cyberjoey 9:36ba3626aab7 147 gLED = LED_ON;
cyberjoey 9:36ba3626aab7 148 }
cyberjoey 9:36ba3626aab7 149 else
cyberjoey 9:36ba3626aab7 150 {
cyberjoey 9:36ba3626aab7 151 rLED = LED_OFF;
cyberjoey 9:36ba3626aab7 152 gLED = LED_OFF;
cyberjoey 9:36ba3626aab7 153 bLED = LED_OFF;
cyberjoey 9:36ba3626aab7 154 }
cyberjoey 9:36ba3626aab7 155 error_ticks--;
cyberjoey 9:36ba3626aab7 156 if(error_ticks <= 0)
cyberjoey 9:36ba3626aab7 157 error_flag = false;
cyberjoey 9:36ba3626aab7 158 }
cyberjoey 9:36ba3626aab7 159 else
cyberjoey 9:36ba3626aab7 160 {
cyberjoey 9:36ba3626aab7 161 if(led_toggle_flag)
cyberjoey 9:36ba3626aab7 162 {
cyberjoey 9:36ba3626aab7 163 //toggle teal leds
cyberjoey 9:36ba3626aab7 164 gLED = LED_ON;
cyberjoey 9:36ba3626aab7 165 bLED = LED_ON;
cyberjoey 9:36ba3626aab7 166 }
cyberjoey 9:36ba3626aab7 167 else
cyberjoey 9:36ba3626aab7 168 {
cyberjoey 9:36ba3626aab7 169 rLED = LED_OFF;
cyberjoey 9:36ba3626aab7 170 gLED = LED_OFF;
cyberjoey 9:36ba3626aab7 171 bLED = LED_OFF;
cyberjoey 9:36ba3626aab7 172 }
cyberjoey 9:36ba3626aab7 173 }
cyberjoey 9:36ba3626aab7 174
cyberjoey 9:36ba3626aab7 175 tick_flag = true;
cyberjoey 9:36ba3626aab7 176 }
cyberjoey 9:36ba3626aab7 177
cyberjoey 9:36ba3626aab7 178 void btn_pressed() //button pressed isr
cyberjoey 9:36ba3626aab7 179 {
cyberjoey 9:36ba3626aab7 180 button_flag = true;
cyberjoey 9:36ba3626aab7 181 }
cyberjoey 9:36ba3626aab7 182
cyberjoey 11:94a7379c0db8 183 void sd_insert() //sd_insert pressed isr
cyberjoey 11:94a7379c0db8 184 {
cyberjoey 11:94a7379c0db8 185 sd_insert_flag = true;
cyberjoey 11:94a7379c0db8 186 }
cyberjoey 11:94a7379c0db8 187
cyberjoey 9:36ba3626aab7 188
cyberjoey 9:36ba3626aab7 189 // *****************************************************************************
cyberjoey 9:36ba3626aab7 190 // Define CRC-8 Table
cyberjoey 9:36ba3626aab7 191 // *****************************************************************************
cyberjoey 9:36ba3626aab7 192
cyberjoey 9:36ba3626aab7 193 static unsigned char crc_table[] = {
cyberjoey 9:36ba3626aab7 194 0, 94,188,226, 97, 63,221,131,194,156,126, 32,163,253, 31, 65,
cyberjoey 9:36ba3626aab7 195 157,195, 33,127,252,162, 64, 30, 95, 1,227,189, 62, 96,130,220,
cyberjoey 9:36ba3626aab7 196 35,125,159,193, 66, 28,254,160,225,191, 93, 3,128,222, 60, 98,
cyberjoey 9:36ba3626aab7 197 190,224, 2, 92,223,129, 99, 61,124, 34,192,158, 29, 67,161,255,
cyberjoey 9:36ba3626aab7 198 70, 24,250,164, 39,121,155,197,132,218, 56,102,229,187, 89, 7,
cyberjoey 9:36ba3626aab7 199 219,133,103, 57,186,228, 6, 88, 25, 71,165,251,120, 38,196,154,
cyberjoey 9:36ba3626aab7 200 101, 59,217,135, 4, 90,184,230,167,249, 27, 69,198,152,122, 36,
cyberjoey 9:36ba3626aab7 201 248,166, 68, 26,153,199, 37,123, 58,100,134,216, 91, 5,231,185,
cyberjoey 9:36ba3626aab7 202 140,210, 48,110,237,179, 81, 15, 78, 16,242,172, 47,113,147,205,
cyberjoey 9:36ba3626aab7 203 17, 79,173,243,112, 46,204,146,211,141,111, 49,178,236, 14, 80,
cyberjoey 9:36ba3626aab7 204 175,241, 19, 77,206,144,114, 44,109, 51,209,143, 12, 82,176,238,
cyberjoey 9:36ba3626aab7 205 50,108,142,208, 83, 13,239,177,240,174, 76, 18,145,207, 45,115,
cyberjoey 9:36ba3626aab7 206 202,148,118, 40,171,245, 23, 73, 8, 86,180,234,105, 55,213,139,
cyberjoey 9:36ba3626aab7 207 87, 9,235,181, 54,104,138,212,149,203, 41,119,244,170, 72, 22,
cyberjoey 9:36ba3626aab7 208 233,183, 85, 11,136,214, 52,106, 43,117,151,201, 74, 20,246,168,
cyberjoey 9:36ba3626aab7 209 116, 42,200,150, 21, 75,169,247,182,232, 10, 84,215,137,107, 53};
cyberjoey 9:36ba3626aab7 210
cyberjoey 9:36ba3626aab7 211
cyberjoey 9:36ba3626aab7 212
cyberjoey 9:36ba3626aab7 213 // -----------------------------------------------------------------------------
cyberjoey 9:36ba3626aab7 214 // Calculate the CRC8 of the byte value provided with the current total
cyberjoey 9:36ba3626aab7 215 // calc_crc8(unsigned char, unsigned char) crc8 total, byte to add
cyberjoey 9:36ba3626aab7 216 // pass crc8 total = 0 to start new crc sum.
cyberjoey 9:36ba3626aab7 217
cyberjoey 9:36ba3626aab7 218 // Returns new crc8 total
cyberjoey 9:36ba3626aab7 219 // -----------------------------------------------------------------------------
cyberjoey 9:36ba3626aab7 220
cyberjoey 9:36ba3626aab7 221 unsigned char calc_crc8(unsigned char crc8, unsigned char value){
cyberjoey 9:36ba3626aab7 222
cyberjoey 9:36ba3626aab7 223 return crc_table[crc8 ^ value];
cyberjoey 9:36ba3626aab7 224 }
cyberjoey 9:36ba3626aab7 225
cyberjoey 9:36ba3626aab7 226 // *****************************************************************************
cyberjoey 9:36ba3626aab7 227 // OW_reset()
cyberjoey 9:36ba3626aab7 228 // returns 0 no device present, 1 device present
cyberjoey 9:36ba3626aab7 229 // *****************************************************************************
cyberjoey 9:36ba3626aab7 230
cyberjoey 9:36ba3626aab7 231 int OW_reset(){
cyberjoey 9:36ba3626aab7 232 char data[2]; // define as minimun array size so 'data' is a pointer
cyberjoey 9:36ba3626aab7 233 data[0] = OW_RESET; // One Wire Reset 0xB4
cyberjoey 9:36ba3626aab7 234 i2c.write(DS2484_ADD,data,1,0); // write reset command to DS2484
cyberjoey 9:36ba3626aab7 235 wait_ms(1);
cyberjoey 9:36ba3626aab7 236 do{ // poll OW-busy
cyberjoey 9:36ba3626aab7 237 i2c.read(DS2484_ADD,data,1); // read back status byte from DS2484
cyberjoey 9:36ba3626aab7 238 }while(OWB & data[0]);
cyberjoey 9:36ba3626aab7 239 if(PPD & data[0])return 1; // Presence Pulse Detected bit true?
cyberjoey 9:36ba3626aab7 240 return 0; // else
cyberjoey 9:36ba3626aab7 241 } // end OW_reset()
cyberjoey 9:36ba3626aab7 242
cyberjoey 9:36ba3626aab7 243 // *****************************************************************************
cyberjoey 9:36ba3626aab7 244 // OW_write_byte(char) takes char to send over one wire
cyberjoey 9:36ba3626aab7 245 // returns DS2484 status byte
cyberjoey 9:36ba3626aab7 246 // *****************************************************************************
cyberjoey 9:36ba3626aab7 247
cyberjoey 9:36ba3626aab7 248 char OW_write_byte(char byte){
cyberjoey 9:36ba3626aab7 249
cyberjoey 9:36ba3626aab7 250 char data[2];
cyberjoey 9:36ba3626aab7 251 data[0] = 0xA5;
cyberjoey 9:36ba3626aab7 252 data[1] = byte;
cyberjoey 9:36ba3626aab7 253 i2c.write(DS2484_ADD,data,2,1);
cyberjoey 9:36ba3626aab7 254 i2c.read(DS2484_ADD,data,1); // read status byte
cyberjoey 9:36ba3626aab7 255
cyberjoey 9:36ba3626aab7 256 // db.printf("[%02X]",byte);
cyberjoey 9:36ba3626aab7 257 wait_us(700); // assumes normal speed OW write
cyberjoey 9:36ba3626aab7 258 return data[0]; // return DS2484 Status byte
cyberjoey 9:36ba3626aab7 259
cyberjoey 9:36ba3626aab7 260 }// end OW_write_byte()
cyberjoey 9:36ba3626aab7 261
cyberjoey 9:36ba3626aab7 262
cyberjoey 9:36ba3626aab7 263 // *****************************************************************************
cyberjoey 9:36ba3626aab7 264 // OW_read_byte(char *, int) char* (save data pointer)
cyberjoey 9:36ba3626aab7 265 // int (number of bytes to read)
cyberjoey 9:36ba3626aab7 266 // returns 0x00
cyberjoey 9:36ba3626aab7 267 //
cyberjoey 9:36ba3626aab7 268 // assumes OW_reset, OW_match rom, and OW device register read address already sent.
cyberjoey 9:36ba3626aab7 269 //
cyberjoey 9:36ba3626aab7 270 // *****************************************************************************
cyberjoey 9:36ba3626aab7 271
cyberjoey 9:36ba3626aab7 272 char OW_read_byte(char* a, int n){
cyberjoey 9:36ba3626aab7 273
cyberjoey 9:36ba3626aab7 274 char data[2];
cyberjoey 9:36ba3626aab7 275 int i;
cyberjoey 9:36ba3626aab7 276
cyberjoey 9:36ba3626aab7 277 //read n bytes of data
cyberjoey 9:36ba3626aab7 278 i=0;
cyberjoey 9:36ba3626aab7 279 do{
cyberjoey 9:36ba3626aab7 280 data[0] = OWRB; // send 0x96; DS2484 command, OW read byte
cyberjoey 9:36ba3626aab7 281 i2c.write(DS2484_ADD,data,1,0);
cyberjoey 9:36ba3626aab7 282 wait_us(600);
cyberjoey 9:36ba3626aab7 283 do{
cyberjoey 9:36ba3626aab7 284 i2c.read(DS2484_ADD,data,1); // read status byte and test OW-busy?
cyberjoey 9:36ba3626aab7 285 }while(data[0]&0x01 == 1); // status bit[0] set --> OW busy
cyberjoey 9:36ba3626aab7 286
cyberjoey 9:36ba3626aab7 287 //get byte from DS2484
cyberjoey 9:36ba3626aab7 288 data[0] = SRP; // send 0xE1, set read pointer
cyberjoey 9:36ba3626aab7 289 data[1] = 0xE1; // set read pointer address 0xE1 read OW data
cyberjoey 9:36ba3626aab7 290 i2c.write(DS2484_ADD,data,2,1);
cyberjoey 9:36ba3626aab7 291 i2c.read(DS2484_ADD,data,1); // read bytes from OW register
cyberjoey 9:36ba3626aab7 292
cyberjoey 9:36ba3626aab7 293 a[i] = data[0];
cyberjoey 9:36ba3626aab7 294
cyberjoey 9:36ba3626aab7 295 i++;
cyberjoey 9:36ba3626aab7 296 //pc.printf("[%02X] ",data[0]);
cyberjoey 9:36ba3626aab7 297 }while(i<n);
cyberjoey 9:36ba3626aab7 298 //for(i=0;i<n;i++) db.printf("OW_read_byte - [%2d][%02X]\r\n",i,a[i]);
cyberjoey 9:36ba3626aab7 299 return 0x00;
cyberjoey 9:36ba3626aab7 300 }// end OW_read_byte()
cyberjoey 9:36ba3626aab7 301
cyberjoey 9:36ba3626aab7 302
cyberjoey 9:36ba3626aab7 303
cyberjoey 9:36ba3626aab7 304 // *****************************************************************************
cyberjoey 9:36ba3626aab7 305 // OW_match_rom(char *) pointer to device_id byte array
cyberjoey 9:36ba3626aab7 306 // returns 0x00
cyberjoey 9:36ba3626aab7 307 // assumes OW_reset alread sent
cyberjoey 9:36ba3626aab7 308 // *****************************************************************************
cyberjoey 9:36ba3626aab7 309
cyberjoey 9:36ba3626aab7 310 char OW_match_rom(char *device_id){
cyberjoey 9:36ba3626aab7 311
cyberjoey 9:36ba3626aab7 312 int i;
cyberjoey 9:36ba3626aab7 313 //Match rom
cyberjoey 9:36ba3626aab7 314 OW_write_byte(OW_MATCH); // send 0x55, match rom command
cyberjoey 9:36ba3626aab7 315 //send rom code for device
cyberjoey 9:36ba3626aab7 316 for(i=0;i<8;i++){
cyberjoey 9:36ba3626aab7 317 OW_write_byte(device_id[i]); //I2C write ow byte
cyberjoey 9:36ba3626aab7 318 }
cyberjoey 9:36ba3626aab7 319 return 0x00;
cyberjoey 9:36ba3626aab7 320
cyberjoey 9:36ba3626aab7 321 }// end OW_macth_rom
cyberjoey 9:36ba3626aab7 322
cyberjoey 9:36ba3626aab7 323
cyberjoey 9:36ba3626aab7 324 // *****************************************************************************
cyberjoey 9:36ba3626aab7 325 // search_rom(char *) pointer to start of 2D array rom_id_list
cyberjoey 9:36ba3626aab7 326 // returns number of devices found
cyberjoey 9:36ba3626aab7 327 // *****************************************************************************
cyberjoey 9:36ba3626aab7 328
cyberjoey 9:36ba3626aab7 329
cyberjoey 9:36ba3626aab7 330 int search_rom(char rom_id_list[MAX_DEVICES][ID_LENGTH]){ // searches for all device on OW bus, returns # found
cyberjoey 9:36ba3626aab7 331
cyberjoey 9:36ba3626aab7 332 int bit_num;
cyberjoey 9:36ba3626aab7 333 int byte_num;
cyberjoey 9:36ba3626aab7 334 int last_zero;
cyberjoey 9:36ba3626aab7 335 int last_discrep;
cyberjoey 9:36ba3626aab7 336 int search_dir;
cyberjoey 9:36ba3626aab7 337 int rom_count;
cyberjoey 9:36ba3626aab7 338 char byte_mask;
cyberjoey 9:36ba3626aab7 339 int last_device;
cyberjoey 9:36ba3626aab7 340 int i;
cyberjoey 9:36ba3626aab7 341
cyberjoey 9:36ba3626aab7 342 char rom_id[8]; //used in rom search
cyberjoey 9:36ba3626aab7 343 char data[8];
cyberjoey 9:36ba3626aab7 344 char crc;
cyberjoey 9:36ba3626aab7 345
cyberjoey 9:36ba3626aab7 346 //init for first search only
cyberjoey 9:36ba3626aab7 347 last_device = 0;
cyberjoey 9:36ba3626aab7 348 last_discrep = 0;
cyberjoey 9:36ba3626aab7 349 rom_count = 0;
cyberjoey 9:36ba3626aab7 350
cyberjoey 9:36ba3626aab7 351 for(i=0;i<8;i++)rom_id[i] = 0x00; //clear rom_id
cyberjoey 9:36ba3626aab7 352
cyberjoey 9:36ba3626aab7 353 do{ // loop for each rom search (end when last_device = 1)
cyberjoey 9:36ba3626aab7 354
cyberjoey 9:36ba3626aab7 355 //init variable for each search
cyberjoey 9:36ba3626aab7 356 bit_num = 1;
cyberjoey 9:36ba3626aab7 357 byte_num = 0;
cyberjoey 9:36ba3626aab7 358 byte_mask = 1;
cyberjoey 9:36ba3626aab7 359 last_zero = 0;
cyberjoey 9:36ba3626aab7 360
cyberjoey 9:36ba3626aab7 361
cyberjoey 9:36ba3626aab7 362 //OW reset
cyberjoey 9:36ba3626aab7 363 if(OW_reset()){ //returns 1 if at least one device present
cyberjoey 9:36ba3626aab7 364 //test if last device found
cyberjoey 9:36ba3626aab7 365 if(last_device!=1){ // more devices to find
cyberjoey 9:36ba3626aab7 366 search_dir = 0;
cyberjoey 9:36ba3626aab7 367 OW_write_byte(OW_SEARCH); //send 0xF0 over one wire to init search rom
cyberjoey 9:36ba3626aab7 368
cyberjoey 9:36ba3626aab7 369 do{
cyberjoey 9:36ba3626aab7 370 //determine search direction
cyberjoey 9:36ba3626aab7 371 if(bit_num < last_discrep){ //before last discrepancy
cyberjoey 9:36ba3626aab7 372 if((rom_id[byte_num] & byte_mask) > 0){// use last rom path
cyberjoey 9:36ba3626aab7 373 search_dir = 1; // last path was 1
cyberjoey 9:36ba3626aab7 374 }else{
cyberjoey 9:36ba3626aab7 375 search_dir = 0; // last path was 0
cyberjoey 9:36ba3626aab7 376 }
cyberjoey 9:36ba3626aab7 377 }else{ // at or past last discrepancy
cyberjoey 9:36ba3626aab7 378 if(bit_num == last_discrep){ // at last discrepancy
cyberjoey 9:36ba3626aab7 379 search_dir = 1; //been here before so use 1
cyberjoey 9:36ba3626aab7 380 }else{
cyberjoey 9:36ba3626aab7 381 search_dir = 0; //past last discrepancy so use 0
cyberjoey 9:36ba3626aab7 382 }
cyberjoey 9:36ba3626aab7 383 }
cyberjoey 9:36ba3626aab7 384
cyberjoey 9:36ba3626aab7 385 //write direction bit and get reply
cyberjoey 9:36ba3626aab7 386 data[0] = 0x78;
cyberjoey 9:36ba3626aab7 387 data[1] = search_dir << 7; //sets bit 7 of status reg to search_dir
cyberjoey 9:36ba3626aab7 388 i2c.write(DS2484_ADD,data,2,1);
cyberjoey 9:36ba3626aab7 389
cyberjoey 9:36ba3626aab7 390 wait_us(250);
cyberjoey 9:36ba3626aab7 391
cyberjoey 9:36ba3626aab7 392 //read in rom_id bits
cyberjoey 9:36ba3626aab7 393 i2c.read(DS2484_ADD,data,1); // read status byte
cyberjoey 9:36ba3626aab7 394
cyberjoey 9:36ba3626aab7 395 //(todo) check for no device error here
cyberjoey 9:36ba3626aab7 396
cyberjoey 9:36ba3626aab7 397 //get search direction used by triplet command
cyberjoey 9:36ba3626aab7 398
cyberjoey 9:36ba3626aab7 399 if(data[0]&0x80){ //true --> DIR bit = 1
cyberjoey 9:36ba3626aab7 400 search_dir = 1;
cyberjoey 9:36ba3626aab7 401 }else{
cyberjoey 9:36ba3626aab7 402 search_dir = 0;
cyberjoey 9:36ba3626aab7 403 }
cyberjoey 9:36ba3626aab7 404
cyberjoey 9:36ba3626aab7 405 //test for discrepancy (both 0 and 1 present at current bit number)(TSB = 0 (1's present) and SBR = 0 (0's present))
cyberjoey 9:36ba3626aab7 406 if(!(data[0] & 0x60)){ // true --> discrepancy exist, both TSB and SBR = 0
cyberjoey 9:36ba3626aab7 407 if(search_dir == 0)last_zero = bit_num;
cyberjoey 9:36ba3626aab7 408 }
cyberjoey 9:36ba3626aab7 409 if(search_dir == 1){ // write search dir to rom bit
cyberjoey 9:36ba3626aab7 410 rom_id[byte_num] |= byte_mask;
cyberjoey 9:36ba3626aab7 411 }else{
cyberjoey 9:36ba3626aab7 412 rom_id[byte_num] &= ~byte_mask;
cyberjoey 9:36ba3626aab7 413 }
cyberjoey 9:36ba3626aab7 414
cyberjoey 9:36ba3626aab7 415 //increment bit_num and byte_num if needed
cyberjoey 9:36ba3626aab7 416 bit_num++;
cyberjoey 9:36ba3626aab7 417 byte_mask <<= 1; //rotate 1 bit left
cyberjoey 9:36ba3626aab7 418 if(byte_mask == 0){ //if bit shifts out of byte set byte to 1
cyberjoey 9:36ba3626aab7 419 byte_num++; //also increnent byt num
cyberjoey 9:36ba3626aab7 420 byte_mask = 1;
cyberjoey 9:36ba3626aab7 421 }
cyberjoey 9:36ba3626aab7 422
cyberjoey 9:36ba3626aab7 423
cyberjoey 9:36ba3626aab7 424 }while(bit_num<65); //bit nun started at 1 so end after 64
cyberjoey 9:36ba3626aab7 425 last_discrep = last_zero;
cyberjoey 9:36ba3626aab7 426 if(last_discrep == 0)last_device = 1;
cyberjoey 9:36ba3626aab7 427 //copy rom_id into rom_id_list and calc crc of first 7 bytes
cyberjoey 13:674c647d12dd 428 crc = 0x00; // reset crc8 total to 0
cyberjoey 9:36ba3626aab7 429 for(i=7;i>=0;i--){
cyberjoey 13:674c647d12dd 430 rom_id_list[rom_count][i] = rom_id[i];
cyberjoey 13:674c647d12dd 431 }
cyberjoey 9:36ba3626aab7 432
cyberjoey 9:36ba3626aab7 433 //clac_crc of rom ID
cyberjoey 9:36ba3626aab7 434 for (i=0;i<7;i++){
cyberjoey 9:36ba3626aab7 435 crc = calc_crc8(crc, rom_id[i]);
cyberjoey 9:36ba3626aab7 436 }
cyberjoey 9:36ba3626aab7 437
cyberjoey 9:36ba3626aab7 438 rom_count++;
cyberjoey 9:36ba3626aab7 439 }//if(last_device..)
cyberjoey 9:36ba3626aab7 440 }else{//if prescent -- if no device present rom count is 0
cyberjoey 9:36ba3626aab7 441 return 0;
cyberjoey 9:36ba3626aab7 442 }
cyberjoey 9:36ba3626aab7 443 }while(last_device == 0);
cyberjoey 9:36ba3626aab7 444 return rom_count;
cyberjoey 9:36ba3626aab7 445 }// end search_rom()
cyberjoey 9:36ba3626aab7 446
cyberjoey 9:36ba3626aab7 447 // *****************************************************************************
cyberjoey 17:401a5bb8d403 448 // OT07_write_register(char, char, char) writes single byte to OT07
cyberjoey 17:401a5bb8d403 449 // char I2C address
cyberjoey 17:401a5bb8d403 450 // char OT07 register address
cyberjoey 17:401a5bb8d403 451 // char data byte to be writen
cyberjoey 17:401a5bb8d403 452 // returns 0 on success ACK, 1 on NACK
cyberjoey 17:401a5bb8d403 453 // *****************************************************************************
cyberjoey 17:401a5bb8d403 454
cyberjoey 17:401a5bb8d403 455 int OT07_write_register(char I2C_add, char reg_add, char byte){
cyberjoey 17:401a5bb8d403 456 char data[2];
cyberjoey 17:401a5bb8d403 457 int error;
cyberjoey 17:401a5bb8d403 458 data[0] = reg_add;
cyberjoey 17:401a5bb8d403 459 data[1] = byte;
cyberjoey 17:401a5bb8d403 460 error = i2c.write(I2C_add,data,2);
cyberjoey 17:401a5bb8d403 461 //if(DEBUG)db.printf("wr[%02X %02X %d]\r\n", data[0], data[1], error);
cyberjoey 17:401a5bb8d403 462 return error;
cyberjoey 17:401a5bb8d403 463
cyberjoey 17:401a5bb8d403 464 }
cyberjoey 17:401a5bb8d403 465
cyberjoey 17:401a5bb8d403 466 /// ****************************************************************************
cyberjoey 17:401a5bb8d403 467 // OT07_write_register(char, char, char *, int) writes multiple bytes to OT07
cyberjoey 17:401a5bb8d403 468 // char I2C address
cyberjoey 17:401a5bb8d403 469 // char OT07 register address
cyberjoey 17:401a5bb8d403 470 // char * data vector of bytes to be written
cyberjoey 17:401a5bb8d403 471 // int number of bytes to write
cyberjoey 17:401a5bb8d403 472 // returns 0 on success ACK, 1 on NACK
cyberjoey 17:401a5bb8d403 473 // *****************************************************************************
cyberjoey 17:401a5bb8d403 474
cyberjoey 17:401a5bb8d403 475 int OT07_write_register(char I2C_add, char reg_add, char *bytes, int n){
cyberjoey 17:401a5bb8d403 476 int i;
cyberjoey 17:401a5bb8d403 477 //set start address
cyberjoey 17:401a5bb8d403 478 char data[16];
cyberjoey 17:401a5bb8d403 479 int error;
cyberjoey 17:401a5bb8d403 480 data[0] = reg_add;
cyberjoey 17:401a5bb8d403 481 for(i=1;i<=n;i++){
cyberjoey 17:401a5bb8d403 482 data[i] = bytes[i-1];
cyberjoey 17:401a5bb8d403 483 }
cyberjoey 17:401a5bb8d403 484 error = i2c.write(I2C_add,data,n+1); // send n bytes of data
cyberjoey 17:401a5bb8d403 485
cyberjoey 17:401a5bb8d403 486 return error;
cyberjoey 17:401a5bb8d403 487 }
cyberjoey 17:401a5bb8d403 488
cyberjoey 17:401a5bb8d403 489 // *****************************************************************************
cyberjoey 17:401a5bb8d403 490 // OT07_read_register(char, char, char *, int) writes single byte to OT07
cyberjoey 17:401a5bb8d403 491 // char I2C address
cyberjoey 17:401a5bb8d403 492 // char OT07 register address
cyberjoey 17:401a5bb8d403 493 // char * data vector for read bytes to be stored in
cyberjoey 17:401a5bb8d403 494 // int number of bytes to read
cyberjoey 17:401a5bb8d403 495 // returns 0 on success, 1 on fail
cyberjoey 17:401a5bb8d403 496 // *****************************************************************************
cyberjoey 17:401a5bb8d403 497
cyberjoey 17:401a5bb8d403 498 int OT07_read_register(char I2C_add, char reg_add, char *bytes, int n){
cyberjoey 17:401a5bb8d403 499 int error;
cyberjoey 17:401a5bb8d403 500 error = i2c.write(I2C_add,&reg_add,1,1);
cyberjoey 17:401a5bb8d403 501 if(error)return error;
cyberjoey 17:401a5bb8d403 502 error = i2c.read(I2C_add,bytes,n);
cyberjoey 17:401a5bb8d403 503 //if(DEBUG)db.printf("rr e[%d]\r\n",error);
cyberjoey 17:401a5bb8d403 504 return error;
cyberjoey 17:401a5bb8d403 505 }
cyberjoey 17:401a5bb8d403 506
cyberjoey 17:401a5bb8d403 507 // *****************************************************************************
cyberjoey 17:401a5bb8d403 508 // search_I2C_bus(OT07_struct *) searches I2C address 0xA0, 0xA2, 0xA4 and 0xA6
cyberjoey 17:401a5bb8d403 509 // OT07_struct * structure array to holds I2C address and rom_ids
cyberjoey 17:401a5bb8d403 510 // returns number of devices found
cyberjoey 17:401a5bb8d403 511 // *****************************************************************************
cyberjoey 17:401a5bb8d403 512
cyberjoey 17:401a5bb8d403 513 int search_I2C_bus(OT07_struct OT07[]){
cyberjoey 17:401a5bb8d403 514 char data[16];
cyberjoey 17:401a5bb8d403 515 char I2C_add;
cyberjoey 17:401a5bb8d403 516 //char GPIO;
cyberjoey 17:401a5bb8d403 517 int error;
cyberjoey 17:401a5bb8d403 518 int device_count = 0;
cyberjoey 17:401a5bb8d403 519 int i;
cyberjoey 17:401a5bb8d403 520 int j;
cyberjoey 17:401a5bb8d403 521 for(i = 0;i<4;i++){
cyberjoey 17:401a5bb8d403 522 I2C_add = 0xA0 + i*2;
cyberjoey 17:401a5bb8d403 523 error = OT07_read_register(I2C_add,0xff,data,1);
cyberjoey 17:401a5bb8d403 524
cyberjoey 17:401a5bb8d403 525 if(error == 0){
cyberjoey 17:401a5bb8d403 526 if(data[0] == 0x30){
cyberjoey 17:401a5bb8d403 527
cyberjoey 17:401a5bb8d403 528 OT07[device_count].I2C_address = I2C_add;
cyberjoey 17:401a5bb8d403 529
cyberjoey 17:401a5bb8d403 530 OT07_read_register(I2C_add,OT07_ROM_ID,data,8);
cyberjoey 17:401a5bb8d403 531 for(j=7;j>=0;j--){
cyberjoey 17:401a5bb8d403 532 OT07[device_count].rom_id[j] = data[j];
cyberjoey 17:401a5bb8d403 533
cyberjoey 17:401a5bb8d403 534 }
cyberjoey 17:401a5bb8d403 535 device_count++;
cyberjoey 17:401a5bb8d403 536 }
cyberjoey 17:401a5bb8d403 537 }
cyberjoey 17:401a5bb8d403 538
cyberjoey 17:401a5bb8d403 539 }
cyberjoey 17:401a5bb8d403 540 return device_count;
cyberjoey 17:401a5bb8d403 541 }
cyberjoey 17:401a5bb8d403 542
cyberjoey 17:401a5bb8d403 543 // *****************************************************************************
cyberjoey 17:401a5bb8d403 544 // convert_temperature(char) sends convert command to OT07 device
cyberjoey 17:401a5bb8d403 545 // char I2C address
cyberjoey 17:401a5bb8d403 546 // *****************************************************************************
cyberjoey 17:401a5bb8d403 547
cyberjoey 17:401a5bb8d403 548 void convert_temperature(char I2C_add){ // set convert bit to start conversion
cyberjoey 17:401a5bb8d403 549
cyberjoey 17:401a5bb8d403 550 char data[2];
cyberjoey 17:401a5bb8d403 551
cyberjoey 17:401a5bb8d403 552 //read ADC_SETUP register 0x14
cyberjoey 17:401a5bb8d403 553 OT07_read_register(I2C_add, OT07_ADC_SETUP,data,1);
cyberjoey 17:401a5bb8d403 554
cyberjoey 17:401a5bb8d403 555 //mask convert register value with 0x01 and write back register 0x14
cyberjoey 17:401a5bb8d403 556 OT07_write_register(I2C_add, OT07_ADC_SETUP, data[0]|0x01);
cyberjoey 17:401a5bb8d403 557 }
cyberjoey 17:401a5bb8d403 558
cyberjoey 17:401a5bb8d403 559 //******************************************************************************
cyberjoey 17:401a5bb8d403 560 // get_temperature(char) read temperature from OT07 device FIFO register
cyberjoey 17:401a5bb8d403 561 // char I2C address
cyberjoey 17:401a5bb8d403 562 // returns double temperature in oC
cyberjoey 17:401a5bb8d403 563 //******************************************************************************
cyberjoey 17:401a5bb8d403 564
cyberjoey 17:401a5bb8d403 565 double get_temperature(char I2C_add){
cyberjoey 17:401a5bb8d403 566 char data[2];
cyberjoey 17:401a5bb8d403 567 double T;
cyberjoey 17:401a5bb8d403 568 int count;
cyberjoey 17:401a5bb8d403 569
cyberjoey 17:401a5bb8d403 570 OT07_read_register(I2C_add,OT07_FIFO_DATA,data,2); // Read temperature from FIFO, 2 bytes
cyberjoey 17:401a5bb8d403 571 //if(DEBUG)db.printf("get_temperature -- FIFO[%02X %02X]\r\n",data[0],data[1]);
cyberjoey 17:401a5bb8d403 572 //calculate temperture from data
cyberjoey 17:401a5bb8d403 573 count = (int)(data[0]*256 + data[1]);
cyberjoey 17:401a5bb8d403 574 if (count >= 32768)count = count - 65536; // 2s comp
cyberjoey 17:401a5bb8d403 575 T = (double)count*0.005;
cyberjoey 17:401a5bb8d403 576
cyberjoey 17:401a5bb8d403 577 return T;
cyberjoey 17:401a5bb8d403 578 }
cyberjoey 17:401a5bb8d403 579
cyberjoey 17:401a5bb8d403 580 // *****************************************************************************
cyberjoey 9:36ba3626aab7 581 // alarm_search(char *) pointer to start of 2D array rom_id_list
cyberjoey 9:36ba3626aab7 582 // returns number of devices found with alarm triggered
cyberjoey 9:36ba3626aab7 583 // *****************************************************************************
cyberjoey 9:36ba3626aab7 584
cyberjoey 9:36ba3626aab7 585 int alarm_search(char rom_id_list[MAX_DEVICES][ID_LENGTH]){ // searches for all devices with alarm triggered on OW bus, returns # found
switches 0:60a522ae2e35 586
cyberjoey 9:36ba3626aab7 587 int bit_num;
cyberjoey 9:36ba3626aab7 588 int byte_num;
cyberjoey 9:36ba3626aab7 589 int last_zero;
cyberjoey 9:36ba3626aab7 590 int last_discrep;
cyberjoey 9:36ba3626aab7 591 int search_dir;
cyberjoey 9:36ba3626aab7 592 int rom_count;
cyberjoey 9:36ba3626aab7 593 char byte_mask;
cyberjoey 9:36ba3626aab7 594 int last_device;
cyberjoey 9:36ba3626aab7 595 int i;
cyberjoey 9:36ba3626aab7 596
cyberjoey 9:36ba3626aab7 597 char rom_id[8]; //used in rom search
cyberjoey 9:36ba3626aab7 598 char data[8];
cyberjoey 9:36ba3626aab7 599 char crc;
cyberjoey 9:36ba3626aab7 600
cyberjoey 9:36ba3626aab7 601 //init for first search only
cyberjoey 9:36ba3626aab7 602 last_device = 0;
cyberjoey 9:36ba3626aab7 603 last_discrep = 0;
cyberjoey 9:36ba3626aab7 604 rom_count = 0;
cyberjoey 9:36ba3626aab7 605
cyberjoey 9:36ba3626aab7 606 for(i=0;i<8;i++)rom_id[i] = 0x00; //clear rom_id
cyberjoey 9:36ba3626aab7 607
cyberjoey 9:36ba3626aab7 608 do{ // loop for each rom search (end when last_device = 1)
cyberjoey 9:36ba3626aab7 609
cyberjoey 9:36ba3626aab7 610 //init variable for each search
cyberjoey 9:36ba3626aab7 611 bit_num = 1;
cyberjoey 9:36ba3626aab7 612 byte_num = 0;
cyberjoey 9:36ba3626aab7 613 byte_mask = 1;
cyberjoey 9:36ba3626aab7 614 last_zero = 0;
cyberjoey 9:36ba3626aab7 615
cyberjoey 9:36ba3626aab7 616
cyberjoey 9:36ba3626aab7 617 //OW reset
cyberjoey 9:36ba3626aab7 618 if(OW_reset()){ //returns 1 if at least one device present
cyberjoey 9:36ba3626aab7 619 //test if last device found
cyberjoey 9:36ba3626aab7 620 if(last_device!=1){ // more devices to find
cyberjoey 9:36ba3626aab7 621 search_dir = 0;
cyberjoey 9:36ba3626aab7 622 OW_write_byte(OW_ALARM); //send 0xEC over one wire to init alarm search
cyberjoey 9:36ba3626aab7 623
cyberjoey 9:36ba3626aab7 624 do{
cyberjoey 9:36ba3626aab7 625 //determine search direction
cyberjoey 9:36ba3626aab7 626 if(bit_num < last_discrep){ //before last discrepancy
cyberjoey 9:36ba3626aab7 627 if((rom_id[byte_num] & byte_mask) > 0){// use last rom path
cyberjoey 9:36ba3626aab7 628 search_dir = 1; // last path was 1
cyberjoey 9:36ba3626aab7 629 }else{
cyberjoey 9:36ba3626aab7 630 search_dir = 0; // last path was 0
cyberjoey 9:36ba3626aab7 631 }
cyberjoey 9:36ba3626aab7 632 }else{ // at or past last discrepancy
cyberjoey 9:36ba3626aab7 633 if(bit_num == last_discrep){ // at last discrepancy
cyberjoey 9:36ba3626aab7 634 search_dir = 1; //been here before so use 1
cyberjoey 9:36ba3626aab7 635 }else{
cyberjoey 9:36ba3626aab7 636 search_dir = 0; //past last discrepancy so use 0
cyberjoey 9:36ba3626aab7 637 }
cyberjoey 9:36ba3626aab7 638 }
cyberjoey 9:36ba3626aab7 639
cyberjoey 9:36ba3626aab7 640 //write direction bit and get reply
cyberjoey 9:36ba3626aab7 641 data[0] = 0x78;
cyberjoey 9:36ba3626aab7 642 data[1] = search_dir << 7; //sets bit 7 of status reg to search_dir
cyberjoey 9:36ba3626aab7 643 i2c.write(DS2484_ADD,data,2,1);
cyberjoey 9:36ba3626aab7 644
cyberjoey 9:36ba3626aab7 645 wait_us(250);
cyberjoey 9:36ba3626aab7 646
cyberjoey 9:36ba3626aab7 647 //read in rom_id bits
cyberjoey 9:36ba3626aab7 648 i2c.read(DS2484_ADD,data,1); // read status byte
cyberjoey 9:36ba3626aab7 649
cyberjoey 9:36ba3626aab7 650 //(todo) check for no device error here
cyberjoey 9:36ba3626aab7 651
cyberjoey 9:36ba3626aab7 652 //get search direction used by triplet command
cyberjoey 9:36ba3626aab7 653
cyberjoey 9:36ba3626aab7 654 if(data[0]&0x80){ //true --> DIR bit = 1
cyberjoey 9:36ba3626aab7 655 search_dir = 1;
cyberjoey 9:36ba3626aab7 656 }else{
cyberjoey 9:36ba3626aab7 657 search_dir = 0;
cyberjoey 9:36ba3626aab7 658 }
cyberjoey 9:36ba3626aab7 659
cyberjoey 9:36ba3626aab7 660 //test for discrepancy (both 0 and 1 present at current bit number)(TSB = 0 (1's present) and SBR = 0 (0's present))
cyberjoey 9:36ba3626aab7 661 if(!(data[0] & 0x60)){ // true --> discrepancy exist, both TSB and SBR = 0
cyberjoey 9:36ba3626aab7 662 if(search_dir == 0)last_zero = bit_num;
cyberjoey 9:36ba3626aab7 663 }
cyberjoey 9:36ba3626aab7 664 if(search_dir == 1){ // write search dir to rom bit
cyberjoey 9:36ba3626aab7 665 rom_id[byte_num] |= byte_mask;
cyberjoey 9:36ba3626aab7 666 }else{
cyberjoey 9:36ba3626aab7 667 rom_id[byte_num] &= ~byte_mask;
cyberjoey 9:36ba3626aab7 668 }
cyberjoey 9:36ba3626aab7 669
cyberjoey 9:36ba3626aab7 670 //increment bit_num and byte_num if needed
cyberjoey 9:36ba3626aab7 671 bit_num++;
cyberjoey 9:36ba3626aab7 672 byte_mask <<= 1; //rotate 1 bit left
cyberjoey 9:36ba3626aab7 673 if(byte_mask == 0){ //if bit shifts out of byte set byte to 1
cyberjoey 9:36ba3626aab7 674 byte_num++; //also increnent byt num
cyberjoey 9:36ba3626aab7 675 byte_mask = 1;
cyberjoey 9:36ba3626aab7 676 }
cyberjoey 9:36ba3626aab7 677
cyberjoey 9:36ba3626aab7 678
cyberjoey 9:36ba3626aab7 679 }while(bit_num<65); //bit nun started at 1 so end after 64
cyberjoey 9:36ba3626aab7 680 last_discrep = last_zero;
cyberjoey 9:36ba3626aab7 681 if(last_discrep == 0)last_device = 1;
cyberjoey 9:36ba3626aab7 682 //copy rom_id into rom_id_list and calc crc of first 7 bytes
cyberjoey 13:674c647d12dd 683 crc = 0x00; // reset crc8 total to 0
cyberjoey 9:36ba3626aab7 684 for(i=7;i>=0;i--){
cyberjoey 9:36ba3626aab7 685 rom_id_list[rom_count][i] = rom_id[i];
cyberjoey 9:36ba3626aab7 686 }
cyberjoey 9:36ba3626aab7 687
cyberjoey 9:36ba3626aab7 688 //clac_crc of rom ID
cyberjoey 9:36ba3626aab7 689 for (i=0;i<7;i++){
cyberjoey 9:36ba3626aab7 690 crc = calc_crc8(crc, rom_id[i]);
cyberjoey 9:36ba3626aab7 691 }
cyberjoey 9:36ba3626aab7 692
cyberjoey 9:36ba3626aab7 693 rom_count++;
cyberjoey 9:36ba3626aab7 694 }//if(last_device..)
cyberjoey 9:36ba3626aab7 695 }else{//if prescent -- if no device present rom count is 0
cyberjoey 9:36ba3626aab7 696 return 0;
cyberjoey 9:36ba3626aab7 697 }
cyberjoey 9:36ba3626aab7 698 }while(last_device == 0);
cyberjoey 9:36ba3626aab7 699
cyberjoey 9:36ba3626aab7 700 //check if rom_id from alarm search is all 1s (this means there was a presence pulse but no alarm is triggered)
cyberjoey 9:36ba3626aab7 701 bool bad_rom_id = true;
cyberjoey 9:36ba3626aab7 702 for(int i = 0; i < 7; i++)
cyberjoey 9:36ba3626aab7 703 {
cyberjoey 9:36ba3626aab7 704 if(rom_id_list[0][i] != 0xFF)
cyberjoey 9:36ba3626aab7 705 bad_rom_id = false; //found a byte in the rom id that isn't all 1s
cyberjoey 9:36ba3626aab7 706 }
cyberjoey 9:36ba3626aab7 707 if(bad_rom_id)
cyberjoey 9:36ba3626aab7 708 return 0;
cyberjoey 9:36ba3626aab7 709
cyberjoey 9:36ba3626aab7 710 return rom_count;
cyberjoey 9:36ba3626aab7 711 }// end alarm_search()
cyberjoey 9:36ba3626aab7 712
cyberjoey 9:36ba3626aab7 713
cyberjoey 9:36ba3626aab7 714 // ******************** write_OW_register() ********************************
cyberjoey 9:36ba3626aab7 715 // write_OW_register(char*, int, int, char*)
cyberjoey 9:36ba3626aab7 716 // char* pointer to rom_id
cyberjoey 9:36ba3626aab7 717 // int start address
cyberjoey 9:36ba3626aab7 718 // int number of bytes to write
cyberjoey 9:36ba3626aab7 719 // char* pointer to write data location
cyberjoey 9:36ba3626aab7 720 // returns 0 if CRC match data
cyberjoey 9:36ba3626aab7 721 // returns -1 if CRC does not match data
cyberjoey 9:36ba3626aab7 722 //
cyberjoey 9:36ba3626aab7 723 // *****************************************************************************
cyberjoey 9:36ba3626aab7 724
cyberjoey 9:36ba3626aab7 725
cyberjoey 9:36ba3626aab7 726
cyberjoey 9:36ba3626aab7 727 int write_OW_register(char *device_ID, int start_add, int n, char *data){
cyberjoey 9:36ba3626aab7 728 int i;
cyberjoey 9:36ba3626aab7 729 //select device
cyberjoey 9:36ba3626aab7 730 OW_reset();
cyberjoey 9:36ba3626aab7 731 OW_match_rom(device_ID);
cyberjoey 9:36ba3626aab7 732 //set start address
cyberjoey 9:36ba3626aab7 733 OW_write_byte(OT07_OW_WRITE); // send 0xCC, OW write register command for OT07
cyberjoey 9:36ba3626aab7 734 OW_write_byte(start_add); // send write register start address
cyberjoey 9:36ba3626aab7 735 OW_write_byte(n-1); // send length of bytes to write (00-> one byte)
cyberjoey 9:36ba3626aab7 736 for(i=0;i<n;i++){ // send n bytes of data
cyberjoey 9:36ba3626aab7 737 OW_write_byte(data[i]);
cyberjoey 9:36ba3626aab7 738 }
cyberjoey 9:36ba3626aab7 739 OW_read_byte(data,2); // read 2 byte CRC
cyberjoey 9:36ba3626aab7 740
cyberjoey 9:36ba3626aab7 741 // --- todo ----
cyberjoey 9:36ba3626aab7 742 // calculate CRC of
cyberjoey 9:36ba3626aab7 743 // Command + length + n bytes sent
cyberjoey 9:36ba3626aab7 744 // compare with 2 bytes read
cyberjoey 9:36ba3626aab7 745
cyberjoey 9:36ba3626aab7 746 return 0;
cyberjoey 9:36ba3626aab7 747
cyberjoey 9:36ba3626aab7 748 }//end write_OW_register
cyberjoey 9:36ba3626aab7 749
cyberjoey 9:36ba3626aab7 750
cyberjoey 9:36ba3626aab7 751
cyberjoey 9:36ba3626aab7 752
cyberjoey 9:36ba3626aab7 753 // ******************** read_OW_register() ********************************
cyberjoey 9:36ba3626aab7 754 // read_OW_register(char*, int, int, char*)
cyberjoey 9:36ba3626aab7 755 // char* pointer to rom_id
cyberjoey 9:36ba3626aab7 756 // int start address
cyberjoey 9:36ba3626aab7 757 // int number of bytes to read, not including CRC bytes
cyberjoey 9:36ba3626aab7 758 // char* pointer to save data location
cyberjoey 9:36ba3626aab7 759 // returns 0 if CRC match data
cyberjoey 9:36ba3626aab7 760 // returns -1 if CRC does not match data
cyberjoey 9:36ba3626aab7 761 //
cyberjoey 9:36ba3626aab7 762 // *****************************************************************************
cyberjoey 9:36ba3626aab7 763
cyberjoey 9:36ba3626aab7 764
cyberjoey 9:36ba3626aab7 765
cyberjoey 9:36ba3626aab7 766 int read_OW_register(char *device_ID, int start_add, int n, char *data){
cyberjoey 9:36ba3626aab7 767
cyberjoey 9:36ba3626aab7 768 //int i;
cyberjoey 9:36ba3626aab7 769 //select device
cyberjoey 9:36ba3626aab7 770 OW_reset();
cyberjoey 9:36ba3626aab7 771 OW_match_rom(device_ID);
cyberjoey 9:36ba3626aab7 772 //set start address
cyberjoey 9:36ba3626aab7 773 OW_write_byte(OT07_OW_READ); // send 0x33, OW read register command for OT07
cyberjoey 9:36ba3626aab7 774 OW_write_byte(start_add); // send read register start address
cyberjoey 9:36ba3626aab7 775 OW_write_byte(n-1); // send length of bytes to read (0 -> 1 byte)
cyberjoey 9:36ba3626aab7 776 OW_read_byte(data,n+2); // read n bytes plus 2 byte CRC
cyberjoey 9:36ba3626aab7 777
cyberjoey 9:36ba3626aab7 778 // --- todo ----
cyberjoey 9:36ba3626aab7 779 // calculate CRC of
cyberjoey 9:36ba3626aab7 780 // Command + length + n bytes
cyberjoey 9:36ba3626aab7 781 // compare with last 2 bytes read
cyberjoey 9:36ba3626aab7 782 return 0;
cyberjoey 9:36ba3626aab7 783
cyberjoey 9:36ba3626aab7 784 }//end read_OW_register
cyberjoey 9:36ba3626aab7 785
cyberjoey 9:36ba3626aab7 786 int set_test_mode(char *device_id){
cyberjoey 9:36ba3626aab7 787 char data[4];
cyberjoey 9:36ba3626aab7 788
cyberjoey 9:36ba3626aab7 789 // enter test mode
cyberjoey 9:36ba3626aab7 790 OW_reset();
cyberjoey 9:36ba3626aab7 791 OW_match_rom(device_id); // match ROM
cyberjoey 9:36ba3626aab7 792 OW_write_byte(OT07_OW_WRITE); // device write register command
cyberjoey 9:36ba3626aab7 793 OW_write_byte(0xFF); // device register address
cyberjoey 9:36ba3626aab7 794 OW_write_byte(0x00); // number of bytes to write -1
cyberjoey 9:36ba3626aab7 795 OW_write_byte(0x54); // first half of test mode pass code
cyberjoey 9:36ba3626aab7 796 OW_read_byte(data,2); // read 2 byte CRC
cyberjoey 9:36ba3626aab7 797
cyberjoey 9:36ba3626aab7 798 OW_reset();
cyberjoey 9:36ba3626aab7 799 OW_match_rom(device_id);
cyberjoey 9:36ba3626aab7 800 OW_write_byte(OT07_OW_WRITE); // device write register command
cyberjoey 9:36ba3626aab7 801 OW_write_byte(0xFF); // device register address
cyberjoey 9:36ba3626aab7 802 OW_write_byte(0x00); // number of bytes to write -1
cyberjoey 9:36ba3626aab7 803 OW_write_byte(0x4D); // second half of test mode pass code
cyberjoey 9:36ba3626aab7 804 OW_read_byte(data,2); // read 2 byte CRC
cyberjoey 9:36ba3626aab7 805
cyberjoey 9:36ba3626aab7 806 // set ADC_ENABLED
cyberjoey 9:36ba3626aab7 807 OW_reset();
cyberjoey 9:36ba3626aab7 808 OW_match_rom(device_id);
cyberjoey 9:36ba3626aab7 809 OW_write_byte(OT07_OW_WRITE); // device write register command
cyberjoey 9:36ba3626aab7 810 OW_write_byte(0x81); // device register address
cyberjoey 9:36ba3626aab7 811 OW_write_byte(0x00); // number of bytes to write -1
cyberjoey 9:36ba3626aab7 812 OW_write_byte(0x04); // ADC_ENABLED code
cyberjoey 9:36ba3626aab7 813 OW_read_byte(data,2); // read 2 byte CRC
cyberjoey 9:36ba3626aab7 814
cyberjoey 9:36ba3626aab7 815 OW_reset();
cyberjoey 9:36ba3626aab7 816 OW_match_rom(device_id);
cyberjoey 9:36ba3626aab7 817 OW_write_byte(OT07_OW_WRITE); // device write register command
cyberjoey 9:36ba3626aab7 818 OW_write_byte(0x98); // device register address
cyberjoey 9:36ba3626aab7 819 OW_write_byte(0x05); // number of bytes to write -1
cyberjoey 9:36ba3626aab7 820 OW_write_byte(0x40); // add 98 data 40
cyberjoey 9:36ba3626aab7 821 OW_write_byte(0xD4); // add 99 data D4
cyberjoey 9:36ba3626aab7 822 OW_write_byte(0xE0); // add 9A data E0
cyberjoey 9:36ba3626aab7 823 OW_write_byte(0xB3); // add 9B data B3
cyberjoey 9:36ba3626aab7 824 OW_write_byte(0x09); // add 9C data 09
cyberjoey 9:36ba3626aab7 825 OW_write_byte(0xBA); // add 9D data BA
cyberjoey 9:36ba3626aab7 826 OW_read_byte(data,2); // read 2 byte CRC
cyberjoey 9:36ba3626aab7 827
cyberjoey 9:36ba3626aab7 828
cyberjoey 9:36ba3626aab7 829 //OTP copy
cyberjoey 9:36ba3626aab7 830 OW_reset();
cyberjoey 9:36ba3626aab7 831 OW_match_rom(device_id);
cyberjoey 9:36ba3626aab7 832 OW_write_byte(OT07_OW_WRITE); // device write register command
cyberjoey 9:36ba3626aab7 833 OW_write_byte(0x80); // device register address
cyberjoey 9:36ba3626aab7 834 OW_write_byte(0x00); // number of bytes to write -1
cyberjoey 9:36ba3626aab7 835 OW_write_byte(0x82); //
cyberjoey 9:36ba3626aab7 836 OW_read_byte(data,2); // read 2 byte CRC
cyberjoey 9:36ba3626aab7 837
cyberjoey 9:36ba3626aab7 838 OW_reset();
cyberjoey 9:36ba3626aab7 839 OW_match_rom(device_id);
cyberjoey 9:36ba3626aab7 840 OW_write_byte(OT07_OW_WRITE); // device write register command
cyberjoey 9:36ba3626aab7 841 OW_write_byte(0x80); // device register address
cyberjoey 9:36ba3626aab7 842 OW_write_byte(0x00); // number of bytes to write -1
cyberjoey 9:36ba3626aab7 843 OW_write_byte(0x02); //
cyberjoey 9:36ba3626aab7 844 OW_read_byte(data,2); // read 2 byte CRC
cyberjoey 9:36ba3626aab7 845
cyberjoey 9:36ba3626aab7 846
cyberjoey 9:36ba3626aab7 847 OW_reset();
cyberjoey 9:36ba3626aab7 848 OW_match_rom(device_id);
cyberjoey 9:36ba3626aab7 849 OW_write_byte(OT07_OW_WRITE); // device write register command
cyberjoey 9:36ba3626aab7 850 OW_write_byte(0xFF); // device register address
cyberjoey 9:36ba3626aab7 851 OW_write_byte(0x00); // number of bytes to write -1
cyberjoey 9:36ba3626aab7 852 OW_write_byte(0x00); // exit Test mode
cyberjoey 9:36ba3626aab7 853 OW_read_byte(data,2); // read 2 byte CRC
cyberjoey 9:36ba3626aab7 854 return 0;
cyberjoey 9:36ba3626aab7 855 }// end set_test_mode()
cyberjoey 9:36ba3626aab7 856
cyberjoey 9:36ba3626aab7 857
cyberjoey 9:36ba3626aab7 858
cyberjoey 9:36ba3626aab7 859 // ******************** convert_temperature() ********************************
cyberjoey 9:36ba3626aab7 860 // convert_temperature()
cyberjoey 9:36ba3626aab7 861 // returns 0
cyberjoey 9:36ba3626aab7 862 // dose not block for 0.75 seconds.
cyberjoey 9:36ba3626aab7 863 // *****************************************************************************
cyberjoey 9:36ba3626aab7 864
cyberjoey 9:36ba3626aab7 865 int convert_temperature(){ // convert sent to all OW devices
cyberjoey 9:36ba3626aab7 866
cyberjoey 9:36ba3626aab7 867 char data[8];
cyberjoey 9:36ba3626aab7 868 OW_reset();
cyberjoey 9:36ba3626aab7 869
cyberjoey 9:36ba3626aab7 870 OW_write_byte(OW_SKIP); // send 0xCC, skip rom command
cyberjoey 9:36ba3626aab7 871
cyberjoey 9:36ba3626aab7 872 // activate strong pullup
cyberjoey 9:36ba3626aab7 873 data[0] = WDC; // send 0xD2 Write Device Configuration
cyberjoey 9:36ba3626aab7 874 data[1] = 0xA5; // 1010 0101 b strong and active pullup on
cyberjoey 9:36ba3626aab7 875 i2c.write(DS2484_ADD,data,2,0);
cyberjoey 9:36ba3626aab7 876
cyberjoey 9:36ba3626aab7 877 //convert command
cyberjoey 9:36ba3626aab7 878 OW_write_byte(OT07_OW_CONVERT); // send 0x44, Convert Temperature
cyberjoey 9:36ba3626aab7 879 OW_read_byte(data,2); // read 2 byte CRC
cyberjoey 9:36ba3626aab7 880 return 0;
cyberjoey 9:36ba3626aab7 881 }
cyberjoey 9:36ba3626aab7 882
cyberjoey 9:36ba3626aab7 883
cyberjoey 9:36ba3626aab7 884 // ******************** convert_temperature() ********************************
cyberjoey 9:36ba3626aab7 885 // convert_temperature(char *) takes 8 byte rom_id as input
cyberjoey 9:36ba3626aab7 886 // returns 0
cyberjoey 9:36ba3626aab7 887 // dose not block for 0.75 seconds.
cyberjoey 9:36ba3626aab7 888 // *****************************************************************************
cyberjoey 9:36ba3626aab7 889
cyberjoey 9:36ba3626aab7 890 int convert_temperature(char *device_id){
cyberjoey 9:36ba3626aab7 891
cyberjoey 9:36ba3626aab7 892 char data[8];
cyberjoey 9:36ba3626aab7 893 OW_reset();
cyberjoey 9:36ba3626aab7 894 OW_match_rom(device_id); // send device id
cyberjoey 9:36ba3626aab7 895
cyberjoey 9:36ba3626aab7 896 // activate strong pullup
cyberjoey 9:36ba3626aab7 897 data[0] = WDC; // send 0xD2 Write Device Configuration
cyberjoey 9:36ba3626aab7 898 data[1] = 0xA5; // 1010 0101 b strong and active pullup on
cyberjoey 9:36ba3626aab7 899 i2c.write(DS2484_ADD,data,2,0);
cyberjoey 9:36ba3626aab7 900
cyberjoey 9:36ba3626aab7 901 //convert command
cyberjoey 9:36ba3626aab7 902 OW_write_byte(OT07_OW_CONVERT); // send 0x44, Convert Temperature
cyberjoey 9:36ba3626aab7 903 OW_read_byte(data,2); // read 2 byte CRC
cyberjoey 9:36ba3626aab7 904 return 0;
cyberjoey 9:36ba3626aab7 905 }
cyberjoey 9:36ba3626aab7 906
cyberjoey 9:36ba3626aab7 907 //************************ get_temperature() *********************************
cyberjoey 9:36ba3626aab7 908 // get_temperature(char *) takes 8 byte rom_id as input
cyberjoey 9:36ba3626aab7 909 // returns double temperature in oC
cyberjoey 9:36ba3626aab7 910 //******************************************************************************
cyberjoey 9:36ba3626aab7 911
cyberjoey 9:36ba3626aab7 912 double get_temperature(char *device_id){
cyberjoey 9:36ba3626aab7 913
cyberjoey 9:36ba3626aab7 914 char t[4];
cyberjoey 9:36ba3626aab7 915 double T;
cyberjoey 9:36ba3626aab7 916 int count;
cyberjoey 9:36ba3626aab7 917 // char data[2];
cyberjoey 9:36ba3626aab7 918
cyberjoey 9:36ba3626aab7 919 read_OW_register(device_id,OT07_FIFO_DATA,0x02,t); // Read temperature from FIFO, 2 bytes
cyberjoey 9:36ba3626aab7 920 //calculate temperture from data
cyberjoey 9:36ba3626aab7 921 count = (int)(t[0]*256 + t[1]);
cyberjoey 9:36ba3626aab7 922 if (count >= 32768)count = count - 65536; // 2s comp
cyberjoey 9:36ba3626aab7 923 T = (double)count*0.005;
cyberjoey 9:36ba3626aab7 924
cyberjoey 9:36ba3626aab7 925 return T;
cyberjoey 9:36ba3626aab7 926 }// end get_temperature()
cyberjoey 9:36ba3626aab7 927
cyberjoey 9:36ba3626aab7 928
cyberjoey 10:148da21c297e 929 void write_settings_file(int interval, bool device_logged[MAX_DEVICES])
cyberjoey 10:148da21c297e 930 {
cyberjoey 10:148da21c297e 931 FILE *fp = fopen(settings_file, "w");
cyberjoey 10:148da21c297e 932 if (fp != NULL)
cyberjoey 10:148da21c297e 933 {
cyberjoey 10:148da21c297e 934 fprintf(fp, "i %d\r\n", interval);
cyberjoey 10:148da21c297e 935
cyberjoey 10:148da21c297e 936 fprintf(fp, "d");
cyberjoey 10:148da21c297e 937
cyberjoey 10:148da21c297e 938 for(int i = 0; i < MAX_DEVICES; i++)
cyberjoey 10:148da21c297e 939 {
cyberjoey 10:148da21c297e 940 if(device_logged[i] == true)
cyberjoey 10:148da21c297e 941 {
cyberjoey 10:148da21c297e 942 fprintf(fp," %d", i);
cyberjoey 10:148da21c297e 943 }
cyberjoey 10:148da21c297e 944 }
cyberjoey 10:148da21c297e 945 fprintf(fp,"\r\n");
cyberjoey 10:148da21c297e 946
cyberjoey 10:148da21c297e 947 fclose(fp);
cyberjoey 10:148da21c297e 948 }
cyberjoey 10:148da21c297e 949 return;
cyberjoey 10:148da21c297e 950 }
cyberjoey 10:148da21c297e 951
cyberjoey 10:148da21c297e 952 bool print_settings_file()
cyberjoey 10:148da21c297e 953 {
cyberjoey 10:148da21c297e 954 FILE *fp = fopen(settings_file, "r");
cyberjoey 10:148da21c297e 955 if (fp != NULL)
cyberjoey 10:148da21c297e 956 {
cyberjoey 10:148da21c297e 957 pc.printf("*\r\n");
cyberjoey 10:148da21c297e 958
cyberjoey 10:148da21c297e 959 // Read contents from file
cyberjoey 10:148da21c297e 960 char c = fgetc(fp);
cyberjoey 11:94a7379c0db8 961
cyberjoey 10:148da21c297e 962 while (!feof(fp))
cyberjoey 10:148da21c297e 963 {
cyberjoey 10:148da21c297e 964 pc.printf("%c", c);
cyberjoey 10:148da21c297e 965 c = fgetc(fp);
cyberjoey 10:148da21c297e 966 }
cyberjoey 10:148da21c297e 967
cyberjoey 10:148da21c297e 968 pc.printf("*\r\n");
cyberjoey 10:148da21c297e 969
cyberjoey 10:148da21c297e 970 fclose(fp);
cyberjoey 10:148da21c297e 971 }
cyberjoey 10:148da21c297e 972 else
cyberjoey 10:148da21c297e 973 {
cyberjoey 10:148da21c297e 974 return false;
cyberjoey 10:148da21c297e 975 }
cyberjoey 10:148da21c297e 976 return true;
cyberjoey 10:148da21c297e 977 }
cyberjoey 10:148da21c297e 978
cyberjoey 10:148da21c297e 979 bool print_log_file()
cyberjoey 10:148da21c297e 980 {
cyberjoey 10:148da21c297e 981 FILE *fp = fopen(log_file, "r");
cyberjoey 10:148da21c297e 982 if (fp != NULL)
cyberjoey 10:148da21c297e 983 {
cyberjoey 10:148da21c297e 984 pc.printf("*\r\n");
cyberjoey 10:148da21c297e 985
cyberjoey 10:148da21c297e 986 // Read contents from file
cyberjoey 10:148da21c297e 987 char c = fgetc(fp);
cyberjoey 10:148da21c297e 988 while (!feof(fp))
cyberjoey 10:148da21c297e 989 {
cyberjoey 10:148da21c297e 990 pc.printf("%c", c);
cyberjoey 10:148da21c297e 991 c = fgetc(fp);
cyberjoey 10:148da21c297e 992 }
cyberjoey 10:148da21c297e 993
cyberjoey 10:148da21c297e 994 pc.printf("*\r\n");
cyberjoey 10:148da21c297e 995
cyberjoey 10:148da21c297e 996 fclose(fp);
cyberjoey 10:148da21c297e 997 }
cyberjoey 10:148da21c297e 998 else
cyberjoey 10:148da21c297e 999 {
cyberjoey 10:148da21c297e 1000 return false;
cyberjoey 10:148da21c297e 1001 }
cyberjoey 10:148da21c297e 1002 return true;
cyberjoey 10:148da21c297e 1003 }
cyberjoey 10:148da21c297e 1004
cyberjoey 11:94a7379c0db8 1005 int getline(char **lineptr, int *n, FILE *stream) {
cyberjoey 11:94a7379c0db8 1006 char *bufptr = NULL;
cyberjoey 11:94a7379c0db8 1007 char *p = bufptr;
cyberjoey 11:94a7379c0db8 1008 size_t size;
cyberjoey 11:94a7379c0db8 1009 int c;
cyberjoey 11:94a7379c0db8 1010
cyberjoey 11:94a7379c0db8 1011 if (lineptr == NULL) {
cyberjoey 11:94a7379c0db8 1012 return -1;
cyberjoey 11:94a7379c0db8 1013 }
cyberjoey 11:94a7379c0db8 1014 if (stream == NULL) {
cyberjoey 11:94a7379c0db8 1015 return -1;
cyberjoey 11:94a7379c0db8 1016 }
cyberjoey 11:94a7379c0db8 1017 if (n == NULL) {
cyberjoey 11:94a7379c0db8 1018 return -1;
cyberjoey 11:94a7379c0db8 1019 }
cyberjoey 11:94a7379c0db8 1020 bufptr = *lineptr;
cyberjoey 11:94a7379c0db8 1021 size = *n;
cyberjoey 11:94a7379c0db8 1022
cyberjoey 11:94a7379c0db8 1023 c = fgetc(stream);
cyberjoey 11:94a7379c0db8 1024 if (c == EOF) {
cyberjoey 11:94a7379c0db8 1025 return -1;
cyberjoey 11:94a7379c0db8 1026 }
cyberjoey 11:94a7379c0db8 1027 if (bufptr == NULL) {
cyberjoey 11:94a7379c0db8 1028 bufptr = (char *)malloc(128);
cyberjoey 11:94a7379c0db8 1029 if (bufptr == NULL) {
cyberjoey 11:94a7379c0db8 1030 return -1;
cyberjoey 11:94a7379c0db8 1031 }
cyberjoey 11:94a7379c0db8 1032 size = 128;
cyberjoey 11:94a7379c0db8 1033 }
cyberjoey 11:94a7379c0db8 1034 p = bufptr;
cyberjoey 11:94a7379c0db8 1035 while(c != EOF) {
cyberjoey 11:94a7379c0db8 1036 if ((p - bufptr) > (size - 1)) {
cyberjoey 11:94a7379c0db8 1037 size = size + 128;
cyberjoey 11:94a7379c0db8 1038 bufptr = (char *)realloc(bufptr, size);
cyberjoey 11:94a7379c0db8 1039 if (bufptr == NULL) {
cyberjoey 11:94a7379c0db8 1040 return -1;
cyberjoey 11:94a7379c0db8 1041 }
cyberjoey 11:94a7379c0db8 1042 }
cyberjoey 11:94a7379c0db8 1043 *p++ = c;
cyberjoey 11:94a7379c0db8 1044 if (c == '\n') {
cyberjoey 11:94a7379c0db8 1045 break;
cyberjoey 11:94a7379c0db8 1046 }
cyberjoey 11:94a7379c0db8 1047 c = fgetc(stream);
cyberjoey 11:94a7379c0db8 1048 }
cyberjoey 11:94a7379c0db8 1049
cyberjoey 11:94a7379c0db8 1050 *p++ = '\0';
cyberjoey 11:94a7379c0db8 1051 *lineptr = bufptr;
cyberjoey 11:94a7379c0db8 1052 *n = size;
cyberjoey 11:94a7379c0db8 1053
cyberjoey 11:94a7379c0db8 1054 return p - bufptr - 1;
cyberjoey 11:94a7379c0db8 1055 }
cyberjoey 11:94a7379c0db8 1056
cyberjoey 14:480f2398fe6a 1057 bool print_settings_file_2()
cyberjoey 14:480f2398fe6a 1058 {
cyberjoey 14:480f2398fe6a 1059 char * line = NULL;
cyberjoey 14:480f2398fe6a 1060 int len = 0;
cyberjoey 14:480f2398fe6a 1061
cyberjoey 14:480f2398fe6a 1062 FILE *fp = fopen(settings_file, "r");
cyberjoey 14:480f2398fe6a 1063 if (fp != NULL)
cyberjoey 14:480f2398fe6a 1064 {
cyberjoey 14:480f2398fe6a 1065 pc.printf("*\r\n");
cyberjoey 14:480f2398fe6a 1066
cyberjoey 14:480f2398fe6a 1067 // Read contents from file
cyberjoey 14:480f2398fe6a 1068 while ((getline(&line, &len, fp)) != -1)
cyberjoey 14:480f2398fe6a 1069 {
cyberjoey 14:480f2398fe6a 1070 pc.printf("%s", line);
cyberjoey 14:480f2398fe6a 1071 }
cyberjoey 14:480f2398fe6a 1072 pc.printf("*\r\n");
cyberjoey 14:480f2398fe6a 1073
cyberjoey 14:480f2398fe6a 1074 fclose(fp);
cyberjoey 14:480f2398fe6a 1075 }
cyberjoey 14:480f2398fe6a 1076 else
cyberjoey 14:480f2398fe6a 1077 {
cyberjoey 14:480f2398fe6a 1078 return false;
cyberjoey 14:480f2398fe6a 1079 }
cyberjoey 14:480f2398fe6a 1080 return true;
cyberjoey 14:480f2398fe6a 1081 }
cyberjoey 14:480f2398fe6a 1082
cyberjoey 11:94a7379c0db8 1083 //returns true if settings file exists and is in the proper format
cyberjoey 11:94a7379c0db8 1084 bool apply_settings_file(bool (&logged_devices)[MAX_DEVICES], int& interval)
cyberjoey 11:94a7379c0db8 1085 {
cyberjoey 11:94a7379c0db8 1086
cyberjoey 11:94a7379c0db8 1087 char * line = NULL;
cyberjoey 11:94a7379c0db8 1088 int len = 0;
cyberjoey 11:94a7379c0db8 1089 int line_number = 0;
cyberjoey 11:94a7379c0db8 1090
cyberjoey 11:94a7379c0db8 1091
cyberjoey 11:94a7379c0db8 1092 FILE *fp = fopen("/sd/settings.txt", "r");
cyberjoey 11:94a7379c0db8 1093 if (fp != NULL)
cyberjoey 11:94a7379c0db8 1094 {
cyberjoey 11:94a7379c0db8 1095
cyberjoey 11:94a7379c0db8 1096 //initialize devices to all false;
cyberjoey 11:94a7379c0db8 1097 for(int i = 0; i < MAX_DEVICES; i++)
cyberjoey 11:94a7379c0db8 1098 {
cyberjoey 11:94a7379c0db8 1099 logged_devices[i] = false;
cyberjoey 11:94a7379c0db8 1100 }
cyberjoey 11:94a7379c0db8 1101
cyberjoey 11:94a7379c0db8 1102 // Read contents from file
cyberjoey 11:94a7379c0db8 1103 while ((getline(&line, &len, fp)) != -1)
cyberjoey 11:94a7379c0db8 1104 {
cyberjoey 11:94a7379c0db8 1105 line_number++;
cyberjoey 11:94a7379c0db8 1106
cyberjoey 11:94a7379c0db8 1107 char i = 0;
cyberjoey 11:94a7379c0db8 1108 char c = line[i];
cyberjoey 11:94a7379c0db8 1109 while(c != '\0')
cyberjoey 11:94a7379c0db8 1110 {
cyberjoey 11:94a7379c0db8 1111 int number;
cyberjoey 11:94a7379c0db8 1112 int n;
cyberjoey 11:94a7379c0db8 1113 sscanf((line+i), "%d%n", &number, &n);
cyberjoey 11:94a7379c0db8 1114 if(isdigit(c))
cyberjoey 11:94a7379c0db8 1115 {
cyberjoey 11:94a7379c0db8 1116 if(line_number == 1)
cyberjoey 11:94a7379c0db8 1117 {
cyberjoey 11:94a7379c0db8 1118 interval = number;
cyberjoey 11:94a7379c0db8 1119 }
cyberjoey 11:94a7379c0db8 1120 else if(line_number == 2)
cyberjoey 11:94a7379c0db8 1121 {
cyberjoey 11:94a7379c0db8 1122 logged_devices[number] = true;
cyberjoey 11:94a7379c0db8 1123 }
cyberjoey 11:94a7379c0db8 1124 if(n > 1)
cyberjoey 11:94a7379c0db8 1125 i = i + (n - 1);
cyberjoey 11:94a7379c0db8 1126 }
cyberjoey 11:94a7379c0db8 1127 i++;
cyberjoey 11:94a7379c0db8 1128 c = line[i];
cyberjoey 11:94a7379c0db8 1129 }
cyberjoey 11:94a7379c0db8 1130 }
cyberjoey 11:94a7379c0db8 1131
cyberjoey 11:94a7379c0db8 1132 fclose(fp);
cyberjoey 11:94a7379c0db8 1133 }
cyberjoey 11:94a7379c0db8 1134 else
cyberjoey 11:94a7379c0db8 1135 {
cyberjoey 11:94a7379c0db8 1136 return false;
cyberjoey 11:94a7379c0db8 1137 }
cyberjoey 11:94a7379c0db8 1138
cyberjoey 11:94a7379c0db8 1139 return true;
cyberjoey 11:94a7379c0db8 1140
cyberjoey 11:94a7379c0db8 1141 }
cyberjoey 11:94a7379c0db8 1142
cyberjoey 9:36ba3626aab7 1143 //******************************************************************************
cyberjoey 9:36ba3626aab7 1144 // main()
cyberjoey 9:36ba3626aab7 1145 //******************************************************************************
cyberjoey 9:36ba3626aab7 1146
cyberjoey 9:36ba3626aab7 1147
switches 0:60a522ae2e35 1148 int main()
switches 0:60a522ae2e35 1149 {
cyberjoey 17:401a5bb8d403 1150 OT07_struct OT07[4]; // structure that holds I2C address and ROM_ID
cyberjoey 9:36ba3626aab7 1151 char data[130];
cyberjoey 9:36ba3626aab7 1152 int device_count = 0; // number of OW devices found by search_rom()
cyberjoey 9:36ba3626aab7 1153 int i;
cyberjoey 9:36ba3626aab7 1154 int j;
cyberjoey 9:36ba3626aab7 1155 int k;
cyberjoey 9:36ba3626aab7 1156
cyberjoey 9:36ba3626aab7 1157
cyberjoey 9:36ba3626aab7 1158 char device_id[ID_LENGTH]; //8 byte rom id of current slected device
cyberjoey 9:36ba3626aab7 1159 char rom_id_list[MAX_DEVICES][ID_LENGTH]; //List of rom id for each device on OW bus
cyberjoey 9:36ba3626aab7 1160
cyberjoey 9:36ba3626aab7 1161 double T[MAX_DEVICES];
cyberjoey 9:36ba3626aab7 1162
cyberjoey 10:148da21c297e 1163 bool device_logged[MAX_DEVICES];
cyberjoey 11:94a7379c0db8 1164 //initialize device_logged to all false;
cyberjoey 11:94a7379c0db8 1165 for(int i = 0; i < MAX_DEVICES; i++)
cyberjoey 11:94a7379c0db8 1166 {
cyberjoey 11:94a7379c0db8 1167 device_logged[i] = false;
cyberjoey 11:94a7379c0db8 1168 }
cyberjoey 10:148da21c297e 1169
cyberjoey 9:36ba3626aab7 1170 // i/o variables
cyberjoey 9:36ba3626aab7 1171 char rx_buff[128]; // comport input buffer
cyberjoey 9:36ba3626aab7 1172 int rx_index; // rx_buffer pointer
cyberjoey 9:36ba3626aab7 1173 char c; // command type character
cyberjoey 9:36ba3626aab7 1174 int n; // argument count
cyberjoey 9:36ba3626aab7 1175 int arg1; // argumnet 1
cyberjoey 9:36ba3626aab7 1176 int arg2; // argument 2
cyberjoey 9:36ba3626aab7 1177 int device; // device argument
cyberjoey 9:36ba3626aab7 1178 int num_bytes;
cyberjoey 9:36ba3626aab7 1179
cyberjoey 9:36ba3626aab7 1180 int time_count;
cyberjoey 9:36ba3626aab7 1181 int log_interval = PERIOD;
cyberjoey 9:36ba3626aab7 1182 int time_to_sample;
cyberjoey 9:36ba3626aab7 1183
cyberjoey 11:94a7379c0db8 1184 apply_settings_file(device_logged, log_interval);
cyberjoey 11:94a7379c0db8 1185
cyberjoey 9:36ba3626aab7 1186 //************* init ticker timer callbacks ****************
cyberjoey 12:aa9fff0aec91 1187 timer_1.attach(&LED_blink_callback,0.5); //start ticker, once per sec.
cyberjoey 9:36ba3626aab7 1188
cyberjoey 9:36ba3626aab7 1189
cyberjoey 12:aa9fff0aec91 1190 i2c.frequency(400000); //set I2C clock to 400kHz
cyberjoey 9:36ba3626aab7 1191
cyberjoey 9:36ba3626aab7 1192 rLED = LED_OFF;
switches 6:96d8d823e292 1193 gLED = LED_ON;
cyberjoey 9:36ba3626aab7 1194 bLED = LED_ON;
cyberjoey 9:36ba3626aab7 1195
cyberjoey 9:36ba3626aab7 1196
cyberjoey 9:36ba3626aab7 1197 // reset DS2484
cyberjoey 17:401a5bb8d403 1198 //data[0] = 0xE1;
cyberjoey 17:401a5bb8d403 1199 //data[1] = 0xF0;
cyberjoey 17:401a5bb8d403 1200 //i2c.write(DS2484_ADD,data,1,1);
cyberjoey 17:401a5bb8d403 1201 //i2c.read(DS2484_ADD,data,1);
cyberjoey 9:36ba3626aab7 1202
cyberjoey 9:36ba3626aab7 1203 // ****************** search for all OW devices on bus *****************
cyberjoey 9:36ba3626aab7 1204
cyberjoey 17:401a5bb8d403 1205 //device_count = search_rom(rom_id_list);
cyberjoey 17:401a5bb8d403 1206 device_count = search_I2C_bus(OT07);
cyberjoey 9:36ba3626aab7 1207
cyberjoey 17:401a5bb8d403 1208 /*for(j=0;j<device_count;j++){
cyberjoey 9:36ba3626aab7 1209 for(k=0;k<8;k++){
cyberjoey 9:36ba3626aab7 1210 device_id[k] = rom_id_list[j][k]; // get device_id from rom_id_list
cyberjoey 9:36ba3626aab7 1211 }
cyberjoey 9:36ba3626aab7 1212 set_test_mode(device_id);
cyberjoey 17:401a5bb8d403 1213 }*/
cyberjoey 9:36ba3626aab7 1214
cyberjoey 9:36ba3626aab7 1215
cyberjoey 9:36ba3626aab7 1216 rx_index = 0; //character buffer index for input from PC
cyberjoey 9:36ba3626aab7 1217
cyberjoey 9:36ba3626aab7 1218 button.fall(&btn_pressed);
cyberjoey 11:94a7379c0db8 1219 SDInsert.fall(&sd_insert);
cyberjoey 11:94a7379c0db8 1220
cyberjoey 11:94a7379c0db8 1221 sd.disk_initialize(); //initialize sd card
cyberjoey 9:36ba3626aab7 1222
cyberjoey 9:36ba3626aab7 1223 while(1) { // start main loop, take data if logging, check for input, repeat
cyberjoey 9:36ba3626aab7 1224
cyberjoey 11:94a7379c0db8 1225 if(sd_insert_flag == true)
cyberjoey 11:94a7379c0db8 1226 {
cyberjoey 11:94a7379c0db8 1227 sd.disk_initialize();
cyberjoey 11:94a7379c0db8 1228 sd_insert_flag = false;
cyberjoey 11:94a7379c0db8 1229 }
cyberjoey 11:94a7379c0db8 1230
cyberjoey 9:36ba3626aab7 1231 if(button_flag == true)
cyberjoey 9:36ba3626aab7 1232 {
cyberjoey 9:36ba3626aab7 1233 if(log_flag == false){ //start logging
cyberjoey 9:36ba3626aab7 1234
cyberjoey 9:36ba3626aab7 1235 if(SDDetect)//if SD card not detected
cyberjoey 9:36ba3626aab7 1236 {
cyberjoey 9:36ba3626aab7 1237 error_flag = true;
cyberjoey 9:36ba3626aab7 1238 error_ticks = 6;
cyberjoey 9:36ba3626aab7 1239 log_flag = false;
cyberjoey 9:36ba3626aab7 1240 }
cyberjoey 9:36ba3626aab7 1241 else
cyberjoey 9:36ba3626aab7 1242 {
cyberjoey 11:94a7379c0db8 1243 apply_settings_file(device_logged, log_interval);
cyberjoey 11:94a7379c0db8 1244
cyberjoey 10:148da21c297e 1245 FILE *fp = fopen(log_file, "a");
cyberjoey 9:36ba3626aab7 1246 if (fp != NULL)
cyberjoey 9:36ba3626aab7 1247 {
cyberjoey 17:401a5bb8d403 1248 fprintf(fp,"Device List\r\n");
cyberjoey 17:401a5bb8d403 1249 fprintf(fp,"Device Number, ROM Code\r\n");
cyberjoey 17:401a5bb8d403 1250 for(j=0;j<device_count;j++)
cyberjoey 17:401a5bb8d403 1251 {
cyberjoey 17:401a5bb8d403 1252 if(device_logged[j])
cyberjoey 17:401a5bb8d403 1253 {
cyberjoey 17:401a5bb8d403 1254 fprintf(fp,"%d,0x",j);
cyberjoey 17:401a5bb8d403 1255 for(i=7;i>=0;i--)
cyberjoey 17:401a5bb8d403 1256 {
cyberjoey 17:401a5bb8d403 1257 fprintf(fp,"%02X",rom_id_list[j][i]);
cyberjoey 17:401a5bb8d403 1258 }
cyberjoey 17:401a5bb8d403 1259 fprintf(fp,"\r\n");
cyberjoey 17:401a5bb8d403 1260 }
cyberjoey 17:401a5bb8d403 1261 }
cyberjoey 17:401a5bb8d403 1262
cyberjoey 9:36ba3626aab7 1263 fprintf(fp, "Time(s)");
cyberjoey 9:36ba3626aab7 1264
cyberjoey 9:36ba3626aab7 1265 for(j=0;j<device_count;j++)
cyberjoey 9:36ba3626aab7 1266 {
cyberjoey 11:94a7379c0db8 1267 if(device_logged[j])
cyberjoey 16:2f373d3c8214 1268 fprintf(fp,",Device %d Temperature (C)",j);
cyberjoey 9:36ba3626aab7 1269 }
cyberjoey 9:36ba3626aab7 1270 fprintf(fp,"\r\n");
cyberjoey 9:36ba3626aab7 1271
cyberjoey 9:36ba3626aab7 1272 fclose(fp);
cyberjoey 9:36ba3626aab7 1273 }
cyberjoey 9:36ba3626aab7 1274
cyberjoey 9:36ba3626aab7 1275 time_count = 0;
cyberjoey 9:36ba3626aab7 1276
cyberjoey 9:36ba3626aab7 1277 time_to_sample = 0; // force sample at time = 0;
cyberjoey 9:36ba3626aab7 1278 tick_flag = true; // force sample at time = 0;
cyberjoey 9:36ba3626aab7 1279 log_flag = true;
cyberjoey 9:36ba3626aab7 1280 }
cyberjoey 9:36ba3626aab7 1281 }else{
cyberjoey 9:36ba3626aab7 1282 log_flag = false;
cyberjoey 9:36ba3626aab7 1283 }
cyberjoey 9:36ba3626aab7 1284 button_flag = false;
cyberjoey 9:36ba3626aab7 1285 }
switches 1:90313362ec11 1286
cyberjoey 9:36ba3626aab7 1287 while(tick_flag == false){ //check for input while waiting for next tick
cyberjoey 9:36ba3626aab7 1288
cyberjoey 9:36ba3626aab7 1289 // ----------------------------------------------------------------------------
cyberjoey 9:36ba3626aab7 1290 // test for charater input for USB com port
cyberjoey 9:36ba3626aab7 1291 // ----------------------------------------------------------------------------
cyberjoey 9:36ba3626aab7 1292
cyberjoey 9:36ba3626aab7 1293 //test if PC sent some charaters
cyberjoey 9:36ba3626aab7 1294 while(pc.readable()){ //characters in buffer, get them
cyberjoey 9:36ba3626aab7 1295 rx_buff[rx_index] = pc.getc();
cyberjoey 9:36ba3626aab7 1296
cyberjoey 9:36ba3626aab7 1297 if(rx_buff[rx_index] == CR){
cyberjoey 9:36ba3626aab7 1298 rx_buff[++rx_index] = 0;
cyberjoey 9:36ba3626aab7 1299 rx_index = -1; // because i++ at end of while give i=0 on next loop
cyberjoey 9:36ba3626aab7 1300 device = 0;
cyberjoey 9:36ba3626aab7 1301 arg1 = 0;
cyberjoey 9:36ba3626aab7 1302 arg2 = 0;
cyberjoey 9:36ba3626aab7 1303
cyberjoey 9:36ba3626aab7 1304 n = sscanf(rx_buff, " %c %d %x %x", &c, & device, &arg1, &arg2);
cyberjoey 9:36ba3626aab7 1305 //process input
cyberjoey 9:36ba3626aab7 1306 if(n > 0){//got input so process it
cyberjoey 9:36ba3626aab7 1307 switch(c){
cyberjoey 9:36ba3626aab7 1308 case 'a':
cyberjoey 9:36ba3626aab7 1309 case 'A': // alarm search
cyberjoey 9:36ba3626aab7 1310 // ****************** search for all OW devices with alarm triggered on bus *****************
cyberjoey 17:401a5bb8d403 1311 /*
cyberjoey 9:36ba3626aab7 1312 device_count = alarm_search(rom_id_list);
cyberjoey 9:36ba3626aab7 1313
cyberjoey 9:36ba3626aab7 1314 pc.printf("%d devices:\r\n", device_count);
cyberjoey 9:36ba3626aab7 1315 for(j=0;j<device_count;j++){
cyberjoey 9:36ba3626aab7 1316 pc.printf("device[%02X] rom id[",j);
cyberjoey 9:36ba3626aab7 1317 for(i=7;i>=0;i--){
cyberjoey 9:36ba3626aab7 1318 pc.printf("%02X",rom_id_list[j][i]);
cyberjoey 9:36ba3626aab7 1319 }
cyberjoey 9:36ba3626aab7 1320 pc.printf("]\r\n");
cyberjoey 17:401a5bb8d403 1321 } */
cyberjoey 9:36ba3626aab7 1322 break;
cyberjoey 11:94a7379c0db8 1323 case 'c':
cyberjoey 11:94a7379c0db8 1324 case 'C':
cyberjoey 11:94a7379c0db8 1325 if(!SDDetect)
cyberjoey 11:94a7379c0db8 1326 pc.printf("y\r\n");
cyberjoey 11:94a7379c0db8 1327 else
cyberjoey 11:94a7379c0db8 1328 pc.printf("n\r\n");
cyberjoey 11:94a7379c0db8 1329 break;
cyberjoey 10:148da21c297e 1330 case 'd':
cyberjoey 10:148da21c297e 1331 case 'D':
cyberjoey 10:148da21c297e 1332 if(n==1) // if no device number is given
cyberjoey 10:148da21c297e 1333 {
cyberjoey 10:148da21c297e 1334 //clear device_logged array
cyberjoey 10:148da21c297e 1335 for(int i = 0; i < MAX_DEVICES; i++)
cyberjoey 10:148da21c297e 1336 {
cyberjoey 10:148da21c297e 1337 device_logged[i] = false;
cyberjoey 10:148da21c297e 1338 }
cyberjoey 10:148da21c297e 1339
cyberjoey 10:148da21c297e 1340 write_settings_file(log_interval, device_logged);
cyberjoey 10:148da21c297e 1341 }
cyberjoey 10:148da21c297e 1342 if(n == 2)
cyberjoey 10:148da21c297e 1343 {
cyberjoey 10:148da21c297e 1344 device_logged[device] = true;
cyberjoey 10:148da21c297e 1345 write_settings_file(log_interval, device_logged);
cyberjoey 10:148da21c297e 1346 }
cyberjoey 10:148da21c297e 1347 break;
cyberjoey 9:36ba3626aab7 1348 case 'f':
cyberjoey 9:36ba3626aab7 1349 case 'F': //f is for "flash" for microSD
cyberjoey 12:aa9fff0aec91 1350 if(!SDDetect)
cyberjoey 9:36ba3626aab7 1351 pc.printf("y\r\n");
cyberjoey 9:36ba3626aab7 1352 else
cyberjoey 12:aa9fff0aec91 1353 pc.printf("n\r\n");
cyberjoey 9:36ba3626aab7 1354 break;
cyberjoey 10:148da21c297e 1355 case 'g':
cyberjoey 10:148da21c297e 1356 case 'G':
cyberjoey 10:148da21c297e 1357 //0 means get config, 1 means get log
cyberjoey 10:148da21c297e 1358 if(n == 2)
cyberjoey 10:148da21c297e 1359 {
cyberjoey 10:148da21c297e 1360 bool fileExists = false;
cyberjoey 10:148da21c297e 1361 if(device == 0)//get config
cyberjoey 10:148da21c297e 1362 {
cyberjoey 10:148da21c297e 1363 fileExists = print_settings_file();
cyberjoey 14:480f2398fe6a 1364 //fileExists = print_settings_file_2();
cyberjoey 10:148da21c297e 1365 }
cyberjoey 10:148da21c297e 1366 if(device == 1)//get log
cyberjoey 10:148da21c297e 1367 {
cyberjoey 10:148da21c297e 1368 fileExists = print_log_file();
cyberjoey 10:148da21c297e 1369 }
cyberjoey 10:148da21c297e 1370 if(!fileExists)
cyberjoey 10:148da21c297e 1371 {
cyberjoey 10:148da21c297e 1372 pc.printf("no_file\r\n");
cyberjoey 10:148da21c297e 1373 }
cyberjoey 10:148da21c297e 1374 }
cyberjoey 10:148da21c297e 1375 break;
cyberjoey 9:36ba3626aab7 1376 case 'i':
cyberjoey 9:36ba3626aab7 1377 case 'I': //Set Logging sample intreval in seconds
cyberjoey 9:36ba3626aab7 1378
cyberjoey 9:36ba3626aab7 1379 log_interval = device;
cyberjoey 9:36ba3626aab7 1380 if(log_interval < 1)log_interval = 1;
cyberjoey 10:148da21c297e 1381 if(log_interval > 60)log_interval = 60;
cyberjoey 10:148da21c297e 1382 write_settings_file(log_interval, device_logged);
cyberjoey 9:36ba3626aab7 1383 break;
cyberjoey 9:36ba3626aab7 1384 case 'l':
cyberjoey 17:401a5bb8d403 1385 case 'L':
cyberjoey 17:401a5bb8d403 1386
cyberjoey 17:401a5bb8d403 1387 /*
cyberjoey 17:401a5bb8d403 1388 // Toggle logging
cyberjoey 9:36ba3626aab7 1389
cyberjoey 9:36ba3626aab7 1390 if(log_flag == false){ //start logging
cyberjoey 9:36ba3626aab7 1391 if(SDDetect)//if SD card not detected
cyberjoey 9:36ba3626aab7 1392 {
cyberjoey 9:36ba3626aab7 1393 error_flag = true;
cyberjoey 9:36ba3626aab7 1394 error_ticks = 6;
cyberjoey 9:36ba3626aab7 1395 log_flag = false;
cyberjoey 9:36ba3626aab7 1396 }
cyberjoey 9:36ba3626aab7 1397 else
cyberjoey 9:36ba3626aab7 1398 {
cyberjoey 10:148da21c297e 1399 FILE *fp = fopen(log_file, "a");
cyberjoey 9:36ba3626aab7 1400 if (fp != NULL)
cyberjoey 9:36ba3626aab7 1401 {
cyberjoey 9:36ba3626aab7 1402 fprintf(fp, "Time(s)");
cyberjoey 9:36ba3626aab7 1403
cyberjoey 9:36ba3626aab7 1404 for(j=0;j<device_count;j++)
cyberjoey 9:36ba3626aab7 1405 {
cyberjoey 16:2f373d3c8214 1406 fprintf(fp,",Device %d Temperature (C)",j);
cyberjoey 9:36ba3626aab7 1407 }
cyberjoey 9:36ba3626aab7 1408 fprintf(fp,"\r\n");
cyberjoey 9:36ba3626aab7 1409
cyberjoey 9:36ba3626aab7 1410 fclose(fp);
cyberjoey 9:36ba3626aab7 1411 }
cyberjoey 9:36ba3626aab7 1412
cyberjoey 9:36ba3626aab7 1413 time_count = 0;
cyberjoey 9:36ba3626aab7 1414
cyberjoey 9:36ba3626aab7 1415 time_to_sample = 0; // force sample at time = 0;
cyberjoey 9:36ba3626aab7 1416 tick_flag = true; // force sample at time = 0;
cyberjoey 9:36ba3626aab7 1417 log_flag = true;
cyberjoey 9:36ba3626aab7 1418 }
cyberjoey 9:36ba3626aab7 1419 }else{
cyberjoey 9:36ba3626aab7 1420 //pc.printf("<stop logging>\r\n");
cyberjoey 9:36ba3626aab7 1421 log_flag = false;
cyberjoey 17:401a5bb8d403 1422 }*/
cyberjoey 9:36ba3626aab7 1423 break;
cyberjoey 9:36ba3626aab7 1424 case 'P':
cyberjoey 9:36ba3626aab7 1425 case 'p': // power down One Wire buss
cyberjoey 17:401a5bb8d403 1426 /*if(n == 2){
cyberjoey 9:36ba3626aab7 1427 if (device == 0){ // power down mode ON.
cyberjoey 9:36ba3626aab7 1428 data[0] = WDC; // 0xD2 Write Device Config
cyberjoey 9:36ba3626aab7 1429 data[1] = 0xD2; // 1101 0010 set 1WS = 0, SPU = 0, PDN = 1, APU = 0
cyberjoey 9:36ba3626aab7 1430 i2c.write(DS2484_ADD,data,2,0);
cyberjoey 9:36ba3626aab7 1431 pc.printf("<Power down DQ>\r\n");
cyberjoey 9:36ba3626aab7 1432 }else{ // power down mode OFF
cyberjoey 9:36ba3626aab7 1433 data[0] = WDC; // 0xD2 Write Device Config
cyberjoey 9:36ba3626aab7 1434 data[1] = 0xE1; // 1110 0001 set 1WS = 0, SPU = 0, PDN = 0, APU = 1
cyberjoey 9:36ba3626aab7 1435 i2c.write(DS2484_ADD,data,2,0);
cyberjoey 9:36ba3626aab7 1436 pc.printf("<Power up DQ>\r\n");
cyberjoey 9:36ba3626aab7 1437 }
cyberjoey 17:401a5bb8d403 1438 }*/
cyberjoey 9:36ba3626aab7 1439 break;
cyberjoey 9:36ba3626aab7 1440 case 'r':
cyberjoey 17:401a5bb8d403 1441 case 'R':
cyberjoey 17:401a5bb8d403 1442 //read register "r device radd.start radd.end"
cyberjoey 9:36ba3626aab7 1443 if(n==3){ //read single register from selected device
cyberjoey 17:401a5bb8d403 1444 OT07_read_register(OT07[device].I2C_address,arg1,data,1);
cyberjoey 17:401a5bb8d403 1445 pc.printf("device[%02X] add[%02X] data[%02X] crc[FF FF]\r\n",device,arg1,data[0]);
cyberjoey 9:36ba3626aab7 1446 }
cyberjoey 9:36ba3626aab7 1447 if(n==4){ //read a range of regesters from selected device
cyberjoey 9:36ba3626aab7 1448 num_bytes = arg2-arg1 + 1; // calculate number of bytes to read
cyberjoey 9:36ba3626aab7 1449 if (num_bytes < 1) num_bytes = 1; // if arg2 <= arg 1 just read arg1 address.
cyberjoey 17:401a5bb8d403 1450 OT07_read_register(OT07[device].I2C_address,arg1,data,num_bytes);
cyberjoey 9:36ba3626aab7 1451 for(i=0;i<num_bytes;i++){
cyberjoey 9:36ba3626aab7 1452 pc.printf("\r\ndevice[%02X] add[%02X] data[%02X]",device,arg1+i,data[i]);
cyberjoey 17:401a5bb8d403 1453 }
cyberjoey 9:36ba3626aab7 1454 }
cyberjoey 9:36ba3626aab7 1455 break;
cyberjoey 9:36ba3626aab7 1456
cyberjoey 9:36ba3626aab7 1457 case 's':
cyberjoey 9:36ba3626aab7 1458 case 'S': // search rom
cyberjoey 17:401a5bb8d403 1459 // ****************** search for I2C devices on bus *****************
cyberjoey 17:401a5bb8d403 1460 //NOTE: MUST ADD I2C ADDRESS TODO
cyberjoey 17:401a5bb8d403 1461 device_count = search_I2C_bus(OT07);
cyberjoey 9:36ba3626aab7 1462 pc.printf("%d devices:\r\n", device_count);
cyberjoey 9:36ba3626aab7 1463 for(j=0;j<device_count;j++){
cyberjoey 9:36ba3626aab7 1464 pc.printf("device[%02X] rom id[",j);
cyberjoey 9:36ba3626aab7 1465 for(i=7;i>=0;i--){
cyberjoey 17:401a5bb8d403 1466 pc.printf("%02X",OT07[j].rom_id[i]);
cyberjoey 9:36ba3626aab7 1467 }
cyberjoey 9:36ba3626aab7 1468 pc.printf("]\r\n");
cyberjoey 13:674c647d12dd 1469 }
cyberjoey 17:401a5bb8d403 1470
cyberjoey 9:36ba3626aab7 1471 break;
cyberjoey 9:36ba3626aab7 1472
cyberjoey 9:36ba3626aab7 1473 case 'T':
cyberjoey 9:36ba3626aab7 1474 case 't':
cyberjoey 9:36ba3626aab7 1475 if(n == 2){//get temperatures from selected device
cyberjoey 9:36ba3626aab7 1476 for(k=0;k<8;k++){
cyberjoey 9:36ba3626aab7 1477 device_id[k] = rom_id_list[device][k]; // get device_id from rom_id_list
cyberjoey 9:36ba3626aab7 1478 }
cyberjoey 9:36ba3626aab7 1479 convert_temperature(device_id); //send OW convert selected device
cyberjoey 9:36ba3626aab7 1480 wait(0.02); //wait 20 ms for convert temperature to complete
cyberjoey 9:36ba3626aab7 1481 T[0] = get_temperature(device_id);
cyberjoey 13:674c647d12dd 1482 pc.printf("device[%02X] temperature[%.3f]\r\n",device,T[0]);
cyberjoey 9:36ba3626aab7 1483 }
cyberjoey 9:36ba3626aab7 1484 if(n == 3){ // "t 1 5" get temperature for devices 1 thru 5
cyberjoey 9:36ba3626aab7 1485
cyberjoey 9:36ba3626aab7 1486 convert_temperature(); //send OW convert to all devices
cyberjoey 9:36ba3626aab7 1487 wait(0.02); //wait 750 ms for convert temperature to complete
cyberjoey 9:36ba3626aab7 1488 for(j=device;j<=arg1;j++){
cyberjoey 9:36ba3626aab7 1489 for(k=0;k<8;k++){
cyberjoey 9:36ba3626aab7 1490 device_id[k] = rom_id_list[j][k]; // get device_id from rom_id_list
cyberjoey 9:36ba3626aab7 1491 }
cyberjoey 9:36ba3626aab7 1492 pc.printf("device[%02X] temperature[%.3f]\r\n",j,get_temperature(device_id));
cyberjoey 13:674c647d12dd 1493 }
cyberjoey 9:36ba3626aab7 1494 }
cyberjoey 17:401a5bb8d403 1495
cyberjoey 17:401a5bb8d403 1496
cyberjoey 17:401a5bb8d403 1497 if(n == 2){//get temperatures from selected device
cyberjoey 17:401a5bb8d403 1498
cyberjoey 17:401a5bb8d403 1499 convert_temperature(OT07[device].I2C_address); //send OW convert selected device
cyberjoey 17:401a5bb8d403 1500 wait(0.02); //wait 20 ms for convert temperature to complete
cyberjoey 17:401a5bb8d403 1501 T[device] = get_temperature(OT07[device].I2C_address);
cyberjoey 17:401a5bb8d403 1502 pc.printf("device[%02X] temperature[%.3f]\r\n",device,T[device]);
cyberjoey 17:401a5bb8d403 1503 }
cyberjoey 17:401a5bb8d403 1504
cyberjoey 17:401a5bb8d403 1505 if(n == 3){ // "t 1 3" get temperature for devices 1 thru 3
cyberjoey 17:401a5bb8d403 1506 //sprintf(str,"%x",arg1); //convert arg1 input as hex to decimal i.e. 0x10 becomes 10 dec
cyberjoey 17:401a5bb8d403 1507 //sscanf(str,"%d",&arg1);
cyberjoey 17:401a5bb8d403 1508 //IS THIS NEEDED? ^^^
cyberjoey 17:401a5bb8d403 1509
cyberjoey 17:401a5bb8d403 1510 for(j=device;j<=arg1;j++){
cyberjoey 17:401a5bb8d403 1511 convert_temperature(OT07[j].I2C_address); //send convert to all devices
cyberjoey 17:401a5bb8d403 1512 wait(0.02); //wait 20ms for convert temperature to complete
cyberjoey 17:401a5bb8d403 1513 T[j] = get_temperature(OT07[j].I2C_address);
cyberjoey 17:401a5bb8d403 1514 }
cyberjoey 17:401a5bb8d403 1515
cyberjoey 17:401a5bb8d403 1516 for(j=device;j<=arg1;j++){
cyberjoey 17:401a5bb8d403 1517 pc.printf("device[%02X] temperature[%.3f]\r\n",j,T[j]);
cyberjoey 17:401a5bb8d403 1518 }
cyberjoey 17:401a5bb8d403 1519 }
cyberjoey 17:401a5bb8d403 1520
cyberjoey 9:36ba3626aab7 1521 break;
cyberjoey 9:36ba3626aab7 1522
cyberjoey 9:36ba3626aab7 1523 case 'w':
cyberjoey 17:401a5bb8d403 1524 case 'W': //write register "w device w.addr data"
cyberjoey 9:36ba3626aab7 1525
cyberjoey 17:401a5bb8d403 1526 OT07_write_register(OT07[device].I2C_address,arg1, arg2);
cyberjoey 17:401a5bb8d403 1527 pc.printf("write -- device[%02X] add[%02X] data[%02X] crc[FF FF]\r\n",device,arg1,arg2);
cyberjoey 9:36ba3626aab7 1528 break;
cyberjoey 9:36ba3626aab7 1529
cyberjoey 9:36ba3626aab7 1530 case 'x':
cyberjoey 9:36ba3626aab7 1531 case 'X': // experimental modes
cyberjoey 9:36ba3626aab7 1532 // ****************** set up ADC enabled in test mode*****************
cyberjoey 9:36ba3626aab7 1533 pc.printf("<set ADC_ENABLED in test mode>\r\n");
cyberjoey 9:36ba3626aab7 1534
cyberjoey 9:36ba3626aab7 1535 for(j=0;j<device_count;j++){
cyberjoey 9:36ba3626aab7 1536 for(k=0;k<8;k++){
cyberjoey 9:36ba3626aab7 1537 device_id[k] = rom_id_list[j][k]; // get device_id from rom_id_list
cyberjoey 9:36ba3626aab7 1538 }
cyberjoey 9:36ba3626aab7 1539 set_test_mode(device_id);
cyberjoey 9:36ba3626aab7 1540 }
cyberjoey 9:36ba3626aab7 1541 break;
cyberjoey 9:36ba3626aab7 1542
cyberjoey 9:36ba3626aab7 1543
cyberjoey 9:36ba3626aab7 1544 }//end switch(c)
cyberjoey 9:36ba3626aab7 1545 }//if(n>0)
cyberjoey 9:36ba3626aab7 1546 }//end if(CR)
cyberjoey 9:36ba3626aab7 1547 if(rx_buff[rx_index] == BS){//backspace received, back up buffer pointer
cyberjoey 9:36ba3626aab7 1548 if(rx_index>0)rx_index--;//remove last char from buffer if not at start.
cyberjoey 9:36ba3626aab7 1549 }else rx_index++;
cyberjoey 9:36ba3626aab7 1550 }//end while(pc.redable())
cyberjoey 9:36ba3626aab7 1551 wait(0.1); // slow down polling
switches 0:60a522ae2e35 1552
cyberjoey 9:36ba3626aab7 1553 }// end (while tick == false)
cyberjoey 9:36ba3626aab7 1554 tick_flag = false; // set to false for next time
cyberjoey 9:36ba3626aab7 1555
cyberjoey 9:36ba3626aab7 1556 // only reached when tick_flag = true otherwise stuck in pc.readable() loop
cyberjoey 13:674c647d12dd 1557 if(log_flag == true){
cyberjoey 9:36ba3626aab7 1558 if(time_count >= time_to_sample){ //take next sample
cyberjoey 9:36ba3626aab7 1559 time_to_sample += log_interval; // calculate time for next sample
cyberjoey 9:36ba3626aab7 1560
cyberjoey 9:36ba3626aab7 1561 // start conversion
cyberjoey 9:36ba3626aab7 1562 convert_temperature();
cyberjoey 9:36ba3626aab7 1563 wait(0.02); //wait 20ms for convert to complete
cyberjoey 9:36ba3626aab7 1564 for(j=0;j<device_count;j++){
cyberjoey 9:36ba3626aab7 1565 for(k=0;k<8;k++){
cyberjoey 9:36ba3626aab7 1566 device_id[k] = rom_id_list[j][k]; // get device_id from rom_id_list
cyberjoey 9:36ba3626aab7 1567 }
cyberjoey 9:36ba3626aab7 1568 T[j] = get_temperature(device_id);
cyberjoey 9:36ba3626aab7 1569 }
cyberjoey 13:674c647d12dd 1570
cyberjoey 13:674c647d12dd 1571 //open file for microSD logging
cyberjoey 10:148da21c297e 1572 FILE *fp = fopen(log_file, "a");
cyberjoey 9:36ba3626aab7 1573 if (fp != NULL)
cyberjoey 9:36ba3626aab7 1574 {
cyberjoey 9:36ba3626aab7 1575 //fprintf(fp, "\n");
cyberjoey 10:148da21c297e 1576 fprintf(fp, "%d",time_count);
cyberjoey 9:36ba3626aab7 1577 for(j=0;j<device_count;j++)
cyberjoey 9:36ba3626aab7 1578 {
cyberjoey 11:94a7379c0db8 1579 if(device_logged[j])
cyberjoey 11:94a7379c0db8 1580 {
cyberjoey 16:2f373d3c8214 1581 fprintf(fp,",%.3f",T[j]);
cyberjoey 11:94a7379c0db8 1582 }
cyberjoey 11:94a7379c0db8 1583
cyberjoey 9:36ba3626aab7 1584 }
cyberjoey 9:36ba3626aab7 1585 fprintf(fp,"\r\n");
cyberjoey 9:36ba3626aab7 1586
cyberjoey 9:36ba3626aab7 1587 fclose(fp);
cyberjoey 9:36ba3626aab7 1588 }
cyberjoey 9:36ba3626aab7 1589 }// end if(time_count >= time_to_sample)
cyberjoey 9:36ba3626aab7 1590 time_count ++; //
cyberjoey 9:36ba3626aab7 1591
cyberjoey 9:36ba3626aab7 1592 }// end if(log_flag)
cyberjoey 9:36ba3626aab7 1593
cyberjoey 9:36ba3626aab7 1594 }//end while(1)
switches 0:60a522ae2e35 1595 }