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@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?

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 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