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@31:79940947df2c, 2018-04-14 (annotated)

Committer:
SDesign2018
Date:
Sat Apr 14 18:20:55 2018 +0000
Revision:
31:79940947df2c
Parent:
30:218c795a8081 
SD card functionality isn't working as wanted. Was working before.; Add method to send longitude and latitude floats.

Who changed what in which revision?

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