https://github.com/TheRobertTalley/lily ... 0but%20meh
Code: Select all
#include <Adafruit_FONA.h> // https://github.com/botletics/SIM7000-LTE-Shield/tree/master/Code its Tim WOO's
#include <TinyGPS++.h>
#include <SoftwareSerial.h>
#include <FS.h>
#include <SPI.h>
#include <SD.h>
#include <Ticker.h>
#include <HardwareSerial.h>
#include <WiFi.h>
#include <WiFiClientSecure.h>
#include <Adafruit_MQTT.h>
#include <Adafruit_MQTT_Client.h>
#include <Adafruit_MQTT_FONA.h>
/************************* WiFi Access Point *********************************
#define WLAN_SSID ""
#define WLAN_PASS ""
/************************* Adafruit.io Setup *********************************/
#define AIO_SERVER "io.adafruit.com"
#define AIO_SERVERPORT 8883
#define IO_USERNAME ""
#define IO_KEY ""
Adafruit_FONA_LTE fona = Adafruit_FONA_LTE(); //needed for passing fona class to mqtt
/************ Global State (you don't need to change this!) ******************/
// Setup the FONA MQTT class by passing in the FONA class and MQTT server and login details.
Adafruit_MQTT_FONA mqtt(&fona, AIO_SERVER, AIO_SERVERPORT, IO_USERNAME, IO_KEY);
// You don't need to change anything below this line!
#define halt(s) { Serial.println(F( s )); while(1); }
// FONAconnect is a helper function that sets up the FONA and connects to
// the GPRS network. See the fonahelper.cpp tab above for the source!
boolean FONAconnect(const __FlashStringHelper *apn, const __FlashStringHelper *username, const __FlashStringHelper *password);
// How many transmission failures in a row we're willing to be ok with before reset
uint8_t txfailures = 0;
#define MAXTXFAILURES 3
uint32_t x=0;
/****************************** Feeds ****************************************************************************/
// Setup a feed called 'gpslat' for publishing.
// Notice MQTT paths for AIO follow the form: <username>/feeds/<feedname> // This feed is not needed, only setup if you want to see it
const char Battery_FEED[] PROGMEM = IO_USERNAME "/feeds/Battery";
Adafruit_MQTT_Publish batter = Adafruit_MQTT_Publish(&mqtt, Battery_FEED);
const char Solar_FEED[] PROGMEM = IO_USERNAME "/feeds/Solar";
Adafruit_MQTT_Publish lesol = Adafruit_MQTT_Publish(&mqtt, Solar_FEED);
const char gps_FEED[] PROGMEM = IO_USERNAME "/feeds/gpslatlng/csv";
Adafruit_MQTT_Publish gpslatlng = Adafruit_MQTT_Publish(&mqtt, gps_FEED);
//gpslatlng.publish(gpsbuffer); !!!!!!!
/*******************************************************************************************************************/
const int offset = -5; // Eastern Standard Time (USA)
float GPSalt, mv, SV;
char Datetime[12], thetimeo[12], Dateo[20],
latlong1[80], gpsMQTT[80], LAT1[15], LONG1[15], ALTo[15], SpeedO[15],
DAYo[8], MONTHo[8], YEARo[12],
houro[8], minuteo[8], secondo[8];
uint8_t readline(char *buff, uint8_t maxbuff, uint16_t timeout = 0);
uint8_t type;
char replybuffer[255]; // this is a large buffer for replies
char inei[16] = {0}; // MUST use a 16 character buffer for InEI! //AIO wont let me post with IM0000000EI.
#define SIMCOM_7000 //pins for a tcallsim7000x
#define FONA_PWRKEY 5
#define FONA_RST 4
#define FONA_TX 26 // For GSM
#define FONA_RX 27
#define TXPin 32 // For GPS module (NEO-6M)
#define RXPin 33
#define SD_MISO 2
#define SD_MOSI 15
#define SD_SCLK 14
#define SD_CS 13
#define LED_PIN 12
#define BAT_ADC 35
#define SOLAR_ADC 36
#define GPSBaud 9600
#define samplingRate 15 // The time we want to delay after each post (in seconds)
#define timetochill 15000
const double HOME_LAT = 34.27; // Enter Your Latitude and Longitude here
const double HOME_LNG = -83.87; // to track how far away the "Dog" is away from Home
// The TinyGPS++ object
TinyGPSPlus gps;
SoftwareSerial ss(RXPin, TXPin); //gps
HardwareSerial fonaSS(1); //gsm
/**************************************************sleepy time***************************/
#define uS_TO_S_FACTOR 1000000ULL /* Conversion factor for micro seconds to seconds */
#define TIME_TO_SLEEP 150 /* Time ESP32 will go to sleep (in seconds) 300 is 5 min */
RTC_DATA_ATTR int bootCount = 0;
void print_wakeup_reason(){
esp_sleep_wakeup_cause_t wakeup_reason;
wakeup_reason = esp_sleep_get_wakeup_cause();
switch(wakeup_reason)
{
case ESP_SLEEP_WAKEUP_EXT0 : Serial.println("Wakeup caused by external signal using RTC_IO"); break;
case ESP_SLEEP_WAKEUP_EXT1 : Serial.println("Wakeup caused by external signal using RTC_CNTL"); break;
case ESP_SLEEP_WAKEUP_TIMER : Serial.println("Wakeup caused by timer"); break;
case ESP_SLEEP_WAKEUP_TOUCHPAD : Serial.println("Wakeup caused by touchpad"); break;
case ESP_SLEEP_WAKEUP_ULP : Serial.println("Wakeup caused by ULP program"); break;
default : Serial.printf("Wakeup was not caused by deep sleep: %d\n",wakeup_reason); break;
}
}
/*******************************GPSMODuLE POWER STUFF**********************************/
// Send a byte array of UBX protocol to the GPS
void sendUBX(uint8_t *MSG, uint8_t len) {
for(int i=0; i<len; i++) {
ss.write(MSG[i]);
}
//Serial.println();
}
/******************************************************** Void Setup!! ************************************/
void setup(){
Serial.begin(115200);
//Increment boot number and print it every reboot
++bootCount;
Serial.println("Boot number: " + String(bootCount));
//Print the wakeup reason for ESP32
print_wakeup_reason();
esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP * uS_TO_S_FACTOR);
Serial.println("Setup ESP32 to sleep for every " + String(TIME_TO_SLEEP) +
" Seconds");
pinMode(FONA_RST, OUTPUT);
digitalWrite(FONA_RST, HIGH); // Default state
// Turn on the module by pulsing PWRKEY low for a little bit
// This amount of time depends on the specific module that's used
fona.powerOn(FONA_PWRKEY); // Power on the module
ss.begin(GPSBaud);
fonaSS.begin(115200, SERIAL_8N1, FONA_TX, FONA_RX); // baud rate, protocol, ESP32 RX pin, ESP32 TX pin
Serial.println(F("Configuring to 9600 baud"));
fonaSS.println("AT+IPR=9600"); // Set baud rate
delay(100); // Short pause to let the command run
fonaSS.begin(9600, SERIAL_8N1, FONA_TX, FONA_RX); // Switch to 9600
if (! fona.begin(fonaSS)) {
Serial.println(F("Couldn't find FONA"));
while (1); // Don't proceed if it couldn't find the device
}
type = fona.type();
Serial.println(F("FONA is OK"));
Serial.print(F("Found "));
// Set modem to full functionality
fona.setFunctionality(1); // AT+CFUN=1
fona.setNetworkSettings(F("vzwinternet"), F(""), F(""));
fona.setOperatingBand("CAT-M", 13);
fona.setNetLED(false);
// Configure a GPRS APN, username, and password.
// You might need to do this to access your network's GPRS/data
// network. Contact your provider for the exact APN, username,
// and password values. Username and password are optional and
// can be removed, but APN is required.
//fona.setNetworkSettings(F("nxtgenphone"), F("your username"), F("your password"));
//fona.setOperatingBand("CAT-M", 12); // AT&T uses band 12
//fona.setNetworkSettings(F("m2m.com.attz")); // For AT&T IoT SIM card
//fona.setNetworkSettings(F("telstra.internet")); // For Telstra (Australia) SIM card - CAT-M1 (Band 28)
//fona.setNetworkSettings(F("hologram")); // For Hologram SIM card
// Optionally configure HTTP gets to follow redirects over SSL.
// Default is not to follow SSL redirects, however if you uncomment
// the following line then redirects over SSL will be followed.
//fona.setHTTPSRedirect(true);
/*
// Other examples of some things you can set:
fona.setPreferredMode(38); // Use LTE only, not 2G
fona.setPreferredLTEMode(1); // Use LTE CAT-M only, not NB-IoT
fona.setOperatingBand("CAT-M", 12); // AT&T uses band 12
// fona.setOperatingBand("CAT-M", 13); // Verizon uses band 13
fona.enableRTC(true);
fona.enableSleepMode(true);
fona.set_eDRX(1, 4, "0010");
fona.enablePSM(true);
// Set the network status LED blinking pattern while connected to a network (see AT+SLEDS command)
fona.setNetLED(true, 2, 64, 3000); // on/off, mode, timer_on, timer_off
fona.setNetLED(false); // Disable network status LED
*/
//printMenu();
delay(5000);
SPI.begin(SD_SCLK, SD_MISO, SD_MOSI, SD_CS);
if (!SD.begin(SD_CS)) {
Serial.println(" SDCard MOUNT FAIL");
} else {
uint32_t cardSize = SD.cardSize() / (1024 * 1024);
String str = " SDCard Size: " + String(cardSize) + "MB";
Serial.println(str);
}
}
void loop(){
//connectwifi();
//MQTT_connect(); // Run Procedure to connect to Adafruit IO MQTT
getdatGPS();
BatteryFlair();
//readmenu();
//RECtoMQTT();
}
void DistanceToHome() {
float Distance_To_Home; // variable to store Distance to Home
float GPSlat = (gps.location.lat()); // variable to store latitude
float GPSlng = (gps.location.lng()); // variable to store longitude
float GPSalt = (gps.altitude.feet()); // variable to store altitude
Distance_To_Home = (unsigned long)TinyGPSPlus::distanceBetween(gps.location.lat(),gps.location.lng(),HOME_LAT, HOME_LNG); //Query Tiny GPS to Calculate Distance to Home
Serial.println(F(" GPS Tracking"));
Serial.println("---------------------");
Serial.print("GPS Lat: ");
Serial.println(gps.location.lat(), 6); // Display latitude to 6 decimal points
Serial.print("GPS Lon: ");
Serial.println(gps.location.lng(), 6); // Serial longitude to 6 decimal points
Serial.print("Distance: ");
Serial.println(Distance_To_Home); // Distance to Home measured in Meters
}
void getdatGPS()
{
// This sketch displays information every time a new sentence is correctly encoded.
while (ss.available() > 0)
if (gps.encode(ss.read()))
displayInfo();
if (millis() > 5000 && gps.charsProcessed() < 10)
{
Serial.println(F("No GPS detected: check wiring."));
while(true);
}
}
void displayInfo()
{
Serial.print(F("Location: "));
if (gps.location.isValid())
{
Serial.print(gps.location.lat(), 6);
Serial.print(F(","));
Serial.println(gps.location.lng(), 6);
dtostrf(gps.speed.mph(),9,1,SpeedO);
dtostrf(gps.altitude.feet(),5,1,ALTo);
dtostrf(gps.location.lat(),9,7,LAT1);
dtostrf(gps.location.lng(),9,7,LONG1);
sprintf(latlong1, "http://www.google.com/maps/place/%s,%s", LAT1, LONG1);
sprintf(gpsMQTT, "%s,%s,%s,%s",SpeedO, LAT1, LONG1, ALTo);
Serial.println(latlong1);
RECtoSD();
}
else
{
Serial.print(F("INVALID"));
}
Serial.print(F(" Date/Time: "));
if (gps.date.isValid())
{
Serial.print(gps.date.month());
Serial.print(F("/"));
Serial.print(gps.date.day());
Serial.print(F("/"));
Serial.print(gps.date.year());
dtostrf(gps.date.month(),2,0,MONTHo);
dtostrf(gps.date.day(),2,0,DAYo);
dtostrf(gps.date.year(),4,0,YEARo);
sprintf(Dateo, "/%s.%s.%s.txt", MONTHo, DAYo, YEARo);
}
else
{
Serial.print(F("INVALID"));
}
Serial.print(F(" "));
if (gps.time.isValid())
{
if (gps.time.hour() < 10) Serial.print(F("0"));
Serial.print(gps.time.hour());
Serial.print(F(":"));
if (gps.time.minute() < 10) Serial.print(F("0"));
Serial.print(gps.time.minute());
Serial.print(F(":"));
if (gps.time.second() < 10) Serial.print(F("0"));
Serial.print(gps.time.second());
Serial.println(F(" "));
dtostrf(gps.time.hour(),2,0,houro);
dtostrf(gps.time.minute(),2,0,minuteo);
dtostrf(gps.time.second(),2,0,secondo);
sprintf(thetimeo, "%s:%s:%s", houro, minuteo, secondo);
}
else
{
Serial.print(F("INVALID"));
}
Serial.println();
}
void RECtoSD(void) {
Serial.println("\n**********RECORDING to SD and INTERWEBS******************");
appendFile(SD, Dateo, "\n");
appendFile(SD, Dateo, thetimeo);
appendFile(SD, Dateo, "\n");
appendFile(SD, Dateo, latlong1);
appendFile(SD, Dateo, "\n");
RECtoMQTT();
}
void RECtoMQTT() {
MQTT_connect();
gpslatlng.publish(gpsMQTT);
batter.publish(analogRead(BAT_ADC));
lesol.publish(analogRead(SOLAR_ADC));
//GPSpowerdown();
//powerdown();
delay(timetochill);
}
void BatteryFlair() {
MQTT_connect();
//batter.publish(analogRead(BAT_ADC));
batter.publish(analogRead(BAT_ADC));
lesol.publish(analogRead(SOLAR_ADC));
//GPSpowerdown();
//powerdown();
delay(timetochill);
}
void appendFile(fs::FS &fs, const char * path, const char * message){
File file = fs.open(path, FILE_APPEND);
if(!file){
Serial.println("Failed to open file for appending");
return;
}
if(file.print(message)){
} else {
Serial.println("SAVE failed");
}
}
/*************************** connect to WIFI ************************************
void connectwifi() {
Serial.println(); Serial.println();
Serial.print("Connecting to ");
Serial.println(WLAN_SSID);
delay(1000);
WiFi.begin(WLAN_SSID, WLAN_PASS);
delay(2000);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print("."); }
Serial.println();
Serial.println("WiFi connected");
Serial.println("IP address: "); Serial.println(WiFi.localIP());
}
/****************************************************************************************/
void readmenu() {
if (! Serial.available() ) {
if (fona.available()) {
Serial.write(fona.read());
}
}
char command = Serial.read();
//Serial.println(command);
switch (command) {
case '?': {
printMenu();
break;
}
case 'a': {
// read the ADC
uint16_t adc;
if (! fona.getADCVoltage(&adc)) {
Serial.println(F("Failed to read ADC"));
} else {
Serial.print(F("ADC = ")); Serial.print(adc); Serial.println(F(" mV"));
}
break;
}
case 'b': {
// read the battery voltage and percentage
uint16_t vbat;
if (! fona.getBattVoltage(&vbat)) {
Serial.println(F("Failed to read Batt"));
} else {
Serial.print(F("VBat = ")); Serial.print(vbat); Serial.println(F(" mV"));
}
if (type != SIM7500 && type != SIM7600) {
if (! fona.getBattPercent(&vbat)) {
Serial.println(F("Failed to read Batt"));
} else {
Serial.print(F("VPct = ")); Serial.print(vbat); Serial.println(F("%"));
}
}
break;
}
case 'U': {
// Unlock the SIM with a PIN code
char PIN[5];
flushSerial();
Serial.println(F("Enter 4-digit PIN"));
readline(PIN, 3);
Serial.println(PIN);
Serial.print(F("Unlocking SIM card: "));
if (! fona.unlockSIM(PIN)) {
Serial.println(F("Failed"));
} else {
Serial.println(F("OK!"));
}
break;
}
case 'C': {
// read the CCID
fona.getSIMCCID(replybuffer); // make sure replybuffer is at least 21 bytes!
Serial.print(F("SIM CCID = ")); Serial.println(replybuffer);
break;
}
case 'i': {
// read the RSSI
uint8_t n = fona.getRSSI();
int8_t r;
Serial.print(F("RSSI = ")); Serial.print(n); Serial.print(": ");
if (n == 0) r = -115;
if (n == 1) r = -111;
if (n == 31) r = -52;
if ((n >= 2) && (n <= 30)) {
r = map(n, 2, 30, -110, -54);
}
Serial.print(r); Serial.println(F(" dBm"));
break;
}
case 'n': {
// read the network/cellular status
uint8_t n = fona.getNetworkStatus();
Serial.print(F("Network status "));
Serial.print(n);
Serial.print(F(": "));
if (n == 0) Serial.println(F("Not registered"));
if (n == 1) Serial.println(F("Registered (home)"));
if (n == 2) Serial.println(F("Not registered (searching)"));
if (n == 3) Serial.println(F("Denied"));
if (n == 4) Serial.println(F("Unknown"));
if (n == 5) Serial.println(F("Registered roaming"));
break;
}
case '1': {
// Get connection type, cellular band, carrier name, etc.
fona.getNetworkInfo();
break;
}
/*** Calling ***/
case 'c': {
// call a phone!
char number[30];
flushSerial();
Serial.print(F("Call #"));
readline(number, 30);
Serial.println();
Serial.print(F("Calling ")); Serial.println(number);
if (!fona.callPhone(number)) {
Serial.println(F("Failed"));
} else {
Serial.println(F("Sent!"));
}
break;
}
case 'A': {
// get call status
int8_t callstat = fona.getCallStatus();
switch (callstat) {
case 0: Serial.println(F("Ready")); break;
case 1: Serial.println(F("Could not get status")); break;
case 3: Serial.println(F("Ringing (incoming)")); break;
case 4: Serial.println(F("Ringing/in progress (outgoing)")); break;
default: Serial.println(F("Unknown")); break;
}
break;
}
case 'h': {
// hang up!
if (! fona.hangUp()) {
Serial.println(F("Failed"));
} else {
Serial.println(F("OK!"));
}
break;
}
case 'p': {
// pick up!
if (! fona.pickUp()) {
Serial.println(F("Failed"));
} else {
Serial.println(F("OK!"));
}
break;
}
#if !defined(SIMCOM_7000) && !defined(SIMCOM_7070)
/*** Audio ***/
case 'v': {
// set volume
flushSerial();
if ( (type == SIM5320A) || (type == SIM5320E) ) {
Serial.print(F("Set Vol [0-8] "));
} else if (type == SIM7500 || type == SIM7600) {
Serial.print(F("Set Vol [0-5] "));
} else {
Serial.print(F("Set Vol % [0-100] "));
}
uint8_t vol = readnumber();
Serial.println();
if (! fona.setVolume(vol)) {
Serial.println(F("Failed"));
} else {
Serial.println(F("OK!"));
}
break;
}
case 'V': {
uint8_t v = fona.getVolume();
Serial.print(v);
if ( (type == SIM5320A) || (type == SIM5320E) ) {
Serial.println(" / 8");
} else if (type == SIM7500 || type == SIM7600) { // Don't write anything for SIM7500
Serial.println();
} else {
Serial.println("%");
}
break;
}
case 'H': {
// Set Headphone output
if (! fona.setAudio(FONA_HEADSETAUDIO)) {
Serial.println(F("Failed"));
} else {
Serial.println(F("OK!"));
}
fona.setMicVolume(FONA_HEADSETAUDIO, 15);
break;
}
case 'e': {
// Set External output
if (! fona.setAudio(FONA_EXTAUDIO)) {
Serial.println(F("Failed"));
} else {
Serial.println(F("OK!"));
}
fona.setMicVolume(FONA_EXTAUDIO, 10);
break;
}
case 'T': {
// play tone
flushSerial();
Serial.print(F("Play tone #"));
uint8_t kittone = readnumber();
Serial.println();
// play for 1 second (1000 ms)
if (! fona.playToolkitTone(kittone, 1000)) {
Serial.println(F("Failed"));
} else {
Serial.println(F("OK!"));
}
break;
}
/*** PWM ***/
case 'P': {
// PWM Buzzer output @ 2KHz max
flushSerial();
Serial.print(F("PWM Freq, 0 = Off, (1-2000): "));
uint16_t freq = readnumber();
Serial.println();
if (! fona.setPWM(freq)) {
Serial.println(F("Failed"));
} else {
Serial.println(F("OK!"));
}
break;
}
#endif
#ifdef SIMCOM_2G
/*** FM Radio ***/
case 'f': {
// get freq
flushSerial();
Serial.print(F("FM Freq (eg 1011 == 101.1 MHz): "));
uint16_t station = readnumber();
Serial.println();
// FM radio ON using headset
if (fona.FMradio(true, FONA_HEADSETAUDIO)) {
Serial.println(F("Opened"));
}
if (! fona.tuneFMradio(station)) {
Serial.println(F("Failed"));
} else {
Serial.println(F("Tuned"));
}
break;
}
case 'F': {
// FM radio off
if (! fona.FMradio(false)) {
Serial.println(F("Failed"));
} else {
Serial.println(F("OK!"));
}
break;
}
case 'm': {
// Set FM volume.
flushSerial();
Serial.print(F("Set FM Vol [0-6]:"));
uint8_t vol = readnumber();
Serial.println();
if (!fona.setFMVolume(vol)) {
Serial.println(F("Failed"));
} else {
Serial.println(F("OK!"));
}
break;
}
case 'M': {
// Get FM volume.
uint8_t fmvol = fona.getFMVolume();
if (fmvol < 0) {
Serial.println(F("Failed"));
} else {
Serial.print(F("FM volume: "));
Serial.println(fmvol, DEC);
}
break;
}
case 'q': {
// Get FM station signal level (in decibels).
flushSerial();
Serial.print(F("FM Freq (eg 1011 == 101.1 MHz): "));
uint16_t station = readnumber();
Serial.println();
int8_t level = fona.getFMSignalLevel(station);
if (level < 0) {
Serial.println(F("Failed! Make sure FM radio is on (tuned to station)."));
} else {
Serial.print(F("Signal level (dB): "));
Serial.println(level, DEC);
}
break;
}
#endif
/*** SMS ***/
case 'N': {
// read the number of SMS's!
int8_t smsnum = fona.getNumSMS();
if (smsnum < 0) {
Serial.println(F("Could not read # SMS"));
} else {
Serial.print(smsnum);
Serial.println(F(" SMS's on SIM card!"));
}
break;
}
case 'r': {
// read an SMS
flushSerial();
Serial.print(F("Read #"));
uint8_t smsn = readnumber();
Serial.print(F("\n\rReading SMS #")); Serial.println(smsn);
// Retrieve SMS sender address/phone number.
if (! fona.getSMSSender(smsn, replybuffer, 250)) {
Serial.println("Failed!");
break;
}
Serial.print(F("FROM: ")); Serial.println(replybuffer);
// Retrieve SMS value.
uint16_t smslen;
if (! fona.readSMS(smsn, replybuffer, 250, &smslen)) { // pass in buffer and max len!
Serial.println("Failed!");
break;
}
Serial.print(F("***** SMS #")); Serial.print(smsn);
Serial.print(" ("); Serial.print(smslen); Serial.println(F(") bytes *****"));
Serial.println(replybuffer);
Serial.println(F("*****"));
break;
}
case 'R': {
// read all SMS
int8_t smsnum = fona.getNumSMS();
uint16_t smslen;
int8_t smsn;
if ( (type == SIM5320A) || (type == SIM5320E) ) {
smsn = 0; // zero indexed
smsnum--;
} else {
smsn = 1; // 1 indexed
}
for ( ; smsn <= smsnum; smsn++) {
Serial.print(F("\n\rReading SMS #")); Serial.println(smsn);
if (!fona.readSMS(smsn, replybuffer, 250, &smslen)) { // pass in buffer and max len!
Serial.println(F("Failed!"));
break;
}
// if the length is zero, its a special case where the index number is higher
// so increase the max we'll look at!
if (smslen == 0) {
Serial.println(F("[empty slot]"));
smsnum++;
continue;
}
Serial.print(F("***** SMS #")); Serial.print(smsn);
Serial.print(" ("); Serial.print(smslen); Serial.println(F(") bytes *****"));
Serial.println(replybuffer);
Serial.println(F("*****"));
}
break;
}
case 'd': {
// delete an SMS
flushSerial();
Serial.print(F("Delete #"));
uint8_t smsn = readnumber();
Serial.print(F("\n\rDeleting SMS #")); Serial.println(smsn);
if (fona.deleteSMS(smsn)) {
Serial.println(F("OK!"));
} else {
Serial.println(F("Couldn't delete"));
}
break;
}
case 's': {
// send an SMS!
char sendto[21], message[141];
flushSerial();
Serial.print(F("Send to #"));
readline(sendto, 20);
Serial.println(sendto);
Serial.print(F("Type out one-line message (140 char): "));
readline(message, 140);
Serial.println(message);
if (!fona.sendSMS(sendto, message)) {
Serial.println(F("Failed"));
} else {
Serial.println(F("Sent!"));
}
break;
}
case 'u': {
// send a USSD!
char message[141];
flushSerial();
Serial.print(F("Type out one-line message (140 char): "));
readline(message, 140);
Serial.println(message);
uint16_t ussdlen;
if (!fona.sendUSSD(message, replybuffer, 250, &ussdlen)) { // pass in buffer and max len!
Serial.println(F("Failed"));
} else {
Serial.println(F("Sent!"));
Serial.print(F("***** USSD Reply"));
Serial.print(" ("); Serial.print(ussdlen); Serial.println(F(") bytes *****"));
Serial.println(replybuffer);
Serial.println(F("*****"));
}
}
/*** Time ***/
case 'y': {
// enable network time sync
if (!fona.enableRTC(true))
Serial.println(F("Failed to enable"));
break;
}
case 'Y': {
// enable NTP time sync
if (!fona.enableNTPTimeSync(true, F("pool.ntp.org")))
Serial.println(F("Failed to enable"));
break;
}
case 't': {
// read the time
char buffer[23];
fona.getTime(buffer, 23); // make sure replybuffer is at least 23 bytes!
Serial.print(F("Time = ")); Serial.println(buffer);
break;
}
/*********************************** GPS */
case 'o': {
// turn GPS off
if (!fona.enableGPS(false))
Serial.println(F("Failed to turn off"));
break;
}
case 'O': {
// turn GPS on
if (!fona.enableGPS(true))
Serial.println(F("Failed to turn on"));
break;
}
case 'x': {
int8_t stat;
// check GPS fix
stat = fona.GPSstatus();
if (stat < 0)
Serial.println(F("Failed to query"));
if (stat == 0) Serial.println(F("GPS off"));
if (stat == 1) Serial.println(F("No fix"));
if (stat == 2) Serial.println(F("2D fix"));
if (stat == 3) Serial.println(F("3D fix"));
break;
}
case 'L': {
//deleted gps function
}
case 'E': {
flushSerial();
if (type == SIM808_V1) {
Serial.print(F("GPS NMEA output sentences (0 = off, 34 = RMC+GGA, 255 = all)"));
} else {
Serial.print(F("On (1) or Off (0)? "));
}
uint8_t nmeaout = readnumber();
// turn on NMEA output
fona.enableGPSNMEA(nmeaout);
break;
}
/*********************************** GPRS */
case 'g': {
// turn GPRS off
if (!fona.enableGPRS(false))
Serial.println(F("Failed to turn off"));
break;
}
case 'G': {
// turn GPRS off first for SIM7500
#if defined(SIMCOM_7500) || defined (SIMCOM_7600)
fona.enableGPRS(false);
#endif
// turn GPRS on
if (!fona.enableGPRS(true))
Serial.println(F("Failed to turn on"));
break;
}
case 'l': {
// check for GSMLOC (requires GPRS)
uint16_t returncode;
if (!fona.getGSMLoc(&returncode, replybuffer, 250))
Serial.println(F("Failed!"));
if (returncode == 0) {
Serial.println(replybuffer);
} else {
Serial.print(F("Fail code #")); Serial.println(returncode);
}
break;
}
#if !defined(SIMCOM_3G) && !defined(SIMCOM_7500) && !defined(SIMCOM_7600)
// The code below was written by Adafruit and only works on some modules
case 'w': {
// read website URL
uint16_t statuscode;
int16_t length;
char url[80];
flushSerial();
Serial.println(F("URL to read (e.g. dweet.io/get/latest/dweet/for/sim7500test123):"));
Serial.print(F("http://")); readline(url, 79);
Serial.println(url);
Serial.println(F("****"));
if (!fona.HTTP_GET_start(url, &statuscode, (uint16_t *)&length)) {
Serial.println("Failed!");
break;
}
while (length > 0) {
while (fona.available()) {
char c = fona.read();
// Serial.write is too slow, we'll write directly to Serial register!
#if defined(__AVR_ATmega328P__) || defined(__AVR_ATmega168__)
loop_until_bit_is_set(UCSR0A, UDRE0); /* Wait until data register empty. */
UDR0 = c;
#else
Serial.write(c);
#endif
length--;
if (! length) break;
}
}
Serial.println(F("\n****"));
fona.HTTP_GET_end();
break;
}
case 'W': {
// Post data to website
uint16_t statuscode;
int16_t length;
char url[80];
char data[80];
flushSerial();
Serial.println(F("NOTE: in beta! Use simple websites to post!"));
Serial.println(F("URL to post (e.g. httpbin.org/post):"));
Serial.print(F("http://")); readline(url, 79);
Serial.println(url);
Serial.println(F("Data to post (e.g. \"foo\" or \"{\"simple\":\"json\"}\"):"));
readline(data, 79);
Serial.println(data);
Serial.println(F("****"));
if (!fona.HTTP_POST_start(url, F("text/plain"), (uint8_t *) data, strlen(data), &statuscode, (uint16_t *)&length)) {
Serial.println("Failed!");
break;
}
while (length > 0) {
while (fona.available()) {
char c = fona.read();
#if defined(__AVR_ATmega328P__) || defined(__AVR_ATmega168__)
loop_until_bit_is_set(UCSR0A, UDRE0); /* Wait until data register empty. */
UDR0 = c;
#else
Serial.write(c);
#endif
length--;
if (! length) break;
}
}
Serial.println(F("\n****"));
fona.HTTP_POST_end();
break;
}
#endif
#if defined(SIMCOM_2G) || defined(SIMCOM_7000)
case '2': {
// Post data to website via 2G or LTE CAT-M/NB-IoT
float temperature = analogRead(A0)*1.23; // Change this to suit your needs
uint16_t battLevel = 3600; // Dummy voltage in mV for testing
// Create char buffers for the floating point numbers for sprintf
// Make sure these buffers are long enough for your request URL
char URL[150];
char body[100];
char tempBuff[16];
char battLevelBuff[16];
// Format the floating point numbers as needed
dtostrf(temperature, 1, 2, tempBuff); // float_val, min_width, digits_after_decimal, char_buffer
dtostrf(battLevel, 1, 0, battLevelBuff);
// Construct the appropriate URL's and body, depending on request type
// Use InEI as device ID for this example
// GET request
sprintf(URL, "dweet.io/dweet/for/%s?temp=%s&batt=%s", inei, tempBuff, battLevelBuff); // No need to specify http:// or https://
// sprintf(URL, "http://dweet.io/dweet/for/%s?temp=%s&batt=%s", inei, tempBuff, battLevelBuff); // But this works too
if (!fona.postData("GET", URL))
Serial.println(F("Failed to complete HTTP GET..."));
// POST request
/*
sprintf(URL, "http://dweet.io/dweet/for/%s", inei);
sprintf(body, "{\"temp\":%s,\"batt\":%s}", tempBuff, battLevelBuff);
if (!fona.postData("POST", URL, body)) // Can also add authorization token parameter!
Serial.println(F("Failed to complete HTTP POST..."));
*/
break;
}
#endif
#if defined(SIMCOM_3G) || defined(SIMCOM_7500) || defined(SIMCOM_7600)
case '3': {
// Post data to website via 3G or 4G LTE
float temperature = analogRead(A0)*1.23; // Change this to suit your needs
// Voltage in mV, just for testing. Use the read battery function instead for real applications.
uint16_t battLevel = 3700;
// Create char buffers for the floating point numbers for sprintf
// Make sure these buffers are long enough for your request URL
char URL[150];
char tempBuff[16];
char battLevelBuff[16];
// Format the floating point numbers as needed
dtostrf(temperature, 1, 2, tempBuff); // float_val, min_width, digits_after_decimal, char_buffer
dtostrf(battLevel, 1, 0, battLevelBuff);
// Construct the appropriate URL's and body, depending on request type
// Use InEI as device ID for this example
// GET request
sprintf(URL, "GET /dweet/for/%s?temp=%s&batt=%s HTTP/1.1\r\nHost: dweet.io\r\n\r\n", inei, tempBuff, battLevelBuff);
if (!fona.postData("www.dweet.io", 443, "HTTPS", URL)) // Server, port, connection type, URL
Serial.println(F("Failed to complete HTTP/HTTPS request..."));
break;
}
#endif
/*****************************************/
case 'S': {
Serial.println(F("Creating SERIAL TUBE"));
while (1) {
while (Serial.available()) {
delay(1);
fona.write(Serial.read());
}
if (fona.available()) {
Serial.write(fona.read());
}
}
break;
}
default: {
return;
}
}
// flush input
flushSerial();
while (fona.available()) {
Serial.write(fona.read());
}
}
void flushSerial() {
while (Serial.available())
Serial.read();
}
char readBlocking() {
while (!Serial.available());
return Serial.read();
}
uint16_t readnumber() {
uint16_t x = 0;
char c;
while (! isdigit(c = readBlocking())) {
//Serial.print(c);
}
Serial.print(c);
x = c - '0';
while (isdigit(c = readBlocking())) {
Serial.print(c);
x *= 10;
x += c - '0';
}
return x;
}
uint8_t readline(char *buff, uint8_t maxbuff, uint16_t timeout) {
uint16_t buffidx = 0;
boolean timeoutvalid = true;
if (timeout == 0) timeoutvalid = false;
while (true) {
if (buffidx > maxbuff) {
//Serial.println(F("SPACE"));
break;
}
while (Serial.available()) {
char c = Serial.read();
//Serial.print(c, HEX); Serial.print("#"); Serial.println(c);
if (c == '\r') continue;
if (c == 0xA) {
if (buffidx == 0) // the first 0x0A is ignored
continue;
timeout = 0; // the second 0x0A is the end of the line
timeoutvalid = true;
break;
}
buff[buffidx] = c;
buffidx++;
}
if (timeoutvalid && timeout == 0) {
//Serial.println(F("TIMEOUT"));
break;
}
delay(1);
}
buff[buffidx] = 0; // null term
return buffidx;
}
/*********************************************************mqtt connect *****************************************/
// will crash like a MOFO over LTE!!!
void MQTT_connect() {
int8_t ret;
// Stop if already connected.
if (mqtt.connected()) {
return;
}
Serial.print("Connecting to MQTT... ");
while ((ret = mqtt.connect()) != 0) { // connect will return 0 for connected
Serial.println(mqtt.connectErrorString(ret));
Serial.println("Retrying MQTT connection in 5 seconds...");
mqtt.disconnect();
delay(5000); // wait 5 seconds
}
Serial.println("MQTT Connected!");
}
/************************************************************************************************************/
void printMenu(void) {
Serial.println(F("-------------------------------------"));
// General
Serial.println(F("[?] Print this menu"));
Serial.println(F("[a] Read the ADC; 2.8V max for SIM800/808, 0V-VBAT for SIM7000 shield"));
Serial.println(F("[b] Read supply voltage")); // Will also give battery % charged for most modules
Serial.println(F("[C] Read the SIM CCID"));
Serial.println(F("[U] Unlock SIM with PIN code"));
Serial.println(F("[i] Read signal strength (RSSI)"));
Serial.println(F("[n] Get network status"));
Serial.println(F("[1] Get network connection info")); // See what connection type and band you're on!
#if !defined(SIMCOM_7000) && !defined(SIMCOM_7070)
// Audio
Serial.println(F("[v] Set audio Volume"));
Serial.println(F("[V] Get volume"));
Serial.println(F("[H] Set headphone audio (SIM800/808)"));
Serial.println(F("[e] Set external audio (SIM800/808)"));
Serial.println(F("[T] Play audio Tone"));
Serial.println(F("[P] PWM/buzzer out (SIM800/808)"));
#endif
// Calling
Serial.println(F("[c] Make phone Call"));
Serial.println(F("[A] Get call status"));
Serial.println(F("[h] Hang up phone"));
Serial.println(F("[p] Pick up phone"));
#ifdef SIMCOM_2G
// FM (SIM800 only!)
Serial.println(F("[f] Tune FM radio (SIM800)"));
Serial.println(F("[F] Turn off FM (SIM800)"));
Serial.println(F("[m] Set FM volume (SIM800)"));
Serial.println(F("[M] Get FM volume (SIM800)"));
Serial.println(F("[q] Get FM station signal level (SIM800)"));
#endif
// SMS
Serial.println(F("[N] Number of SMS's"));
Serial.println(F("[r] Read SMS #"));
Serial.println(F("[R] Read all SMS"));
Serial.println(F("[d] Delete SMS #"));
Serial.println(F("[s] Send SMS"));
Serial.println(F("[u] Send USSD"));
// Time
Serial.println(F("[y] Enable local time stamp (SIM800/808/70X0)"));
Serial.println(F("[Y] Enable NTP time sync (SIM800/808/70X0)")); // Need to use "G" command first!
Serial.println(F("[t] Get network time")); // Works just by being connected to network
// Data Connection
Serial.println(F("[G] Enable cellular data"));
Serial.println(F("[g] Disable cellular data"));
Serial.println(F("[l] Query GSMLOC (2G)"));
#if !defined(SIMCOM_3G) && !defined(SIMCOM_7500) && !defined(SIMCOM_7600)
Serial.println(F("[w] Read webpage"));
Serial.println(F("[W] Post to website"));
#endif
// The following option below posts dummy data to dweet.io for demonstration purposes. See the
// IoT_example sketch for an actual application of this function!
Serial.println(F("[2] Post to dweet.io - 2G / LTE CAT-M / NB-IoT")); // SIM800/808/900/7000/7070
Serial.println(F("[3] Post to dweet.io - 3G / 4G LTE")); // SIM5320/7500/7600
// GPS
if (type >= SIM808_V1) {
Serial.println(F("[O] Turn GPS on (SIM808/5320/7XX0)"));
Serial.println(F("[o] Turn GPS off (SIM808/5320/7XX0)"));
Serial.println(F("[L] Query GPS location (SIM808/5320/7XX0)"));
if (type == SIM808_V1) {
Serial.println(F("[x] GPS fix status (FONA808 v1 only)"));
}
Serial.println(F("[E] Raw NMEA out (SIM808)"));
}
Serial.println(F("[S] Create serial passthru tunnel"));
Serial.println(F("-------------------------------------"));
Serial.println(F(""));
}
void GPSpowerdown() {
//Set GPS to save power by turning off antenna and such
uint8_t GPSoff[] = {0xB5, 0x62, 0x06, 0x04, 0x04, 0x00, 0x00, 0x00,0x08, 0x00, 0x16, 0x74};
sendUBX(GPSoff, sizeof(GPSoff)/sizeof(uint8_t));
}
void GPSpowerUP() {
//Set GPS to Power up
uint8_t GPSon[] = {0xB5, 0x62, 0x06, 0x04, 0x04, 0x00, 0x00, 0x00,0x09, 0x00, 0x17, 0x76};
sendUBX(GPSon, sizeof(GPSon)/sizeof(uint8_t));
}
void powerdown() {
Serial.println("Going to sleep now");
Serial.flush();
esp_deep_sleep_start();
Serial.println("This will never be printed");
}
the error i get is:
https://github.com/TheRobertTalley/lily ... rash%20log
Code: Select all
<---
---> AT
<---
---> AT
<---
---> AT
<---
---> AT
<---
---> AT
<---
---> AT
<---
---> AT
<--- +CPIN: READY
---> AT
<--- AT
---> AT
<--- AT
---> ATE0
<--- ATE0
---> ATE0
<--- OK
---> AT+GMR
<--- Revision:1529B04SIM7000G
OK
---> AT+CPMS="SM","SM","SM"
<--- +CPMS: 0,0,0,0,0,0
FONA is OK
Found ---> AT+CFUN=1
<--- OK
---> AT+CGDCONT=1,"IP","vzwinternet"
<--- OK
---> AT+CBANDCFG="CAT-M",13
<--- OK
---> AT+CNETLIGHT=0
<--- OK
SDCard MOUNT FAIL
Location: INVALID Date/Time: 0/0/2000 00:00:00
Location: INVALID Date/Time: 0/0/2000 00:00:00
Guru Meditation Error: Core 1 panic'ed (LoadProhibited). Exception was unhandled.
Core 1 register dump:
PC : 0x400893d8 PS : 0x00060130 A0 : 0x800d224d A1 : 0x3ffb1e70
A2 : 0x3ffb1ea8 A3 : 0x00000000 A4 : 0x0000000a A5 : 0x3ffb1f0c
A6 : 0x00000020 A7 : 0x00000005 A8 : 0x3ffb1eb4 A9 : 0x00000000
A10 : 0x3ffb1eb1 A11 : 0x3ffb1eb1 A12 : 0x0000000a A13 : 0x0000ff00
A14 : 0x00ff0000 A15 : 0xff000000 SAR : 0x00000010 EXCCAUSE: 0x0000001c
EXCVADDR: 0x00000000 LBEG : 0x400889e4 LEND : 0x40088a00 LCOUNT : 0x00000000
ELF file SHA256: 0000000000000000
Backtrace: 0x400893d8:0x3ffb1e70 0x400d224a:0x3ffb1e90 0x400d1542:0x3ffb1f30 0x400d19a0:0x3ffb1f50 0x400d1a23:0x3ffb1f70 0x400d1ef2:0x3ffb1f90 0x400d84c1:0x3ffb1fb0 0x4008b38e:0x3ffb1fd0
Rebooting...Thanks!
-Talley
