This is used for sending Data to receiving mDot
Dependencies: libmDot-dev-mbed5-deprecated ISL29011
Fork of mdot-examples by
send_main.cpp@27:5db200a4d496, 2018-04-01 (annotated)
- Committer:
- SDesign2018
- Date:
- Sun Apr 01 21:32:06 2018 +0000
- Revision:
- 27:5db200a4d496
- Parent:
- 26:15df8f054d11
- Child:
- 28:29702434319d
dot->sleep replaces the ticker class from mbed; It works
Who changed what in which revision?
User | Revision | Line number | New contents of line |
---|---|---|---|
SDesign2018 | 26:15df8f054d11 | 1 | /* |
SDesign2018 | 26:15df8f054d11 | 2 | 3/27/2018 mdot version = 3.0.2, mbed version = 5.5.7 WORKS |
SDesign2018 | 26:15df8f054d11 | 3 | 3/27/2018 mdot version = 3.1.0, mbed version = 5.7.4 WORKS |
SDesign2018 | 26:15df8f054d11 | 4 | */ |
SDesign2018 | 26:15df8f054d11 | 5 | |
SDesign2018 | 26:15df8f054d11 | 6 | #include <stdlib.h> |
SDesign2018 | 26:15df8f054d11 | 7 | #include <iostream> |
SDesign2018 | 26:15df8f054d11 | 8 | #include <string.h> |
SDesign2018 | 26:15df8f054d11 | 9 | #include <mbed.h> |
SDesign2018 | 27:5db200a4d496 | 10 | #include "mDot.h" |
SDesign2018 | 26:15df8f054d11 | 11 | #include "dot_util.h" |
SDesign2018 | 26:15df8f054d11 | 12 | #include "RadioEvent.h" |
SDesign2018 | 26:15df8f054d11 | 13 | #include "itoa.h" |
SDesign2018 | 26:15df8f054d11 | 14 | |
SDesign2018 | 26:15df8f054d11 | 15 | #define BUFFER_SIZE 10 |
SDesign2018 | 26:15df8f054d11 | 16 | |
SDesign2018 | 26:15df8f054d11 | 17 | //note: added GPS functions , variables below (will organize better later ski |
SDesign2018 | 26:15df8f054d11 | 18 | //and gps code in main is noted |
SDesign2018 | 26:15df8f054d11 | 19 | |
SDesign2018 | 26:15df8f054d11 | 20 | |
SDesign2018 | 26:15df8f054d11 | 21 | |
SDesign2018 | 26:15df8f054d11 | 22 | ///-----------------FOR GPS------BELOW---------------------------------- |
SDesign2018 | 26:15df8f054d11 | 23 | // |
SDesign2018 | 26:15df8f054d11 | 24 | |
SDesign2018 | 26:15df8f054d11 | 25 | #include "MBed_Adafruit_GPS.h" |
SDesign2018 | 26:15df8f054d11 | 26 | |
SDesign2018 | 26:15df8f054d11 | 27 | |
SDesign2018 | 26:15df8f054d11 | 28 | Serial * gps_Serial = new Serial(PA_2,PA_3); |
SDesign2018 | 26:15df8f054d11 | 29 | //Initalize using pa2 and pa3 (D0 and D1 on the mdot) (D0->TX on gps) (D1->RX on gps) |
SDesign2018 | 26:15df8f054d11 | 30 | //gps_Serial = new Serial(PA_2,PA_3); //serial object for use w/ GPS USING PA_2 and PA_3 |
SDesign2018 | 26:15df8f054d11 | 31 | Adafruit_GPS myGPS(gps_Serial); //object of Adafruit's GPS class |
SDesign2018 | 26:15df8f054d11 | 32 | char c; //when read via Adafruit_GPS::read(), the class returns single character stored here |
SDesign2018 | 26:15df8f054d11 | 33 | Timer refresh_Timer; //sets up a timer for use in loop; how often do we print GPS info? |
SDesign2018 | 26:15df8f054d11 | 34 | const int refresh_Time = 2000; //refresh time in ms |
SDesign2018 | 26:15df8f054d11 | 35 | |
SDesign2018 | 26:15df8f054d11 | 36 | |
SDesign2018 | 26:15df8f054d11 | 37 | |
SDesign2018 | 26:15df8f054d11 | 38 | // how long are max NMEA lines to parse? |
SDesign2018 | 26:15df8f054d11 | 39 | #define MAXLINELENGTH 120 |
SDesign2018 | 26:15df8f054d11 | 40 | |
SDesign2018 | 26:15df8f054d11 | 41 | // we double buffer: read one line in and leave one for the main program |
SDesign2018 | 26:15df8f054d11 | 42 | volatile char line1[MAXLINELENGTH]; |
SDesign2018 | 26:15df8f054d11 | 43 | volatile char line2[MAXLINELENGTH]; |
SDesign2018 | 26:15df8f054d11 | 44 | // our index into filling the current line |
SDesign2018 | 26:15df8f054d11 | 45 | volatile uint16_t lineidx=0; |
SDesign2018 | 26:15df8f054d11 | 46 | // pointers to the double buffers |
SDesign2018 | 26:15df8f054d11 | 47 | volatile char *currentline; |
SDesign2018 | 26:15df8f054d11 | 48 | volatile char *lastline; |
SDesign2018 | 26:15df8f054d11 | 49 | volatile bool recvdflag; |
SDesign2018 | 26:15df8f054d11 | 50 | volatile bool inStandbyMode; |
SDesign2018 | 26:15df8f054d11 | 51 | |
SDesign2018 | 26:15df8f054d11 | 52 | |
SDesign2018 | 26:15df8f054d11 | 53 | |
SDesign2018 | 26:15df8f054d11 | 54 | |
SDesign2018 | 26:15df8f054d11 | 55 | bool Adafruit_GPS::parse(char *nmea) { |
SDesign2018 | 26:15df8f054d11 | 56 | // do checksum check |
SDesign2018 | 26:15df8f054d11 | 57 | |
SDesign2018 | 26:15df8f054d11 | 58 | // first look if we even have one |
SDesign2018 | 26:15df8f054d11 | 59 | if (nmea[strlen(nmea)-4] == '*') { |
SDesign2018 | 26:15df8f054d11 | 60 | uint16_t sum = parseHex(nmea[strlen(nmea)-3]) * 16; |
SDesign2018 | 26:15df8f054d11 | 61 | sum += parseHex(nmea[strlen(nmea)-2]); |
SDesign2018 | 26:15df8f054d11 | 62 | |
SDesign2018 | 26:15df8f054d11 | 63 | // check checksum |
SDesign2018 | 26:15df8f054d11 | 64 | for (uint8_t i=1; i < (strlen(nmea)-4); i++) { |
SDesign2018 | 26:15df8f054d11 | 65 | sum ^= nmea[i]; |
SDesign2018 | 26:15df8f054d11 | 66 | } |
SDesign2018 | 26:15df8f054d11 | 67 | if (sum != 0) { |
SDesign2018 | 26:15df8f054d11 | 68 | // bad checksum :( |
SDesign2018 | 26:15df8f054d11 | 69 | //return false; |
SDesign2018 | 26:15df8f054d11 | 70 | } |
SDesign2018 | 26:15df8f054d11 | 71 | } |
SDesign2018 | 26:15df8f054d11 | 72 | |
SDesign2018 | 26:15df8f054d11 | 73 | // look for a few common sentences |
SDesign2018 | 26:15df8f054d11 | 74 | if (strstr(nmea, "$GPGGA")) { |
SDesign2018 | 26:15df8f054d11 | 75 | // found GGA |
SDesign2018 | 26:15df8f054d11 | 76 | char *p = nmea; |
SDesign2018 | 26:15df8f054d11 | 77 | // get time |
SDesign2018 | 26:15df8f054d11 | 78 | p = strchr(p, ',')+1; |
SDesign2018 | 26:15df8f054d11 | 79 | float timef = atof(p); |
SDesign2018 | 26:15df8f054d11 | 80 | uint32_t time = timef; |
SDesign2018 | 26:15df8f054d11 | 81 | hour = time / 10000; |
SDesign2018 | 26:15df8f054d11 | 82 | minute = (time % 10000) / 100; |
SDesign2018 | 26:15df8f054d11 | 83 | seconds = (time % 100); |
SDesign2018 | 26:15df8f054d11 | 84 | |
SDesign2018 | 26:15df8f054d11 | 85 | milliseconds = fmod((double) timef, 1.0) * 1000; |
SDesign2018 | 26:15df8f054d11 | 86 | |
SDesign2018 | 26:15df8f054d11 | 87 | // parse out latitude |
SDesign2018 | 26:15df8f054d11 | 88 | p = strchr(p, ',')+1; |
SDesign2018 | 26:15df8f054d11 | 89 | latitude = atof(p); |
SDesign2018 | 26:15df8f054d11 | 90 | |
SDesign2018 | 26:15df8f054d11 | 91 | p = strchr(p, ',')+1; |
SDesign2018 | 26:15df8f054d11 | 92 | if (p[0] == 'N') lat = 'N'; |
SDesign2018 | 26:15df8f054d11 | 93 | else if (p[0] == 'S') lat = 'S'; |
SDesign2018 | 26:15df8f054d11 | 94 | else if (p[0] == ',') lat = 0; |
SDesign2018 | 26:15df8f054d11 | 95 | else return false; |
SDesign2018 | 26:15df8f054d11 | 96 | |
SDesign2018 | 26:15df8f054d11 | 97 | // parse out longitude |
SDesign2018 | 26:15df8f054d11 | 98 | p = strchr(p, ',')+1; |
SDesign2018 | 26:15df8f054d11 | 99 | longitude = atof(p); |
SDesign2018 | 26:15df8f054d11 | 100 | |
SDesign2018 | 26:15df8f054d11 | 101 | p = strchr(p, ',')+1; |
SDesign2018 | 26:15df8f054d11 | 102 | if (p[0] == 'W') lon = 'W'; |
SDesign2018 | 26:15df8f054d11 | 103 | else if (p[0] == 'E') lon = 'E'; |
SDesign2018 | 26:15df8f054d11 | 104 | else if (p[0] == ',') lon = 0; |
SDesign2018 | 26:15df8f054d11 | 105 | else return false; |
SDesign2018 | 26:15df8f054d11 | 106 | |
SDesign2018 | 26:15df8f054d11 | 107 | p = strchr(p, ',')+1; |
SDesign2018 | 26:15df8f054d11 | 108 | fixquality = atoi(p); |
SDesign2018 | 26:15df8f054d11 | 109 | |
SDesign2018 | 26:15df8f054d11 | 110 | p = strchr(p, ',')+1; |
SDesign2018 | 26:15df8f054d11 | 111 | satellites = atoi(p); |
SDesign2018 | 26:15df8f054d11 | 112 | |
SDesign2018 | 26:15df8f054d11 | 113 | p = strchr(p, ',')+1; |
SDesign2018 | 26:15df8f054d11 | 114 | HDOP = atof(p); |
SDesign2018 | 26:15df8f054d11 | 115 | |
SDesign2018 | 26:15df8f054d11 | 116 | p = strchr(p, ',')+1; |
SDesign2018 | 26:15df8f054d11 | 117 | altitude = atof(p); |
SDesign2018 | 26:15df8f054d11 | 118 | p = strchr(p, ',')+1; |
SDesign2018 | 26:15df8f054d11 | 119 | p = strchr(p, ',')+1; |
SDesign2018 | 26:15df8f054d11 | 120 | geoidheight = atof(p); |
SDesign2018 | 26:15df8f054d11 | 121 | return true; |
SDesign2018 | 26:15df8f054d11 | 122 | } |
SDesign2018 | 26:15df8f054d11 | 123 | if (strstr(nmea, "$GPRMC")) { |
SDesign2018 | 26:15df8f054d11 | 124 | // found RMC |
SDesign2018 | 26:15df8f054d11 | 125 | char *p = nmea; |
SDesign2018 | 26:15df8f054d11 | 126 | |
SDesign2018 | 26:15df8f054d11 | 127 | // get time |
SDesign2018 | 26:15df8f054d11 | 128 | p = strchr(p, ',')+1; |
SDesign2018 | 26:15df8f054d11 | 129 | float timef = atof(p); |
SDesign2018 | 26:15df8f054d11 | 130 | uint32_t time = timef; |
SDesign2018 | 26:15df8f054d11 | 131 | hour = time / 10000; |
SDesign2018 | 26:15df8f054d11 | 132 | minute = (time % 10000) / 100; |
SDesign2018 | 26:15df8f054d11 | 133 | seconds = (time % 100); |
SDesign2018 | 26:15df8f054d11 | 134 | |
SDesign2018 | 26:15df8f054d11 | 135 | milliseconds = fmod((double) timef, 1.0) * 1000; |
SDesign2018 | 26:15df8f054d11 | 136 | |
SDesign2018 | 26:15df8f054d11 | 137 | p = strchr(p, ',')+1; |
SDesign2018 | 26:15df8f054d11 | 138 | // Serial.println(p); |
SDesign2018 | 26:15df8f054d11 | 139 | if (p[0] == 'A') |
SDesign2018 | 26:15df8f054d11 | 140 | fix = true; |
SDesign2018 | 26:15df8f054d11 | 141 | else if (p[0] == 'V') |
SDesign2018 | 26:15df8f054d11 | 142 | fix = false; |
SDesign2018 | 26:15df8f054d11 | 143 | else |
SDesign2018 | 26:15df8f054d11 | 144 | return false; |
SDesign2018 | 26:15df8f054d11 | 145 | |
SDesign2018 | 26:15df8f054d11 | 146 | // parse out latitude |
SDesign2018 | 26:15df8f054d11 | 147 | p = strchr(p, ',')+1; |
SDesign2018 | 26:15df8f054d11 | 148 | latitude = atof(p); |
SDesign2018 | 26:15df8f054d11 | 149 | |
SDesign2018 | 26:15df8f054d11 | 150 | p = strchr(p, ',')+1; |
SDesign2018 | 26:15df8f054d11 | 151 | if (p[0] == 'N') lat = 'N'; |
SDesign2018 | 26:15df8f054d11 | 152 | else if (p[0] == 'S') lat = 'S'; |
SDesign2018 | 26:15df8f054d11 | 153 | else if (p[0] == ',') lat = 0; |
SDesign2018 | 26:15df8f054d11 | 154 | else return false; |
SDesign2018 | 26:15df8f054d11 | 155 | |
SDesign2018 | 26:15df8f054d11 | 156 | // parse out longitude |
SDesign2018 | 26:15df8f054d11 | 157 | p = strchr(p, ',')+1; |
SDesign2018 | 26:15df8f054d11 | 158 | longitude = atof(p); |
SDesign2018 | 26:15df8f054d11 | 159 | |
SDesign2018 | 26:15df8f054d11 | 160 | p = strchr(p, ',')+1; |
SDesign2018 | 26:15df8f054d11 | 161 | if (p[0] == 'W') lon = 'W'; |
SDesign2018 | 26:15df8f054d11 | 162 | else if (p[0] == 'E') lon = 'E'; |
SDesign2018 | 26:15df8f054d11 | 163 | else if (p[0] == ',') lon = 0; |
SDesign2018 | 26:15df8f054d11 | 164 | else return false; |
SDesign2018 | 26:15df8f054d11 | 165 | |
SDesign2018 | 26:15df8f054d11 | 166 | // speed |
SDesign2018 | 26:15df8f054d11 | 167 | p = strchr(p, ',')+1; |
SDesign2018 | 26:15df8f054d11 | 168 | speed = atof(p); |
SDesign2018 | 26:15df8f054d11 | 169 | |
SDesign2018 | 26:15df8f054d11 | 170 | // angle |
SDesign2018 | 26:15df8f054d11 | 171 | p = strchr(p, ',')+1; |
SDesign2018 | 26:15df8f054d11 | 172 | angle = atof(p); |
SDesign2018 | 26:15df8f054d11 | 173 | |
SDesign2018 | 26:15df8f054d11 | 174 | p = strchr(p, ',')+1; |
SDesign2018 | 26:15df8f054d11 | 175 | uint32_t fulldate = atof(p); |
SDesign2018 | 26:15df8f054d11 | 176 | day = fulldate / 10000; |
SDesign2018 | 26:15df8f054d11 | 177 | month = (fulldate % 10000) / 100; |
SDesign2018 | 26:15df8f054d11 | 178 | year = (fulldate % 100); |
SDesign2018 | 26:15df8f054d11 | 179 | |
SDesign2018 | 26:15df8f054d11 | 180 | // we dont parse the remaining, yet! |
SDesign2018 | 26:15df8f054d11 | 181 | return true; |
SDesign2018 | 26:15df8f054d11 | 182 | } |
SDesign2018 | 26:15df8f054d11 | 183 | |
SDesign2018 | 26:15df8f054d11 | 184 | return false; |
SDesign2018 | 26:15df8f054d11 | 185 | } |
SDesign2018 | 26:15df8f054d11 | 186 | |
SDesign2018 | 26:15df8f054d11 | 187 | char Adafruit_GPS::read(void) { |
SDesign2018 | 26:15df8f054d11 | 188 | char c = 0; |
SDesign2018 | 26:15df8f054d11 | 189 | |
SDesign2018 | 26:15df8f054d11 | 190 | if (paused) return c; |
SDesign2018 | 26:15df8f054d11 | 191 | |
SDesign2018 | 26:15df8f054d11 | 192 | if(!gpsSerial->readable()) return c; |
SDesign2018 | 26:15df8f054d11 | 193 | c = gpsSerial->getc(); |
SDesign2018 | 26:15df8f054d11 | 194 | |
SDesign2018 | 26:15df8f054d11 | 195 | //Serial.print(c); |
SDesign2018 | 26:15df8f054d11 | 196 | |
SDesign2018 | 26:15df8f054d11 | 197 | if (c == '$') { |
SDesign2018 | 26:15df8f054d11 | 198 | currentline[lineidx] = 0; |
SDesign2018 | 26:15df8f054d11 | 199 | lineidx = 0; |
SDesign2018 | 26:15df8f054d11 | 200 | } |
SDesign2018 | 26:15df8f054d11 | 201 | if (c == '\n') { |
SDesign2018 | 26:15df8f054d11 | 202 | currentline[lineidx] = 0; |
SDesign2018 | 26:15df8f054d11 | 203 | |
SDesign2018 | 26:15df8f054d11 | 204 | if (currentline == line1) { |
SDesign2018 | 26:15df8f054d11 | 205 | currentline = line2; |
SDesign2018 | 26:15df8f054d11 | 206 | lastline = line1; |
SDesign2018 | 26:15df8f054d11 | 207 | } else { |
SDesign2018 | 26:15df8f054d11 | 208 | currentline = line1; |
SDesign2018 | 26:15df8f054d11 | 209 | lastline = line2; |
SDesign2018 | 26:15df8f054d11 | 210 | } |
SDesign2018 | 26:15df8f054d11 | 211 | |
SDesign2018 | 26:15df8f054d11 | 212 | lineidx = 0; |
SDesign2018 | 26:15df8f054d11 | 213 | recvdflag = true; |
SDesign2018 | 26:15df8f054d11 | 214 | } |
SDesign2018 | 26:15df8f054d11 | 215 | |
SDesign2018 | 26:15df8f054d11 | 216 | currentline[lineidx++] = c; |
SDesign2018 | 26:15df8f054d11 | 217 | if (lineidx >= MAXLINELENGTH) |
SDesign2018 | 26:15df8f054d11 | 218 | lineidx = MAXLINELENGTH-1; |
SDesign2018 | 26:15df8f054d11 | 219 | |
SDesign2018 | 26:15df8f054d11 | 220 | return c; |
SDesign2018 | 26:15df8f054d11 | 221 | } |
SDesign2018 | 26:15df8f054d11 | 222 | |
SDesign2018 | 26:15df8f054d11 | 223 | Adafruit_GPS::Adafruit_GPS (Serial *ser) |
SDesign2018 | 26:15df8f054d11 | 224 | { |
SDesign2018 | 26:15df8f054d11 | 225 | common_init(); // Set everything to common state, then... |
SDesign2018 | 26:15df8f054d11 | 226 | gpsSerial = ser; // ...override gpsSwSerial with value passed. |
SDesign2018 | 26:15df8f054d11 | 227 | } |
SDesign2018 | 26:15df8f054d11 | 228 | |
SDesign2018 | 26:15df8f054d11 | 229 | // Initialization code used by all constructor types |
SDesign2018 | 26:15df8f054d11 | 230 | void Adafruit_GPS::common_init(void) { |
SDesign2018 | 26:15df8f054d11 | 231 | gpsSerial = NULL; |
SDesign2018 | 26:15df8f054d11 | 232 | recvdflag = false; |
SDesign2018 | 26:15df8f054d11 | 233 | paused = false; |
SDesign2018 | 26:15df8f054d11 | 234 | lineidx = 0; |
SDesign2018 | 26:15df8f054d11 | 235 | currentline = line1; |
SDesign2018 | 26:15df8f054d11 | 236 | lastline = line2; |
SDesign2018 | 26:15df8f054d11 | 237 | |
SDesign2018 | 26:15df8f054d11 | 238 | hour = minute = seconds = year = month = day = |
SDesign2018 | 26:15df8f054d11 | 239 | fixquality = satellites = 0; // uint8_t |
SDesign2018 | 26:15df8f054d11 | 240 | lat = lon = mag = 0; // char |
SDesign2018 | 26:15df8f054d11 | 241 | fix = false; // bool |
SDesign2018 | 26:15df8f054d11 | 242 | milliseconds = 0; // uint16_t |
SDesign2018 | 26:15df8f054d11 | 243 | latitude = longitude = geoidheight = altitude = |
SDesign2018 | 26:15df8f054d11 | 244 | speed = angle = magvariation = HDOP = 0.0; // float |
SDesign2018 | 26:15df8f054d11 | 245 | } |
SDesign2018 | 26:15df8f054d11 | 246 | |
SDesign2018 | 26:15df8f054d11 | 247 | void Adafruit_GPS::begin(int baud) |
SDesign2018 | 26:15df8f054d11 | 248 | { |
SDesign2018 | 26:15df8f054d11 | 249 | gpsSerial->baud(baud); |
SDesign2018 | 26:15df8f054d11 | 250 | wait_ms(10); |
SDesign2018 | 26:15df8f054d11 | 251 | } |
SDesign2018 | 26:15df8f054d11 | 252 | |
SDesign2018 | 26:15df8f054d11 | 253 | void Adafruit_GPS::sendCommand(char *str) { |
SDesign2018 | 26:15df8f054d11 | 254 | gpsSerial->printf("%s",str); |
SDesign2018 | 26:15df8f054d11 | 255 | } |
SDesign2018 | 26:15df8f054d11 | 256 | |
SDesign2018 | 26:15df8f054d11 | 257 | bool Adafruit_GPS::newNMEAreceived(void) { |
SDesign2018 | 26:15df8f054d11 | 258 | return recvdflag; |
SDesign2018 | 26:15df8f054d11 | 259 | } |
SDesign2018 | 26:15df8f054d11 | 260 | |
SDesign2018 | 26:15df8f054d11 | 261 | void Adafruit_GPS::pause(bool p) { |
SDesign2018 | 26:15df8f054d11 | 262 | paused = p; |
SDesign2018 | 26:15df8f054d11 | 263 | } |
SDesign2018 | 26:15df8f054d11 | 264 | |
SDesign2018 | 26:15df8f054d11 | 265 | char *Adafruit_GPS::lastNMEA(void) { |
SDesign2018 | 26:15df8f054d11 | 266 | recvdflag = false; |
SDesign2018 | 26:15df8f054d11 | 267 | return (char *)lastline; |
SDesign2018 | 26:15df8f054d11 | 268 | } |
SDesign2018 | 26:15df8f054d11 | 269 | |
SDesign2018 | 26:15df8f054d11 | 270 | // read a Hex value and return the decimal equivalent |
SDesign2018 | 26:15df8f054d11 | 271 | uint8_t Adafruit_GPS::parseHex(char c) { |
SDesign2018 | 26:15df8f054d11 | 272 | if (c < '0') |
SDesign2018 | 26:15df8f054d11 | 273 | return 0; |
SDesign2018 | 26:15df8f054d11 | 274 | if (c <= '9') |
SDesign2018 | 26:15df8f054d11 | 275 | return c - '0'; |
SDesign2018 | 26:15df8f054d11 | 276 | if (c < 'A') |
SDesign2018 | 26:15df8f054d11 | 277 | return 0; |
SDesign2018 | 26:15df8f054d11 | 278 | if (c <= 'F') |
SDesign2018 | 26:15df8f054d11 | 279 | return (c - 'A')+10; |
SDesign2018 | 26:15df8f054d11 | 280 | } |
SDesign2018 | 26:15df8f054d11 | 281 | |
SDesign2018 | 26:15df8f054d11 | 282 | bool Adafruit_GPS::waitForSentence(char *wait4me, uint8_t max) { |
SDesign2018 | 26:15df8f054d11 | 283 | char str[20]; |
SDesign2018 | 26:15df8f054d11 | 284 | |
SDesign2018 | 26:15df8f054d11 | 285 | uint8_t i=0; |
SDesign2018 | 26:15df8f054d11 | 286 | while (i < max) { |
SDesign2018 | 26:15df8f054d11 | 287 | if (newNMEAreceived()) { |
SDesign2018 | 26:15df8f054d11 | 288 | char *nmea = lastNMEA(); |
SDesign2018 | 26:15df8f054d11 | 289 | strncpy(str, nmea, 20); |
SDesign2018 | 26:15df8f054d11 | 290 | str[19] = 0; |
SDesign2018 | 26:15df8f054d11 | 291 | i++; |
SDesign2018 | 26:15df8f054d11 | 292 | |
SDesign2018 | 26:15df8f054d11 | 293 | if (strstr(str, wait4me)) |
SDesign2018 | 26:15df8f054d11 | 294 | return true; |
SDesign2018 | 26:15df8f054d11 | 295 | } |
SDesign2018 | 26:15df8f054d11 | 296 | } |
SDesign2018 | 26:15df8f054d11 | 297 | |
SDesign2018 | 26:15df8f054d11 | 298 | return false; |
SDesign2018 | 26:15df8f054d11 | 299 | } |
SDesign2018 | 26:15df8f054d11 | 300 | |
SDesign2018 | 26:15df8f054d11 | 301 | bool Adafruit_GPS::LOCUS_StartLogger(void) { |
SDesign2018 | 26:15df8f054d11 | 302 | sendCommand(PMTK_LOCUS_STARTLOG); |
SDesign2018 | 26:15df8f054d11 | 303 | recvdflag = false; |
SDesign2018 | 26:15df8f054d11 | 304 | return waitForSentence(PMTK_LOCUS_LOGSTARTED); |
SDesign2018 | 26:15df8f054d11 | 305 | } |
SDesign2018 | 26:15df8f054d11 | 306 | |
SDesign2018 | 26:15df8f054d11 | 307 | bool Adafruit_GPS::LOCUS_ReadStatus(void) { |
SDesign2018 | 26:15df8f054d11 | 308 | sendCommand(PMTK_LOCUS_QUERY_STATUS); |
SDesign2018 | 26:15df8f054d11 | 309 | |
SDesign2018 | 26:15df8f054d11 | 310 | if (! waitForSentence("$PMTKLOG")) |
SDesign2018 | 26:15df8f054d11 | 311 | return false; |
SDesign2018 | 26:15df8f054d11 | 312 | |
SDesign2018 | 26:15df8f054d11 | 313 | char *response = lastNMEA(); |
SDesign2018 | 26:15df8f054d11 | 314 | uint16_t parsed[10]; |
SDesign2018 | 26:15df8f054d11 | 315 | uint8_t i; |
SDesign2018 | 26:15df8f054d11 | 316 | |
SDesign2018 | 26:15df8f054d11 | 317 | for (i=0; i<10; i++) parsed[i] = -1; |
SDesign2018 | 26:15df8f054d11 | 318 | |
SDesign2018 | 26:15df8f054d11 | 319 | response = strchr(response, ','); |
SDesign2018 | 26:15df8f054d11 | 320 | for (i=0; i<10; i++) { |
SDesign2018 | 26:15df8f054d11 | 321 | if (!response || (response[0] == 0) || (response[0] == '*')) |
SDesign2018 | 26:15df8f054d11 | 322 | break; |
SDesign2018 | 26:15df8f054d11 | 323 | response++; |
SDesign2018 | 26:15df8f054d11 | 324 | parsed[i]=0; |
SDesign2018 | 26:15df8f054d11 | 325 | while ((response[0] != ',') && |
SDesign2018 | 26:15df8f054d11 | 326 | (response[0] != '*') && (response[0] != 0)) { |
SDesign2018 | 26:15df8f054d11 | 327 | parsed[i] *= 10; |
SDesign2018 | 26:15df8f054d11 | 328 | char c = response[0]; |
SDesign2018 | 26:15df8f054d11 | 329 | if (isdigit(c)) |
SDesign2018 | 26:15df8f054d11 | 330 | parsed[i] += c - '0'; |
SDesign2018 | 26:15df8f054d11 | 331 | else |
SDesign2018 | 26:15df8f054d11 | 332 | parsed[i] = c; |
SDesign2018 | 26:15df8f054d11 | 333 | response++; |
SDesign2018 | 26:15df8f054d11 | 334 | } |
SDesign2018 | 26:15df8f054d11 | 335 | } |
SDesign2018 | 26:15df8f054d11 | 336 | LOCUS_serial = parsed[0]; |
SDesign2018 | 26:15df8f054d11 | 337 | LOCUS_type = parsed[1]; |
SDesign2018 | 26:15df8f054d11 | 338 | if (isalpha(parsed[2])) { |
SDesign2018 | 26:15df8f054d11 | 339 | parsed[2] = parsed[2] - 'a' + 10; |
SDesign2018 | 26:15df8f054d11 | 340 | } |
SDesign2018 | 26:15df8f054d11 | 341 | LOCUS_mode = parsed[2]; |
SDesign2018 | 26:15df8f054d11 | 342 | LOCUS_config = parsed[3]; |
SDesign2018 | 26:15df8f054d11 | 343 | LOCUS_interval = parsed[4]; |
SDesign2018 | 26:15df8f054d11 | 344 | LOCUS_distance = parsed[5]; |
SDesign2018 | 26:15df8f054d11 | 345 | LOCUS_speed = parsed[6]; |
SDesign2018 | 26:15df8f054d11 | 346 | LOCUS_status = !parsed[7]; |
SDesign2018 | 26:15df8f054d11 | 347 | LOCUS_records = parsed[8]; |
SDesign2018 | 26:15df8f054d11 | 348 | LOCUS_percent = parsed[9]; |
SDesign2018 | 26:15df8f054d11 | 349 | |
SDesign2018 | 26:15df8f054d11 | 350 | return true; |
SDesign2018 | 26:15df8f054d11 | 351 | } |
SDesign2018 | 26:15df8f054d11 | 352 | |
SDesign2018 | 26:15df8f054d11 | 353 | // Standby Mode Switches |
SDesign2018 | 26:15df8f054d11 | 354 | bool Adafruit_GPS::standby(void) { |
SDesign2018 | 26:15df8f054d11 | 355 | if (inStandbyMode) { |
SDesign2018 | 26:15df8f054d11 | 356 | return false; // Returns false if already in standby mode, so that you do not wake it up by sending commands to GPS |
SDesign2018 | 26:15df8f054d11 | 357 | } |
SDesign2018 | 26:15df8f054d11 | 358 | else { |
SDesign2018 | 26:15df8f054d11 | 359 | inStandbyMode = true; |
SDesign2018 | 26:15df8f054d11 | 360 | sendCommand(PMTK_STANDBY); |
SDesign2018 | 26:15df8f054d11 | 361 | //return waitForSentence(PMTK_STANDBY_SUCCESS); // don't seem to be fast enough to catch the message, or something else just is not working |
SDesign2018 | 26:15df8f054d11 | 362 | return true; |
SDesign2018 | 26:15df8f054d11 | 363 | } |
SDesign2018 | 26:15df8f054d11 | 364 | } |
SDesign2018 | 26:15df8f054d11 | 365 | |
SDesign2018 | 26:15df8f054d11 | 366 | bool Adafruit_GPS::wakeup(void) { |
SDesign2018 | 26:15df8f054d11 | 367 | if (inStandbyMode) { |
SDesign2018 | 26:15df8f054d11 | 368 | inStandbyMode = false; |
SDesign2018 | 26:15df8f054d11 | 369 | sendCommand(""); // send byte to wake it up |
SDesign2018 | 26:15df8f054d11 | 370 | return waitForSentence(PMTK_AWAKE); |
SDesign2018 | 26:15df8f054d11 | 371 | } |
SDesign2018 | 26:15df8f054d11 | 372 | else { |
SDesign2018 | 26:15df8f054d11 | 373 | return false; // Returns false if not in standby mode, nothing to wakeup |
SDesign2018 | 26:15df8f054d11 | 374 | } |
SDesign2018 | 26:15df8f054d11 | 375 | } |
SDesign2018 | 26:15df8f054d11 | 376 | |
SDesign2018 | 26:15df8f054d11 | 377 | |
SDesign2018 | 26:15df8f054d11 | 378 | |
SDesign2018 | 26:15df8f054d11 | 379 | |
SDesign2018 | 26:15df8f054d11 | 380 | /////FOR GPS-----------------ABOVE------------------------------------- |
SDesign2018 | 26:15df8f054d11 | 381 | |
SDesign2018 | 26:15df8f054d11 | 382 | |
SDesign2018 | 26:15df8f054d11 | 383 | |
SDesign2018 | 26:15df8f054d11 | 384 | |
SDesign2018 | 26:15df8f054d11 | 385 | |
SDesign2018 | 26:15df8f054d11 | 386 | |
SDesign2018 | 26:15df8f054d11 | 387 | |
SDesign2018 | 26:15df8f054d11 | 388 | |
SDesign2018 | 26:15df8f054d11 | 389 | |
SDesign2018 | 26:15df8f054d11 | 390 | |
SDesign2018 | 26:15df8f054d11 | 391 | |
SDesign2018 | 26:15df8f054d11 | 392 | |
SDesign2018 | 26:15df8f054d11 | 393 | |
SDesign2018 | 26:15df8f054d11 | 394 | |
SDesign2018 | 26:15df8f054d11 | 395 | ///////////////////////////////////////////////////////////////////////////// |
SDesign2018 | 26:15df8f054d11 | 396 | // -------------------- DOT LIBRARY REQUIRED ------------------------------// |
SDesign2018 | 26:15df8f054d11 | 397 | // * Because these example programs can be used for both mDot and xDot // |
SDesign2018 | 26:15df8f054d11 | 398 | // devices, the LoRa stack is not included. The libmDot library should // |
SDesign2018 | 26:15df8f054d11 | 399 | // be imported if building for mDot devices. The libxDot library // |
SDesign2018 | 26:15df8f054d11 | 400 | // should be imported if building for xDot devices. // |
SDesign2018 | 26:15df8f054d11 | 401 | // * https://developer.mbed.org/teams/MultiTech/code/libmDot-dev-mbed5/ // |
SDesign2018 | 26:15df8f054d11 | 402 | // * https://developer.mbed.org/teams/MultiTech/code/libmDot-mbed5/ // |
SDesign2018 | 26:15df8f054d11 | 403 | // * https://developer.mbed.org/teams/MultiTech/code/libxDot-dev-mbed5/ // |
SDesign2018 | 26:15df8f054d11 | 404 | // * https://developer.mbed.org/teams/MultiTech/code/libxDot-mbed5/ // |
SDesign2018 | 26:15df8f054d11 | 405 | ///////////////////////////////////////////////////////////////////////////// |
SDesign2018 | 26:15df8f054d11 | 406 | |
SDesign2018 | 26:15df8f054d11 | 407 | |
SDesign2018 | 26:15df8f054d11 | 408 | ///////////////////////////////////////////////////////////// |
SDesign2018 | 26:15df8f054d11 | 409 | // * these options must match between the two devices in // |
SDesign2018 | 26:15df8f054d11 | 410 | // order for communication to be successful |
SDesign2018 | 26:15df8f054d11 | 411 | //-------------------MDOT variables------------------------// |
SDesign2018 | 26:15df8f054d11 | 412 | ///////////////////////////////////////////////////////////// |
SDesign2018 | 26:15df8f054d11 | 413 | static uint8_t network_address[] = { 0x00, 0x11, 0x22, 0x33 }; |
SDesign2018 | 26:15df8f054d11 | 414 | static uint8_t network_session_key[] = { 0x00, 0x11, 0x22, 0x33, 0x00, 0x11, 0x22, 0x33, 0x00, 0x11, 0x22, 0x33, 0x00, 0x11, 0x22, 0x33 }; |
SDesign2018 | 26:15df8f054d11 | 415 | static uint8_t data_session_key[] = { 0x33, 0x22, 0x11, 0x00, 0x33, 0x22, 0x11, 0x00, 0x33, 0x22, 0x11, 0x00, 0x33, 0x22, 0x11, 0x00 }; |
SDesign2018 | 26:15df8f054d11 | 416 | |
SDesign2018 | 26:15df8f054d11 | 417 | mDot* dot = NULL; |
SDesign2018 | 26:15df8f054d11 | 418 | lora::ChannelPlan* plan = NULL; |
SDesign2018 | 26:15df8f054d11 | 419 | //--------------End of MDOT variables-------------------// |
SDesign2018 | 26:15df8f054d11 | 420 | |
SDesign2018 | 26:15df8f054d11 | 421 | Serial pc(USBTX, USBRX); |
SDesign2018 | 26:15df8f054d11 | 422 | Ticker Periodic; |
SDesign2018 | 26:15df8f054d11 | 423 | |
SDesign2018 | 26:15df8f054d11 | 424 | // ADXL372 Slave I2C |
SDesign2018 | 26:15df8f054d11 | 425 | I2C ADXL372(I2C_SDA, I2C_SCL); // (D14,D15) (MISO, CS) |
SDesign2018 | 26:15df8f054d11 | 426 | |
SDesign2018 | 26:15df8f054d11 | 427 | // ADT7410 Temperature |
SDesign2018 | 26:15df8f054d11 | 428 | I2C ADT7410(I2C_SDA, I2C_SCL); // Attempt at making I2C connection to slaves (D14,D15) |
SDesign2018 | 26:15df8f054d11 | 429 | InterruptIn ADT7410_Int(D2); // Allow this pin for ADT7410 Interrupt critical temperature notice |
SDesign2018 | 26:15df8f054d11 | 430 | |
SDesign2018 | 26:15df8f054d11 | 431 | // DS7505s Temperature |
SDesign2018 | 26:15df8f054d11 | 432 | I2C DS7505(I2C_SDA, I2C_SCL); // Attempt at making I2C connection to slaves (D14,D15) |
SDesign2018 | 26:15df8f054d11 | 433 | |
SDesign2018 | 26:15df8f054d11 | 434 | // Create reocurring interrupt function that could be used to periodically take temperatures |
SDesign2018 | 26:15df8f054d11 | 435 | // Not working right now due to some mutex initialize error |
SDesign2018 | 26:15df8f054d11 | 436 | // Suspect that it is due to it having be a RTOS task thing |
SDesign2018 | 26:15df8f054d11 | 437 | // Should probably go back to using an in processor timer interrupt instead of mbed |
SDesign2018 | 26:15df8f054d11 | 438 | |
SDesign2018 | 26:15df8f054d11 | 439 | const int ADT7410_Address_7BIT = 0x49; // A0 set HIGH and A1 set LOW |
SDesign2018 | 26:15df8f054d11 | 440 | const int ADT7410_Address_8BIT = ADT7410_Address_7BIT << 1; // Shift 1 bit to left for R/~W bit, and basic I2C format |
SDesign2018 | 26:15df8f054d11 | 441 | |
SDesign2018 | 26:15df8f054d11 | 442 | const int ADXL372_Address_7bit = 0x1D; // Address for the I2C if MISO pulled low, 0x53 if pulled high |
SDesign2018 | 26:15df8f054d11 | 443 | const int ADXL372_Address_8bit = ADXL372_Address_7bit << 1; // Same |
SDesign2018 | 26:15df8f054d11 | 444 | |
SDesign2018 | 26:15df8f054d11 | 445 | const int DS7505s_Address_7bit = 0x48; // A0 set LOR, A1 set LOW, A2 set LOW |
SDesign2018 | 26:15df8f054d11 | 446 | const int DS7505s_Address_8bit = DS7505s_Address_7bit << 1; // Same |
SDesign2018 | 26:15df8f054d11 | 447 | |
SDesign2018 | 26:15df8f054d11 | 448 | |
SDesign2018 | 26:15df8f054d11 | 449 | int regAddress; // Used by all sensors |
SDesign2018 | 26:15df8f054d11 | 450 | |
SDesign2018 | 26:15df8f054d11 | 451 | /* |
SDesign2018 | 26:15df8f054d11 | 452 | * Variables used for ADT7410 Temperature |
SDesign2018 | 26:15df8f054d11 | 453 | */ |
SDesign2018 | 26:15df8f054d11 | 454 | // Points to the returned char pointer from called functions |
SDesign2018 | 26:15df8f054d11 | 455 | char * rawTempValues; // Could change to uint8_t, same for other char pointers |
SDesign2018 | 26:15df8f054d11 | 456 | uint16_t convertedTempValue; // Data values must be uint16_t for conversion and send prep |
SDesign2018 | 26:15df8f054d11 | 457 | uint16_t temperatureBuffer[BUFFER_SIZE]; |
SDesign2018 | 26:15df8f054d11 | 458 | |
SDesign2018 | 26:15df8f054d11 | 459 | |
SDesign2018 | 26:15df8f054d11 | 460 | /* |
SDesign2018 | 26:15df8f054d11 | 461 | * Variables used for mDot |
SDesign2018 | 26:15df8f054d11 | 462 | */ |
SDesign2018 | 26:15df8f054d11 | 463 | |
SDesign2018 | 26:15df8f054d11 | 464 | |
SDesign2018 | 26:15df8f054d11 | 465 | uint32_t tx_frequency; |
SDesign2018 | 26:15df8f054d11 | 466 | uint8_t tx_datarate; |
SDesign2018 | 26:15df8f054d11 | 467 | uint8_t tx_power; |
SDesign2018 | 26:15df8f054d11 | 468 | uint8_t frequency_band; |
SDesign2018 | 26:15df8f054d11 | 469 | |
SDesign2018 | 26:15df8f054d11 | 470 | |
SDesign2018 | 26:15df8f054d11 | 471 | |
SDesign2018 | 26:15df8f054d11 | 472 | /* |
SDesign2018 | 26:15df8f054d11 | 473 | * Variables used for ADXL372 Accelerometer |
SDesign2018 | 26:15df8f054d11 | 474 | */ |
SDesign2018 | 26:15df8f054d11 | 475 | char *accelValues; |
SDesign2018 | 26:15df8f054d11 | 476 | char Xmsb; // Gets most significant byte |
SDesign2018 | 26:15df8f054d11 | 477 | char Xlsb; // Gets least significant byte |
SDesign2018 | 26:15df8f054d11 | 478 | char Ymsb; |
SDesign2018 | 26:15df8f054d11 | 479 | char Ylsb; |
SDesign2018 | 26:15df8f054d11 | 480 | char Zmsb; |
SDesign2018 | 26:15df8f054d11 | 481 | char Zlsb; |
SDesign2018 | 26:15df8f054d11 | 482 | uint16_t XData; |
SDesign2018 | 26:15df8f054d11 | 483 | uint16_t YData; |
SDesign2018 | 26:15df8f054d11 | 484 | uint16_t ZData; |
SDesign2018 | 26:15df8f054d11 | 485 | |
SDesign2018 | 27:5db200a4d496 | 486 | |
SDesign2018 | 26:15df8f054d11 | 487 | uint16_t XDataInterrupt[BUFFER_SIZE]; |
SDesign2018 | 26:15df8f054d11 | 488 | uint16_t YDataInterrupt[BUFFER_SIZE]; |
SDesign2018 | 26:15df8f054d11 | 489 | uint16_t ZDataInterrupt[BUFFER_SIZE]; |
SDesign2018 | 26:15df8f054d11 | 490 | |
SDesign2018 | 26:15df8f054d11 | 491 | |
SDesign2018 | 26:15df8f054d11 | 492 | |
SDesign2018 | 26:15df8f054d11 | 493 | /* |
SDesign2018 | 26:15df8f054d11 | 494 | * Variables used for interrupt triggers |
SDesign2018 | 26:15df8f054d11 | 495 | */ |
SDesign2018 | 26:15df8f054d11 | 496 | bool takeTemperature = false; // Trigger temperature reading |
SDesign2018 | 26:15df8f054d11 | 497 | bool takeAccelerometer = false; // Trigger accelerometer reading |
SDesign2018 | 26:15df8f054d11 | 498 | bool periodicReadingTrigger = false; // Trigger reading both accelerometer and temperature |
SDesign2018 | 26:15df8f054d11 | 499 | |
SDesign2018 | 26:15df8f054d11 | 500 | /* |
SDesign2018 | 26:15df8f054d11 | 501 | * Prototype functions |
SDesign2018 | 26:15df8f054d11 | 502 | */ |
SDesign2018 | 26:15df8f054d11 | 503 | |
SDesign2018 | 26:15df8f054d11 | 504 | char twosComplementConversion(char value); |
SDesign2018 | 26:15df8f054d11 | 505 | |
SDesign2018 | 26:15df8f054d11 | 506 | void ADXL372Initialize(void); |
SDesign2018 | 26:15df8f054d11 | 507 | void ADXL372Reset(void); |
SDesign2018 | 26:15df8f054d11 | 508 | void I2CSelfTest(void); |
SDesign2018 | 26:15df8f054d11 | 509 | void accelerometerI2CWrite(uint8_t hexAddress, uint8_t hexData); |
SDesign2018 | 26:15df8f054d11 | 510 | char * accelerometerI2CRead(int hexAddress); |
SDesign2018 | 26:15df8f054d11 | 511 | |
SDesign2018 | 26:15df8f054d11 | 512 | void ADT7410Initialize(void); |
SDesign2018 | 26:15df8f054d11 | 513 | void ADT7410Write(unsigned char registerAddress, unsigned char data); |
SDesign2018 | 26:15df8f054d11 | 514 | char * ADT7410Read(int hex); |
SDesign2018 | 26:15df8f054d11 | 515 | |
SDesign2018 | 26:15df8f054d11 | 516 | |
SDesign2018 | 26:15df8f054d11 | 517 | /* |
SDesign2018 | 26:15df8f054d11 | 518 | * Interrupt functions |
SDesign2018 | 26:15df8f054d11 | 519 | */ |
SDesign2018 | 26:15df8f054d11 | 520 | void CriticalTemperatureInterrupt(void){ |
SDesign2018 | 26:15df8f054d11 | 521 | takeTemperature = true; // Take temperature because something happened |
SDesign2018 | 26:15df8f054d11 | 522 | } |
SDesign2018 | 26:15df8f054d11 | 523 | |
SDesign2018 | 26:15df8f054d11 | 524 | void CriticalAccelerometerInterrupt(void){ |
SDesign2018 | 26:15df8f054d11 | 525 | takeAccelerometer = true; // Take accelerometer because something happened |
SDesign2018 | 26:15df8f054d11 | 526 | } |
SDesign2018 | 26:15df8f054d11 | 527 | |
SDesign2018 | 26:15df8f054d11 | 528 | void takePeriodicReading(std::vector<uint8_t> tx_data){ |
SDesign2018 | 26:15df8f054d11 | 529 | pc.printf("Regular periodic reading \n\r"); |
SDesign2018 | 26:15df8f054d11 | 530 | /* |
SDesign2018 | 26:15df8f054d11 | 531 | * Taking accelerometer data |
SDesign2018 | 26:15df8f054d11 | 532 | */ |
SDesign2018 | 26:15df8f054d11 | 533 | regAddress = 0x08; // This is the register address for XData |
SDesign2018 | 26:15df8f054d11 | 534 | accelValues = accelerometerI2CRead(regAddress); // Get the dadta |
SDesign2018 | 26:15df8f054d11 | 535 | // Raw Data |
SDesign2018 | 26:15df8f054d11 | 536 | Xmsb = *(accelValues + 0); |
SDesign2018 | 26:15df8f054d11 | 537 | Xlsb = *(accelValues + 1); |
SDesign2018 | 26:15df8f054d11 | 538 | Ymsb = *(accelValues + 2); |
SDesign2018 | 26:15df8f054d11 | 539 | Ylsb = *(accelValues + 3); |
SDesign2018 | 26:15df8f054d11 | 540 | Zmsb = *(accelValues + 4); |
SDesign2018 | 26:15df8f054d11 | 541 | Zlsb = *(accelValues + 5); |
SDesign2018 | 26:15df8f054d11 | 542 | |
SDesign2018 | 26:15df8f054d11 | 543 | // Combine two bytes into short int, remove last 4 bits because 12bit resolution |
SDesign2018 | 26:15df8f054d11 | 544 | XData = (Xmsb << 8 | Xlsb) >> 4; |
SDesign2018 | 26:15df8f054d11 | 545 | YData = (Ymsb << 8 | Ylsb) >> 4; |
SDesign2018 | 26:15df8f054d11 | 546 | ZData = (Zmsb << 8 | Zlsb) >> 4; |
SDesign2018 | 26:15df8f054d11 | 547 | |
SDesign2018 | 26:15df8f054d11 | 548 | // Check if twos complement is needed |
SDesign2018 | 26:15df8f054d11 | 549 | //XData = twosComplementConversion(XData); |
SDesign2018 | 26:15df8f054d11 | 550 | //YData = twosComplementConversion(YData); |
SDesign2018 | 26:15df8f054d11 | 551 | //ZData = twosComplementConversion(ZData); |
SDesign2018 | 26:15df8f054d11 | 552 | |
SDesign2018 | 26:15df8f054d11 | 553 | // Split Complemented Data |
SDesign2018 | 26:15df8f054d11 | 554 | Xlsb = XData & 0xff; // Split the lower 8 bits here |
SDesign2018 | 26:15df8f054d11 | 555 | Xmsb = XData >> 8; // Split the higher 8 bits here |
SDesign2018 | 26:15df8f054d11 | 556 | |
SDesign2018 | 26:15df8f054d11 | 557 | Ylsb = YData & 0xff; // Split the lower 8 bits here |
SDesign2018 | 26:15df8f054d11 | 558 | Ymsb = YData >> 8; // Split the higher 8 bits here |
SDesign2018 | 26:15df8f054d11 | 559 | |
SDesign2018 | 26:15df8f054d11 | 560 | Zlsb = ZData & 0xff; // Split the lower 8bits here |
SDesign2018 | 26:15df8f054d11 | 561 | Zmsb = ZData >> 8; // Split the higher 8bits here |
SDesign2018 | 26:15df8f054d11 | 562 | |
SDesign2018 | 27:5db200a4d496 | 563 | |
SDesign2018 | 27:5db200a4d496 | 564 | |
SDesign2018 | 26:15df8f054d11 | 565 | /* |
SDesign2018 | 26:15df8f054d11 | 566 | * Taking temperature data |
SDesign2018 | 26:15df8f054d11 | 567 | */ |
SDesign2018 | 26:15df8f054d11 | 568 | regAddress = 0x00; |
SDesign2018 | 26:15df8f054d11 | 569 | rawTempValues = ADT7410Read(regAddress); |
SDesign2018 | 26:15df8f054d11 | 570 | convertedTempValue = ((*(rawTempValues + 0) << 8) | *(rawTempValues + 1)) >> 3; // Combine the two bytes into |
SDesign2018 | 26:15df8f054d11 | 571 | // a short int variable(16 bits), remove last 3 bits |
SDesign2018 | 26:15df8f054d11 | 572 | |
SDesign2018 | 26:15df8f054d11 | 573 | |
SDesign2018 | 26:15df8f054d11 | 574 | c = myGPS.read(); //queries the GPS |
SDesign2018 | 26:15df8f054d11 | 575 | |
SDesign2018 | 26:15df8f054d11 | 576 | // if (c) { pc.printf("%c", c); } //this line will echo the GPS data if not paused |
SDesign2018 | 26:15df8f054d11 | 577 | //check if we recieved a new message from GPS, if so, attempt to parse it, |
SDesign2018 | 26:15df8f054d11 | 578 | if ( myGPS.newNMEAreceived() ) { |
SDesign2018 | 26:15df8f054d11 | 579 | if ( !myGPS.parse(myGPS.lastNMEA()) ) { |
SDesign2018 | 26:15df8f054d11 | 580 | |
SDesign2018 | 26:15df8f054d11 | 581 | } |
SDesign2018 | 26:15df8f054d11 | 582 | } |
SDesign2018 | 26:15df8f054d11 | 583 | |
SDesign2018 | 26:15df8f054d11 | 584 | //check if enough time has passed to warrant printing GPS info to screen |
SDesign2018 | 26:15df8f054d11 | 585 | //note if refresh_Time is too low or pc.baud is too low, GPS data may be lost during printing |
SDesign2018 | 26:15df8f054d11 | 586 | if (refresh_Timer.read_ms() >= refresh_Time) { |
SDesign2018 | 26:15df8f054d11 | 587 | refresh_Timer.reset(); |
SDesign2018 | 26:15df8f054d11 | 588 | |
SDesign2018 | 26:15df8f054d11 | 589 | /* pc.printf("Time: %d:%d:%d.%u\n", myGPS.hour, myGPS.minute, myGPS.seconds, myGPS.milliseconds); |
SDesign2018 | 26:15df8f054d11 | 590 | pc.printf("Date: %d/%d/20%d\n", myGPS.day, myGPS.month, myGPS.year); |
SDesign2018 | 26:15df8f054d11 | 591 | pc.printf("Fix: %d\n", (int) myGPS.fix); |
SDesign2018 | 26:15df8f054d11 | 592 | pc.printf("Quality: %d\n", (int) myGPS.fixquality);*/ |
SDesign2018 | 26:15df8f054d11 | 593 | if (myGPS.fix) { |
SDesign2018 | 26:15df8f054d11 | 594 | pc.printf("\r"); |
SDesign2018 | 26:15df8f054d11 | 595 | pc.printf("GPS log:\n"); |
SDesign2018 | 26:15df8f054d11 | 596 | pc.printf("\r"); |
SDesign2018 | 26:15df8f054d11 | 597 | pc.printf("Time(GMT): %d:%d:%d.%u\n", myGPS.hour, myGPS.minute, myGPS.seconds, myGPS.milliseconds); |
SDesign2018 | 26:15df8f054d11 | 598 | pc.printf("\r"); |
SDesign2018 | 26:15df8f054d11 | 599 | pc.printf("Date: %d/%d/20%d\n", myGPS.day, myGPS.month, myGPS.year); |
SDesign2018 | 26:15df8f054d11 | 600 | pc.printf("\r"); |
SDesign2018 | 26:15df8f054d11 | 601 | pc.printf("Fix: %d\n", (int) myGPS.fix); |
SDesign2018 | 26:15df8f054d11 | 602 | pc.printf("\r"); |
SDesign2018 | 26:15df8f054d11 | 603 | pc.printf("Quality: %d\n", (int) myGPS.fixquality); |
SDesign2018 | 26:15df8f054d11 | 604 | pc.printf("\r"); |
SDesign2018 | 26:15df8f054d11 | 605 | pc.printf("Location: %5.2f%c, %5.2f%c\n", myGPS.latitude, myGPS.lat, myGPS.longitude, myGPS.lon); |
SDesign2018 | 26:15df8f054d11 | 606 | pc.printf("\r"); |
SDesign2018 | 26:15df8f054d11 | 607 | pc.printf("Speed: %5.2f knots\n", myGPS.speed); |
SDesign2018 | 26:15df8f054d11 | 608 | pc.printf("\r"); |
SDesign2018 | 26:15df8f054d11 | 609 | pc.printf("Angle: %5.2f\n", myGPS.angle); |
SDesign2018 | 26:15df8f054d11 | 610 | pc.printf("\r"); |
SDesign2018 | 26:15df8f054d11 | 611 | pc.printf("Altitude: %5.2f\n", myGPS.altitude); |
SDesign2018 | 26:15df8f054d11 | 612 | pc.printf("\r"); |
SDesign2018 | 26:15df8f054d11 | 613 | pc.printf("Satellites: %d\n", myGPS.satellites); |
SDesign2018 | 26:15df8f054d11 | 614 | pc.printf("\r"); |
SDesign2018 | 26:15df8f054d11 | 615 | } |
SDesign2018 | 26:15df8f054d11 | 616 | } |
SDesign2018 | 26:15df8f054d11 | 617 | |
SDesign2018 | 26:15df8f054d11 | 618 | pc.printf("Accelerometer::: "); |
SDesign2018 | 26:15df8f054d11 | 619 | pc.printf("X: 0x%x | Y: 0x%x | Z: 0x%x\n\r", XData, YData, ZData); |
SDesign2018 | 26:15df8f054d11 | 620 | //pc.printf("X: 0x%x %x | Y: 0x%x %x | Z: 0x%x %x\n\r", Xmsb, Xlsb, Ymsb, Ylsb,Zmsb, Zlsb); |
SDesign2018 | 26:15df8f054d11 | 621 | pc.printf("Temperature::: "); |
SDesign2018 | 26:15df8f054d11 | 622 | pc.printf("Celsius: 0x%x\n\r", convertedTempValue); |
SDesign2018 | 26:15df8f054d11 | 623 | |
SDesign2018 | 26:15df8f054d11 | 624 | |
SDesign2018 | 26:15df8f054d11 | 625 | // Push 1 for temperature |
SDesign2018 | 26:15df8f054d11 | 626 | tx_data.push_back(1); |
SDesign2018 | 26:15df8f054d11 | 627 | tx_data.push_back((convertedTempValue >> 8) & 0xFF); |
SDesign2018 | 26:15df8f054d11 | 628 | tx_data.push_back(convertedTempValue & 0xFF); |
SDesign2018 | 26:15df8f054d11 | 629 | // Push 2 for AccelerometerX |
SDesign2018 | 26:15df8f054d11 | 630 | tx_data.push_back(2); |
SDesign2018 | 26:15df8f054d11 | 631 | tx_data.push_back((XData >> 8) & 0xFF); |
SDesign2018 | 26:15df8f054d11 | 632 | tx_data.push_back(XData & 0xFF); |
SDesign2018 | 26:15df8f054d11 | 633 | // Push 3 for AccelerometerY |
SDesign2018 | 26:15df8f054d11 | 634 | tx_data.push_back(3); |
SDesign2018 | 26:15df8f054d11 | 635 | tx_data.push_back((YData >> 8) & 0xFF); |
SDesign2018 | 26:15df8f054d11 | 636 | tx_data.push_back(YData & 0xFF); |
SDesign2018 | 26:15df8f054d11 | 637 | // Push 4 for AccelerometerZ |
SDesign2018 | 26:15df8f054d11 | 638 | tx_data.push_back(4); |
SDesign2018 | 26:15df8f054d11 | 639 | tx_data.push_back((ZData >> 8) & 0xFF); |
SDesign2018 | 26:15df8f054d11 | 640 | tx_data.push_back(ZData & 0xFF); |
SDesign2018 | 26:15df8f054d11 | 641 | logInfo("Temperautre: %lu [0x%04X]", convertedTempValue, convertedTempValue); |
SDesign2018 | 26:15df8f054d11 | 642 | send_data(tx_data); |
SDesign2018 | 26:15df8f054d11 | 643 | periodicReadingTrigger = false; // Flip back to no trigger |
SDesign2018 | 26:15df8f054d11 | 644 | } |
SDesign2018 | 26:15df8f054d11 | 645 | |
SDesign2018 | 26:15df8f054d11 | 646 | void takePeriodicReadingTicker(void){ |
SDesign2018 | 26:15df8f054d11 | 647 | periodicReadingTrigger = true; |
SDesign2018 | 26:15df8f054d11 | 648 | } |
SDesign2018 | 26:15df8f054d11 | 649 | |
SDesign2018 | 26:15df8f054d11 | 650 | //////////////////////////////////////////////////////////////////////////////// |
SDesign2018 | 26:15df8f054d11 | 651 | /* _ |
SDesign2018 | 26:15df8f054d11 | 652 | ____ ___ ____ _(_)___ |
SDesign2018 | 26:15df8f054d11 | 653 | / __ `__ \/ __ `/ / __ \ |
SDesign2018 | 26:15df8f054d11 | 654 | / / / / / / /_/ / / / / / |
SDesign2018 | 26:15df8f054d11 | 655 | /_/ /_/ /_/\__,_/_/_/ /_/ |
SDesign2018 | 26:15df8f054d11 | 656 | |
SDesign2018 | 26:15df8f054d11 | 657 | *////////////////////////////////////////////////////////////////////////////// |
SDesign2018 | 26:15df8f054d11 | 658 | int main(void) |
SDesign2018 | 26:15df8f054d11 | 659 | { |
SDesign2018 | 26:15df8f054d11 | 660 | // Custom event handler for automatically displaying RX data |
SDesign2018 | 26:15df8f054d11 | 661 | //interruptEverything.attach(&interruptReadTemperature, 7.0); |
SDesign2018 | 26:15df8f054d11 | 662 | RadioEvent events; |
SDesign2018 | 26:15df8f054d11 | 663 | // Change baud rate in serial terminal to this value |
SDesign2018 | 26:15df8f054d11 | 664 | pc.baud(115200); |
SDesign2018 | 26:15df8f054d11 | 665 | ADXL372.frequency(300000); // I2C devices are connected to the same clock |
SDesign2018 | 26:15df8f054d11 | 666 | ADT7410.frequency(300000); // Redundant but whatever |
SDesign2018 | 26:15df8f054d11 | 667 | ADT7410_Int.rise(&CriticalTemperatureInterrupt); |
SDesign2018 | 26:15df8f054d11 | 668 | myGPS.begin(9600); //sets baud rate for GPS communication; note this may be changed via Adafruit_GPS::sendCommand(char *) |
SDesign2018 | 26:15df8f054d11 | 669 | //a list of GPS commands is available at http://www.adafruit.com/datasheets/PMTK_A08.pdf |
SDesign2018 | 26:15df8f054d11 | 670 | |
SDesign2018 | 26:15df8f054d11 | 671 | myGPS.sendCommand(PMTK_SET_NMEA_OUTPUT_RMCGGA); //these commands are defined in MBed_Adafruit_GPS.h; a link is provided there for command creation |
SDesign2018 | 26:15df8f054d11 | 672 | myGPS.sendCommand(PMTK_SET_NMEA_UPDATE_1HZ); |
SDesign2018 | 26:15df8f054d11 | 673 | myGPS.sendCommand(PGCMD_ANTENNA); |
SDesign2018 | 26:15df8f054d11 | 674 | |
SDesign2018 | 26:15df8f054d11 | 675 | |
SDesign2018 | 26:15df8f054d11 | 676 | mts::MTSLog::setLogLevel(mts::MTSLog::TRACE_LEVEL); |
SDesign2018 | 26:15df8f054d11 | 677 | |
SDesign2018 | 26:15df8f054d11 | 678 | // Sometimes when calling this, it creates error: type specifier expected |
SDesign2018 | 26:15df8f054d11 | 679 | // Even with identical include files I would get this in another workspace. |
SDesign2018 | 26:15df8f054d11 | 680 | plan = new lora::ChannelPlan_US915(); |
SDesign2018 | 26:15df8f054d11 | 681 | |
SDesign2018 | 26:15df8f054d11 | 682 | logInfo("Now asserting"); |
SDesign2018 | 26:15df8f054d11 | 683 | assert(plan); |
SDesign2018 | 26:15df8f054d11 | 684 | |
SDesign2018 | 26:15df8f054d11 | 685 | // Careful when using this. The production ready libmdot-mbed5 has a void constructor |
SDesign2018 | 26:15df8f054d11 | 686 | // Therefore, can only use the libmDot-dev-mbed5 version, for now. |
SDesign2018 | 26:15df8f054d11 | 687 | dot = mDot::getInstance(plan); |
SDesign2018 | 26:15df8f054d11 | 688 | assert(dot); |
SDesign2018 | 26:15df8f054d11 | 689 | |
SDesign2018 | 26:15df8f054d11 | 690 | logInfo("mbed-os library version: %d", MBED_LIBRARY_VERSION); |
SDesign2018 | 26:15df8f054d11 | 691 | |
SDesign2018 | 26:15df8f054d11 | 692 | // start from a well-known state |
SDesign2018 | 26:15df8f054d11 | 693 | logInfo("defaulting Dot configuration"); |
SDesign2018 | 26:15df8f054d11 | 694 | dot->resetConfig(); |
SDesign2018 | 26:15df8f054d11 | 695 | |
SDesign2018 | 26:15df8f054d11 | 696 | // make sure library logging is turned on |
SDesign2018 | 26:15df8f054d11 | 697 | dot->setLogLevel(mts::MTSLog::INFO_LEVEL); |
SDesign2018 | 26:15df8f054d11 | 698 | |
SDesign2018 | 26:15df8f054d11 | 699 | // attach the custom events handler |
SDesign2018 | 26:15df8f054d11 | 700 | dot->setEvents(&events); |
SDesign2018 | 26:15df8f054d11 | 701 | |
SDesign2018 | 26:15df8f054d11 | 702 | // update configuration if necessary |
SDesign2018 | 26:15df8f054d11 | 703 | if (dot->getJoinMode() != mDot::PEER_TO_PEER) { |
SDesign2018 | 26:15df8f054d11 | 704 | logInfo("changing network join mode to PEER_TO_PEER"); |
SDesign2018 | 26:15df8f054d11 | 705 | if (dot->setJoinMode(mDot::PEER_TO_PEER) != mDot::MDOT_OK) { |
SDesign2018 | 26:15df8f054d11 | 706 | logError("failed to set network join mode to PEER_TO_PEER"); |
SDesign2018 | 26:15df8f054d11 | 707 | } |
SDesign2018 | 26:15df8f054d11 | 708 | } |
SDesign2018 | 26:15df8f054d11 | 709 | |
SDesign2018 | 26:15df8f054d11 | 710 | /* |
SDesign2018 | 26:15df8f054d11 | 711 | * Get the Frequency and then choose transfer frequency, datarate, and power accordingly |
SDesign2018 | 26:15df8f054d11 | 712 | * |
SDesign2018 | 26:15df8f054d11 | 713 | */ |
SDesign2018 | 26:15df8f054d11 | 714 | //////////////////////////////////////////////////////////////////////////////// |
SDesign2018 | 26:15df8f054d11 | 715 | frequency_band = dot->getFrequencyBand(); |
SDesign2018 | 26:15df8f054d11 | 716 | switch (frequency_band) { |
SDesign2018 | 26:15df8f054d11 | 717 | case lora::ChannelPlan::EU868_OLD: |
SDesign2018 | 26:15df8f054d11 | 718 | case lora::ChannelPlan::EU868: |
SDesign2018 | 26:15df8f054d11 | 719 | // 250kHz channels achieve higher throughput |
SDesign2018 | 26:15df8f054d11 | 720 | // DR_6 : SF7 @ 250kHz |
SDesign2018 | 26:15df8f054d11 | 721 | // DR_0 - DR_5 (125kHz channels) available but much slower |
SDesign2018 | 26:15df8f054d11 | 722 | tx_frequency = 869850000; |
SDesign2018 | 26:15df8f054d11 | 723 | tx_datarate = lora::DR_6; |
SDesign2018 | 26:15df8f054d11 | 724 | // the 869850000 frequency is 100% duty cycle if the total power is under 7 dBm - tx power 4 + antenna gain 3 = 7 |
SDesign2018 | 26:15df8f054d11 | 725 | tx_power = 4; |
SDesign2018 | 26:15df8f054d11 | 726 | break; |
SDesign2018 | 26:15df8f054d11 | 727 | |
SDesign2018 | 26:15df8f054d11 | 728 | case lora::ChannelPlan::US915_OLD: |
SDesign2018 | 26:15df8f054d11 | 729 | case lora::ChannelPlan::US915: |
SDesign2018 | 26:15df8f054d11 | 730 | case lora::ChannelPlan::AU915_OLD: |
SDesign2018 | 26:15df8f054d11 | 731 | case lora::ChannelPlan::AU915: |
SDesign2018 | 26:15df8f054d11 | 732 | // 500kHz channels achieve highest throughput |
SDesign2018 | 26:15df8f054d11 | 733 | // DR_8 : SF12 @ 500kHz |
SDesign2018 | 26:15df8f054d11 | 734 | // DR_9 : SF11 @ 500kHz |
SDesign2018 | 26:15df8f054d11 | 735 | // DR_10 : SF10 @ 500kHz |
SDesign2018 | 26:15df8f054d11 | 736 | // DR_11 : SF9 @ 500kHz |
SDesign2018 | 26:15df8f054d11 | 737 | // DR_12 : SF8 @ 500kHz |
SDesign2018 | 26:15df8f054d11 | 738 | // DR_13 : SF7 @ 500kHz |
SDesign2018 | 26:15df8f054d11 | 739 | // DR_0 - DR_3 (125kHz channels) available but much slower |
SDesign2018 | 26:15df8f054d11 | 740 | tx_frequency = 915500000; |
SDesign2018 | 26:15df8f054d11 | 741 | tx_datarate = lora::DR_13; |
SDesign2018 | 26:15df8f054d11 | 742 | // 915 bands have no duty cycle restrictions, set tx power to max |
SDesign2018 | 26:15df8f054d11 | 743 | tx_power = 20; |
SDesign2018 | 26:15df8f054d11 | 744 | break; |
SDesign2018 | 26:15df8f054d11 | 745 | |
SDesign2018 | 26:15df8f054d11 | 746 | case lora::ChannelPlan::AS923: |
SDesign2018 | 26:15df8f054d11 | 747 | case lora::ChannelPlan::AS923_JAPAN: |
SDesign2018 | 26:15df8f054d11 | 748 | // 250kHz channels achieve higher throughput |
SDesign2018 | 26:15df8f054d11 | 749 | // DR_6 : SF7 @ 250kHz |
SDesign2018 | 26:15df8f054d11 | 750 | // DR_0 - DR_5 (125kHz channels) available but much slower |
SDesign2018 | 26:15df8f054d11 | 751 | tx_frequency = 924800000; |
SDesign2018 | 26:15df8f054d11 | 752 | tx_datarate = lora::DR_6; |
SDesign2018 | 26:15df8f054d11 | 753 | tx_power = 16; |
SDesign2018 | 26:15df8f054d11 | 754 | break; |
SDesign2018 | 26:15df8f054d11 | 755 | |
SDesign2018 | 26:15df8f054d11 | 756 | case lora::ChannelPlan::KR920: |
SDesign2018 | 26:15df8f054d11 | 757 | // DR_5 : SF7 @ 125kHz |
SDesign2018 | 26:15df8f054d11 | 758 | tx_frequency = 922700000; |
SDesign2018 | 26:15df8f054d11 | 759 | tx_datarate = lora::DR_5; |
SDesign2018 | 26:15df8f054d11 | 760 | tx_power = 14; |
SDesign2018 | 26:15df8f054d11 | 761 | break; |
SDesign2018 | 26:15df8f054d11 | 762 | |
SDesign2018 | 26:15df8f054d11 | 763 | default: |
SDesign2018 | 26:15df8f054d11 | 764 | while (true) { |
SDesign2018 | 26:15df8f054d11 | 765 | logFatal("no known channel plan in use - extra configuration is needed!"); |
SDesign2018 | 26:15df8f054d11 | 766 | wait(5); |
SDesign2018 | 26:15df8f054d11 | 767 | } |
SDesign2018 | 26:15df8f054d11 | 768 | break; |
SDesign2018 | 26:15df8f054d11 | 769 | } |
SDesign2018 | 26:15df8f054d11 | 770 | ///////////////////////////////////////////////////////////////////////////////////// |
SDesign2018 | 26:15df8f054d11 | 771 | |
SDesign2018 | 26:15df8f054d11 | 772 | // in PEER_TO_PEER mode there is no join request/response transaction |
SDesign2018 | 26:15df8f054d11 | 773 | // as long as both Dots are configured correctly, they should be able to communicate |
SDesign2018 | 26:15df8f054d11 | 774 | update_peer_to_peer_config(network_address, network_session_key, data_session_key, tx_frequency, tx_datarate, tx_power); |
SDesign2018 | 26:15df8f054d11 | 775 | |
SDesign2018 | 26:15df8f054d11 | 776 | // save changes to configuration |
SDesign2018 | 26:15df8f054d11 | 777 | logInfo("saving configuration"); |
SDesign2018 | 26:15df8f054d11 | 778 | if (!dot->saveConfig()) { |
SDesign2018 | 26:15df8f054d11 | 779 | logError("failed to save configuration"); |
SDesign2018 | 26:15df8f054d11 | 780 | } |
SDesign2018 | 26:15df8f054d11 | 781 | // Display configuration |
SDesign2018 | 26:15df8f054d11 | 782 | // It's gonna output a lot of information onto the Serial Terminal |
SDesign2018 | 26:15df8f054d11 | 783 | display_config(); |
SDesign2018 | 26:15df8f054d11 | 784 | |
SDesign2018 | 26:15df8f054d11 | 785 | |
SDesign2018 | 26:15df8f054d11 | 786 | |
SDesign2018 | 26:15df8f054d11 | 787 | |
SDesign2018 | 26:15df8f054d11 | 788 | |
SDesign2018 | 26:15df8f054d11 | 789 | //below is acc,temp sensors |
SDesign2018 | 26:15df8f054d11 | 790 | ADT7410Initialize(); |
SDesign2018 | 26:15df8f054d11 | 791 | ADXL372Initialize(); |
SDesign2018 | 26:15df8f054d11 | 792 | |
SDesign2018 | 27:5db200a4d496 | 793 | //Periodic.attach(&takePeriodicReadingTicker,5); |
SDesign2018 | 26:15df8f054d11 | 794 | |
SDesign2018 | 26:15df8f054d11 | 795 | while(1){ |
SDesign2018 | 26:15df8f054d11 | 796 | // Create a vector of uint8_t elements to be sent later |
SDesign2018 | 26:15df8f054d11 | 797 | |
SDesign2018 | 26:15df8f054d11 | 798 | std::vector<uint8_t> tx_data; |
SDesign2018 | 26:15df8f054d11 | 799 | |
SDesign2018 | 26:15df8f054d11 | 800 | |
SDesign2018 | 27:5db200a4d496 | 801 | |
SDesign2018 | 27:5db200a4d496 | 802 | takePeriodicReading(tx_data); |
SDesign2018 | 27:5db200a4d496 | 803 | |
SDesign2018 | 26:15df8f054d11 | 804 | |
SDesign2018 | 26:15df8f054d11 | 805 | if(takeAccelerometer || takeTemperature){ |
SDesign2018 | 26:15df8f054d11 | 806 | pc.printf("INTERRUPTEDDDDDDDD: "); |
SDesign2018 | 26:15df8f054d11 | 807 | if(takeTemperature) pc.printf("Temperature triggered!!!!!!!!!!!!\n\r"); |
SDesign2018 | 26:15df8f054d11 | 808 | else if(takeAccelerometer) pc.printf("AccelerometerTriggered!!!!!!!!!!!!!\n\r"); |
SDesign2018 | 26:15df8f054d11 | 809 | |
SDesign2018 | 27:5db200a4d496 | 810 | |
SDesign2018 | 27:5db200a4d496 | 811 | takePeriodicReading(tx_data); |
SDesign2018 | 26:15df8f054d11 | 812 | |
SDesign2018 | 27:5db200a4d496 | 813 | |
SDesign2018 | 27:5db200a4d496 | 814 | |
SDesign2018 | 27:5db200a4d496 | 815 | |
SDesign2018 | 26:15df8f054d11 | 816 | takeAccelerometer = false; // Flip back to no trigger |
SDesign2018 | 26:15df8f054d11 | 817 | takeTemperature = false; // Flip back to no trigger |
SDesign2018 | 26:15df8f054d11 | 818 | |
SDesign2018 | 26:15df8f054d11 | 819 | } |
SDesign2018 | 26:15df8f054d11 | 820 | |
SDesign2018 | 26:15df8f054d11 | 821 | |
SDesign2018 | 26:15df8f054d11 | 822 | |
SDesign2018 | 27:5db200a4d496 | 823 | // Go to sleep for 5 seconds and wake up after 5 seconds or wakeup from interrupt |
SDesign2018 | 26:15df8f054d11 | 824 | |
SDesign2018 | 27:5db200a4d496 | 825 | if(dot->sleep(5,mDot::RTC_ALARM_OR_INTERRUPT, false) == mDot::MDOT_OK) |
SDesign2018 | 27:5db200a4d496 | 826 | { |
SDesign2018 | 27:5db200a4d496 | 827 | pc.printf("Sleep well\n\r"); |
SDesign2018 | 27:5db200a4d496 | 828 | } |
SDesign2018 | 27:5db200a4d496 | 829 | |
SDesign2018 | 26:15df8f054d11 | 830 | } |
SDesign2018 | 26:15df8f054d11 | 831 | |
SDesign2018 | 26:15df8f054d11 | 832 | return 0; |
SDesign2018 | 26:15df8f054d11 | 833 | } |
SDesign2018 | 26:15df8f054d11 | 834 | |
SDesign2018 | 26:15df8f054d11 | 835 | /******************************************************************************* |
SDesign2018 | 26:15df8f054d11 | 836 | * Not really used at the moment |
SDesign2018 | 26:15df8f054d11 | 837 | * Not really needed. But keep just in case because I don't want to rewrite it |
SDesign2018 | 26:15df8f054d11 | 838 | ******************************************************************************/ |
SDesign2018 | 26:15df8f054d11 | 839 | //////////////////////////////////////////////////////////////////////////////// |
SDesign2018 | 26:15df8f054d11 | 840 | char twosComplementConversion(char value) |
SDesign2018 | 26:15df8f054d11 | 841 | { |
SDesign2018 | 26:15df8f054d11 | 842 | /* |
SDesign2018 | 26:15df8f054d11 | 843 | * Go from bit 0 to bit 7 and invert them |
SDesign2018 | 26:15df8f054d11 | 844 | * Then finally add 1 |
SDesign2018 | 26:15df8f054d11 | 845 | */ |
SDesign2018 | 26:15df8f054d11 | 846 | char mask = value & 0x80; |
SDesign2018 | 26:15df8f054d11 | 847 | if(mask == 0x80){ // Check for sign |
SDesign2018 | 26:15df8f054d11 | 848 | value = ~value + 1; |
SDesign2018 | 26:15df8f054d11 | 849 | return value; |
SDesign2018 | 26:15df8f054d11 | 850 | } |
SDesign2018 | 26:15df8f054d11 | 851 | return value; |
SDesign2018 | 26:15df8f054d11 | 852 | } |
SDesign2018 | 26:15df8f054d11 | 853 | //////////////////////////////////////////////////////////////////////////////// |
SDesign2018 | 26:15df8f054d11 | 854 | |
SDesign2018 | 26:15df8f054d11 | 855 | /******************************************************************************* |
SDesign2018 | 26:15df8f054d11 | 856 | * Initializes whatever settings you want for the accelerometer |
SDesign2018 | 26:15df8f054d11 | 857 | * Can change it to use the previous I2C write function instead of all this mess |
SDesign2018 | 26:15df8f054d11 | 858 | * |
SDesign2018 | 26:15df8f054d11 | 859 | ******************************************************************************/ |
SDesign2018 | 26:15df8f054d11 | 860 | //////////////////////////////////////////////////////////////////////////////// |
SDesign2018 | 26:15df8f054d11 | 861 | void ADXL372Initialize(void){ |
SDesign2018 | 26:15df8f054d11 | 862 | ADXL372Reset(); |
SDesign2018 | 26:15df8f054d11 | 863 | pc.printf("Initializing ADXL372 accelerometer\n\r"); |
SDesign2018 | 26:15df8f054d11 | 864 | accelerometerI2CWrite(0x3F, 0x0F); // Enable I2C highspeed,Low Pass, High pass and full bandwidth measurement mode |
SDesign2018 | 26:15df8f054d11 | 865 | accelerometerI2CWrite(0x38, 0x01); // Enable the High pass filter corner 1 at register 0x38 |
SDesign2018 | 26:15df8f054d11 | 866 | accelerometerI2CWrite(0x3E, 0x44); // AutoSleep is enabled with LINKLOOP at DEFAULTMODE , Bandwidth at default, |
SDesign2018 | 26:15df8f054d11 | 867 | |
SDesign2018 | 26:15df8f054d11 | 868 | /* accelerometerI2CWrite(0x24, 0x01); // X used for activity threshold |
SDesign2018 | 26:15df8f054d11 | 869 | accelerometerI2CWrite(0x26, 0x01); // Y used for activity threshold |
SDesign2018 | 26:15df8f054d11 | 870 | accelerometerI2CWrite(0x28, 0x01); // Z used for activity threshold */ |
SDesign2018 | 26:15df8f054d11 | 871 | pc.printf("\n\n\r"); |
SDesign2018 | 26:15df8f054d11 | 872 | } |
SDesign2018 | 26:15df8f054d11 | 873 | //////////////////////////////////////////////////////////////////////////////// |
SDesign2018 | 26:15df8f054d11 | 874 | |
SDesign2018 | 26:15df8f054d11 | 875 | |
SDesign2018 | 26:15df8f054d11 | 876 | /******************************************************************************* |
SDesign2018 | 26:15df8f054d11 | 877 | * ADT7410 Initializing function |
SDesign2018 | 26:15df8f054d11 | 878 | * Make critical temperature 24 celsius |
SDesign2018 | 26:15df8f054d11 | 879 | * Make CRIT pin active high |
SDesign2018 | 26:15df8f054d11 | 880 | ******************************************************************************/ |
SDesign2018 | 26:15df8f054d11 | 881 | //////////////////////////////////////////////////////////////////////////////// |
SDesign2018 | 26:15df8f054d11 | 882 | void ADT7410Initialize(void){ |
SDesign2018 | 26:15df8f054d11 | 883 | pc.printf("Initializing ADT7410 Temperature\n\r"); |
SDesign2018 | 26:15df8f054d11 | 884 | // Make critical temperature be 24 celsius |
SDesign2018 | 26:15df8f054d11 | 885 | ADT7410Write(0x08, 0x01); // MSB of Temperature Crit value |
SDesign2018 | 26:15df8f054d11 | 886 | ADT7410Write(0x09, 0x80); // LSB of Temperature Crit value |
SDesign2018 | 26:15df8f054d11 | 887 | |
SDesign2018 | 26:15df8f054d11 | 888 | // Make CRIT pin active high |
SDesign2018 | 26:15df8f054d11 | 889 | ADT7410Write(0x03, 0x08); // Turn INT HIGH, works for the interrupt pin |
SDesign2018 | 26:15df8f054d11 | 890 | pc.printf("\n\n\r"); |
SDesign2018 | 26:15df8f054d11 | 891 | } |
SDesign2018 | 26:15df8f054d11 | 892 | //////////////////////////////////////////////////////////////////////////////// |
SDesign2018 | 26:15df8f054d11 | 893 | |
SDesign2018 | 26:15df8f054d11 | 894 | /******************************************************************************* |
SDesign2018 | 26:15df8f054d11 | 895 | * ADXL372 reset function |
SDesign2018 | 26:15df8f054d11 | 896 | * Resets all registers and settings back to default |
SDesign2018 | 26:15df8f054d11 | 897 | * Basically the same as the previous ADXL372 I2C write function |
SDesign2018 | 26:15df8f054d11 | 898 | * |
SDesign2018 | 26:15df8f054d11 | 899 | ******************************************************************************/ |
SDesign2018 | 26:15df8f054d11 | 900 | //////////////////////////////////////////////////////////////////////////////// |
SDesign2018 | 26:15df8f054d11 | 901 | void ADXL372Reset(void){ |
SDesign2018 | 26:15df8f054d11 | 902 | int flag; |
SDesign2018 | 26:15df8f054d11 | 903 | //--------- One full writing cycle for ADXL372 for Z Enable ------------------// |
SDesign2018 | 26:15df8f054d11 | 904 | /* '0' - NAK was received |
SDesign2018 | 26:15df8f054d11 | 905 | * '1' - ACK was received, <---- This good |
SDesign2018 | 26:15df8f054d11 | 906 | * '2' - timeout |
SDesign2018 | 26:15df8f054d11 | 907 | */ |
SDesign2018 | 26:15df8f054d11 | 908 | ADXL372.start(); |
SDesign2018 | 26:15df8f054d11 | 909 | flag = ADXL372.write(ADXL372_Address_8bit | 0); |
SDesign2018 | 26:15df8f054d11 | 910 | if(flag == 1) |
SDesign2018 | 26:15df8f054d11 | 911 | { |
SDesign2018 | 26:15df8f054d11 | 912 | //pc.printf("Write to I2C address success\n\r"); |
SDesign2018 | 26:15df8f054d11 | 913 | |
SDesign2018 | 26:15df8f054d11 | 914 | flag = ADXL372.write(0x41); |
SDesign2018 | 26:15df8f054d11 | 915 | if(flag == 1) |
SDesign2018 | 26:15df8f054d11 | 916 | { |
SDesign2018 | 26:15df8f054d11 | 917 | //pc.printf("Write to 0x41 register address success\n\r"); |
SDesign2018 | 26:15df8f054d11 | 918 | flag = ADXL372.write(0x52); // Set bit 0 |
SDesign2018 | 26:15df8f054d11 | 919 | if(flag == 1) |
SDesign2018 | 26:15df8f054d11 | 920 | { |
SDesign2018 | 26:15df8f054d11 | 921 | pc.printf("Everything has been reset\n\r"); |
SDesign2018 | 26:15df8f054d11 | 922 | ADXL372.stop(); |
SDesign2018 | 26:15df8f054d11 | 923 | } |
SDesign2018 | 26:15df8f054d11 | 924 | } |
SDesign2018 | 26:15df8f054d11 | 925 | } |
SDesign2018 | 26:15df8f054d11 | 926 | else ADXL372.stop(); |
SDesign2018 | 26:15df8f054d11 | 927 | // ---------------- End of writing cycle --------------------------// |
SDesign2018 | 26:15df8f054d11 | 928 | } |
SDesign2018 | 26:15df8f054d11 | 929 | //////////////////////////////////////////////////////////////////////////////// |
SDesign2018 | 26:15df8f054d11 | 930 | |
SDesign2018 | 26:15df8f054d11 | 931 | /* |
SDesign2018 | 26:15df8f054d11 | 932 | * |
SDesign2018 | 26:15df8f054d11 | 933 | * Self-test to see if the accelerometer is working as intended |
SDesign2018 | 26:15df8f054d11 | 934 | * Wait 300 ms. |
SDesign2018 | 26:15df8f054d11 | 935 | * Check bit 2 for a 1 for success. Bit 1 for completion of self-test. |
SDesign2018 | 26:15df8f054d11 | 936 | * Returns whole register |
SDesign2018 | 26:15df8f054d11 | 937 | */ |
SDesign2018 | 26:15df8f054d11 | 938 | //////////////////////////////////////////////////////////////////////////////// |
SDesign2018 | 26:15df8f054d11 | 939 | void I2CSelfTest(void){ |
SDesign2018 | 26:15df8f054d11 | 940 | char *result; |
SDesign2018 | 26:15df8f054d11 | 941 | uint8_t check; |
SDesign2018 | 26:15df8f054d11 | 942 | accelerometerI2CWrite(0x3F, 0x0F); |
SDesign2018 | 26:15df8f054d11 | 943 | accelerometerI2CWrite(0x40, 0x01); |
SDesign2018 | 26:15df8f054d11 | 944 | wait(0.3); |
SDesign2018 | 26:15df8f054d11 | 945 | result = accelerometerI2CRead(0x40); |
SDesign2018 | 26:15df8f054d11 | 946 | check = result[0]; |
SDesign2018 | 26:15df8f054d11 | 947 | if(check & 0x04){ |
SDesign2018 | 26:15df8f054d11 | 948 | pc.printf("Passed\n\r"); |
SDesign2018 | 26:15df8f054d11 | 949 | }else {pc.printf("FAILED\n\r");} |
SDesign2018 | 26:15df8f054d11 | 950 | } |
SDesign2018 | 26:15df8f054d11 | 951 | //////////////////////////////////////////////////////////////////////////////// |
SDesign2018 | 26:15df8f054d11 | 952 | |
SDesign2018 | 26:15df8f054d11 | 953 | /******************************************************************************* |
SDesign2018 | 26:15df8f054d11 | 954 | * |
SDesign2018 | 26:15df8f054d11 | 955 | * I2C function for the the ADXL372 accelerometer for a write sequence |
SDesign2018 | 26:15df8f054d11 | 956 | * Param: |
SDesign2018 | 26:15df8f054d11 | 957 | * hexAddress: Pass the hexadecimal value for what register you want |
SDesign2018 | 26:15df8f054d11 | 958 | * hexData: Pass the hexadecimal value for what data you want to send |
SDesign2018 | 26:15df8f054d11 | 959 | * i.e. hexadecimal represenatation of certain bits |
SDesign2018 | 26:15df8f054d11 | 960 | * Returns from mbed library write function |
SDesign2018 | 26:15df8f054d11 | 961 | * 0: NAK was reveived |
SDesign2018 | 26:15df8f054d11 | 962 | * 1: ACK was received <---- Good for us |
SDesign2018 | 26:15df8f054d11 | 963 | * 2: Timeout |
SDesign2018 | 26:15df8f054d11 | 964 | ******************************************************************************/ |
SDesign2018 | 26:15df8f054d11 | 965 | //////////////////////////////////////////////////////////////////////////////// |
SDesign2018 | 26:15df8f054d11 | 966 | void accelerometerI2CWrite(uint8_t hexAddress, uint8_t hexData){ |
SDesign2018 | 26:15df8f054d11 | 967 | |
SDesign2018 | 26:15df8f054d11 | 968 | int flag; |
SDesign2018 | 26:15df8f054d11 | 969 | int registerAddress = hexAddress; |
SDesign2018 | 26:15df8f054d11 | 970 | int data = hexData; |
SDesign2018 | 26:15df8f054d11 | 971 | |
SDesign2018 | 26:15df8f054d11 | 972 | ADXL372.start(); |
SDesign2018 | 26:15df8f054d11 | 973 | flag = ADXL372.write(ADXL372_Address_8bit); |
SDesign2018 | 26:15df8f054d11 | 974 | if(flag == 1) |
SDesign2018 | 26:15df8f054d11 | 975 | { |
SDesign2018 | 26:15df8f054d11 | 976 | //pc.printf("Write to I2C address success\n\r"); |
SDesign2018 | 26:15df8f054d11 | 977 | wait(0.1); |
SDesign2018 | 26:15df8f054d11 | 978 | flag = ADXL372.write(registerAddress); |
SDesign2018 | 26:15df8f054d11 | 979 | if(flag == 1) |
SDesign2018 | 26:15df8f054d11 | 980 | { |
SDesign2018 | 26:15df8f054d11 | 981 | //pc.printf("Write to register 0x%x address success\n\r", registerAddress); |
SDesign2018 | 26:15df8f054d11 | 982 | flag = ADXL372.write(data); |
SDesign2018 | 26:15df8f054d11 | 983 | if(flag == 1) |
SDesign2018 | 26:15df8f054d11 | 984 | { |
SDesign2018 | 26:15df8f054d11 | 985 | pc.printf("Writing data 0x%x to register address 0x%d success\n\r", data, registerAddress); |
SDesign2018 | 26:15df8f054d11 | 986 | ADXL372.stop(); |
SDesign2018 | 26:15df8f054d11 | 987 | return; |
SDesign2018 | 26:15df8f054d11 | 988 | }else {ADXL372.stop();} |
SDesign2018 | 26:15df8f054d11 | 989 | }else {ADXL372.stop();} |
SDesign2018 | 26:15df8f054d11 | 990 | }else ADXL372.stop(); |
SDesign2018 | 26:15df8f054d11 | 991 | |
SDesign2018 | 26:15df8f054d11 | 992 | } |
SDesign2018 | 26:15df8f054d11 | 993 | //////////////////////////////////////////////////////////////////////////////// |
SDesign2018 | 26:15df8f054d11 | 994 | |
SDesign2018 | 26:15df8f054d11 | 995 | /******************************************************************************* |
SDesign2018 | 26:15df8f054d11 | 996 | * I2C read sequence for the accelerometer |
SDesign2018 | 26:15df8f054d11 | 997 | * Param: |
SDesign2018 | 26:15df8f054d11 | 998 | * hexAddress: pass the hexadecimal representation of desired Register address |
SDesign2018 | 26:15df8f054d11 | 999 | * Return: |
SDesign2018 | 26:15df8f054d11 | 1000 | * Char pointer to the array of read data. |
SDesign2018 | 26:15df8f054d11 | 1001 | * |
SDesign2018 | 26:15df8f054d11 | 1002 | * Right now it works only for the XData, YData, ZData because I wrote it to read |
SDesign2018 | 26:15df8f054d11 | 1003 | * 6 bytes(6 registers). |
SDesign2018 | 26:15df8f054d11 | 1004 | * Should change it to be 1 byte at a time |
SDesign2018 | 26:15df8f054d11 | 1005 | ******************************************************************************/ |
SDesign2018 | 26:15df8f054d11 | 1006 | //////////////////////////////////////////////////////////////////////////////// |
SDesign2018 | 26:15df8f054d11 | 1007 | char * accelerometerI2CRead(int hexAddress){ |
SDesign2018 | 26:15df8f054d11 | 1008 | char accelData[6]; |
SDesign2018 | 26:15df8f054d11 | 1009 | char registerAddress[1]; |
SDesign2018 | 26:15df8f054d11 | 1010 | registerAddress[0] = hexAddress; |
SDesign2018 | 26:15df8f054d11 | 1011 | |
SDesign2018 | 26:15df8f054d11 | 1012 | // Perform mbed's way sending a start bit, then device address[r/~w], and then the register address |
SDesign2018 | 26:15df8f054d11 | 1013 | // Also if it succeeds, continue to the next operation |
SDesign2018 | 26:15df8f054d11 | 1014 | if(ADXL372.write(ADXL372_Address_8bit, registerAddress, 1) == 0){ |
SDesign2018 | 26:15df8f054d11 | 1015 | |
SDesign2018 | 26:15df8f054d11 | 1016 | // If previous sequence works, get 6 bytes into char array accelData |
SDesign2018 | 26:15df8f054d11 | 1017 | // Char array because it uses 1 byte(8bits) |
SDesign2018 | 26:15df8f054d11 | 1018 | // Should probably change it to uint8_t type |
SDesign2018 | 26:15df8f054d11 | 1019 | if(ADXL372.read(ADXL372_Address_8bit, accelData, 6) == 0){ |
SDesign2018 | 26:15df8f054d11 | 1020 | return accelData; |
SDesign2018 | 26:15df8f054d11 | 1021 | }else pc.printf("Failed to read\n\r"); |
SDesign2018 | 26:15df8f054d11 | 1022 | }else pc.printf("Failed to write\n\r"); |
SDesign2018 | 26:15df8f054d11 | 1023 | return 0; // Only if it fails completely |
SDesign2018 | 26:15df8f054d11 | 1024 | } |
SDesign2018 | 26:15df8f054d11 | 1025 | //////////////////////////////////////////////////////////////////////////////// |
SDesign2018 | 26:15df8f054d11 | 1026 | |
SDesign2018 | 26:15df8f054d11 | 1027 | |
SDesign2018 | 26:15df8f054d11 | 1028 | |
SDesign2018 | 26:15df8f054d11 | 1029 | |
SDesign2018 | 26:15df8f054d11 | 1030 | /******************************************************************************* |
SDesign2018 | 26:15df8f054d11 | 1031 | * Performs one byte write I2C protocol |
SDesign2018 | 26:15df8f054d11 | 1032 | * PARAM: |
SDesign2018 | 26:15df8f054d11 | 1033 | * registerAddress: register you want access to in device, one byte char hex format |
SDesign2018 | 26:15df8f054d11 | 1034 | * data: one byte data that you want to write to device register |
SDesign2018 | 26:15df8f054d11 | 1035 | * Return results from mbed library function: |
SDesign2018 | 26:15df8f054d11 | 1036 | * 0: failure at writing i2c address |
SDesign2018 | 26:15df8f054d11 | 1037 | * 1: successful write |
SDesign2018 | 26:15df8f054d11 | 1038 | * 2: failure at writing data |
SDesign2018 | 26:15df8f054d11 | 1039 | * |
SDesign2018 | 26:15df8f054d11 | 1040 | ******************************************************************************/ |
SDesign2018 | 26:15df8f054d11 | 1041 | //////////////////////////////////////////////////////////////////////////////// |
SDesign2018 | 26:15df8f054d11 | 1042 | void ADT7410Write(unsigned char registerAddress, unsigned char data){ |
SDesign2018 | 26:15df8f054d11 | 1043 | int flag; |
SDesign2018 | 26:15df8f054d11 | 1044 | ADT7410.start(); |
SDesign2018 | 26:15df8f054d11 | 1045 | flag = ADT7410.write(ADT7410_Address_8BIT); |
SDesign2018 | 26:15df8f054d11 | 1046 | if(flag == 1) |
SDesign2018 | 26:15df8f054d11 | 1047 | { |
SDesign2018 | 26:15df8f054d11 | 1048 | |
SDesign2018 | 26:15df8f054d11 | 1049 | wait(0.1); |
SDesign2018 | 26:15df8f054d11 | 1050 | flag = ADT7410.write(registerAddress); |
SDesign2018 | 26:15df8f054d11 | 1051 | if(flag == 1) |
SDesign2018 | 26:15df8f054d11 | 1052 | { |
SDesign2018 | 26:15df8f054d11 | 1053 | |
SDesign2018 | 26:15df8f054d11 | 1054 | flag = ADT7410.write(data); |
SDesign2018 | 26:15df8f054d11 | 1055 | if(flag == 1) |
SDesign2018 | 26:15df8f054d11 | 1056 | { |
SDesign2018 | 26:15df8f054d11 | 1057 | pc.printf("Writing data 0x%x to register address 0x%x success\n\r", data, registerAddress); |
SDesign2018 | 26:15df8f054d11 | 1058 | ADT7410.stop(); |
SDesign2018 | 26:15df8f054d11 | 1059 | |
SDesign2018 | 26:15df8f054d11 | 1060 | }else {ADT7410.stop();} |
SDesign2018 | 26:15df8f054d11 | 1061 | }else {ADT7410.stop();} |
SDesign2018 | 26:15df8f054d11 | 1062 | }else ADT7410.stop(); |
SDesign2018 | 26:15df8f054d11 | 1063 | |
SDesign2018 | 26:15df8f054d11 | 1064 | |
SDesign2018 | 26:15df8f054d11 | 1065 | } |
SDesign2018 | 26:15df8f054d11 | 1066 | //////////////////////////////////////////////////////////////////////////////// |
SDesign2018 | 26:15df8f054d11 | 1067 | |
SDesign2018 | 26:15df8f054d11 | 1068 | |
SDesign2018 | 26:15df8f054d11 | 1069 | /******************************************************************************* |
SDesign2018 | 26:15df8f054d11 | 1070 | * I2C Read function for ADT7410 Temperature sensor |
SDesign2018 | 26:15df8f054d11 | 1071 | * Param: |
SDesign2018 | 26:15df8f054d11 | 1072 | * hex: hexadecimal representation for desired register |
SDesign2018 | 26:15df8f054d11 | 1073 | * Return: |
SDesign2018 | 26:15df8f054d11 | 1074 | * Char pointer to the array of data values. |
SDesign2018 | 26:15df8f054d11 | 1075 | * Could also change from a char pointer to a uint8_t pointer. |
SDesign2018 | 26:15df8f054d11 | 1076 | * |
SDesign2018 | 26:15df8f054d11 | 1077 | ******************************************************************************/ |
SDesign2018 | 26:15df8f054d11 | 1078 | //////////////////////////////////////////////////////////////////////////////// |
SDesign2018 | 26:15df8f054d11 | 1079 | char * ADT7410Read(int hex){ |
SDesign2018 | 26:15df8f054d11 | 1080 | //short int convertedVal; |
SDesign2018 | 26:15df8f054d11 | 1081 | char data[2] = {0, 0}; |
SDesign2018 | 26:15df8f054d11 | 1082 | char cmd[1]; |
SDesign2018 | 26:15df8f054d11 | 1083 | cmd[0] = hex; |
SDesign2018 | 26:15df8f054d11 | 1084 | //pc.printf("Register Addres is: %x \n\r", cmd[0]); |
SDesign2018 | 26:15df8f054d11 | 1085 | if(ADT7410.write(ADT7410_Address_8BIT, cmd,1) == 0){ |
SDesign2018 | 26:15df8f054d11 | 1086 | if(ADT7410.read(ADT7410_Address_8BIT, data, 2) == 0){ |
SDesign2018 | 26:15df8f054d11 | 1087 | |
SDesign2018 | 26:15df8f054d11 | 1088 | return data; |
SDesign2018 | 26:15df8f054d11 | 1089 | //return (data[0] << 8 | data[1])>>3; // Explained here: https://stackoverflow.com/a/141576 SOOO GREAT |
SDesign2018 | 26:15df8f054d11 | 1090 | |
SDesign2018 | 26:15df8f054d11 | 1091 | }else {pc.printf("Failed to read \n\r"); return data;} |
SDesign2018 | 26:15df8f054d11 | 1092 | }else {pc.printf("Failed to write \n\r"); return data;} |
SDesign2018 | 26:15df8f054d11 | 1093 | |
SDesign2018 | 26:15df8f054d11 | 1094 | } |
SDesign2018 | 26:15df8f054d11 | 1095 | //////////////////////////////////////////////////////////////////////////////// |
SDesign2018 | 26:15df8f054d11 | 1096 | |
SDesign2018 | 26:15df8f054d11 | 1097 |