Denwis La / Mbed OS mDot_Send_Data

This is used for sending Data to receiving mDot

Dependencies:   libmDot-dev-mbed5-deprecated sd-driver ISL29011

Fork of mdot-examples by 3mdeb

send_main.cpp@26:15df8f054d11, 2018-04-01 (annotated)

Committer:
SDesign2018
Date:
Sun Apr 01 21:21:29 2018 +0000
Revision:
26:15df8f054d11
Child:
27:5db200a4d496
Sending package with flags works

Who changed what in which revision?

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