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@28:29702434319d, 2018-04-10 (annotated)

Committer:
SDesign2018
Date:
Tue Apr 10 23:51:44 2018 +0000
Revision:
28:29702434319d
Parent:
27:5db200a4d496
Child:
29:0f0a059f023e
axis offsets work.; Need to work on sd card shit cuz it sucks

Who changed what in which revision?

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