Browse Source
Merge pull request #84 from EnviroDIY/master
Re-creation of XBee pull requestv_master
Volodymyr Shymanskyy
7 years ago
committed by
GitHub
GitHub
24 changed files with 890 additions and 71 deletions
Split View
Diff Options
-
+6 -0.gitignore
-
+14 -2.travis.yml
-
+21 -20README.md
-
+5 -1TinyGsmClient.h
-
+30 -4TinyGsmClientA6.h
-
+84 -6TinyGsmClientESP8266.h
-
+30 -4TinyGsmClientM590.h
-
+28 -6TinyGsmClientSIM800.h
-
+633 -0TinyGsmClientXBee.h
-
+1 -0TinyGsmCommon.h
-
BINdoc/Digi XBee LTEC1 Users Guide - 90001525.pdf
-
BINdoc/Digi XBee S6B Users Guide - 90002180.pdf
-
BINdoc/ESP8266 - AT Instruction Set.pdf
-
BINdoc/ESP8266 - Datasheet v4.3.pdf
-
BINdoc/ESP8266 - Low Power Solutions.pdf
-
BINdoc/SIM800 AT Commands v1.11.pdf
-
+1 -1examples/BlynkClient/BlynkClient.ino
-
+1 -1examples/FileDownload/FileDownload.ino
-
+1 -1examples/MqttClient/MqttClient.ino
-
+0 -1examples/WebClient/WebClient.ino
-
+4 -1tools/AT_Debug/AT_Debug.ino
-
+2 -1tools/Diagnostics/Diagnostics.ino
-
+2 -0tools/FactoryReset/FactoryReset.ino
-
+27 -22tools/test_build/test_build.ino
+ 6
- 0
.gitignore
View File
+ 14
- 2
.travis.yml
View File
+ 21
- 20
README.md
View File
+ 5
- 1
TinyGsmClient.h
View File
+ 30
- 4
TinyGsmClientA6.h
View File
+ 84
- 6
TinyGsmClientESP8266.h
View File
+ 30
- 4
TinyGsmClientM590.h
View File
+ 28
- 6
TinyGsmClientSIM800.h
View File
+ 633
- 0
TinyGsmClientXBee.h
View File
| @ -0,0 +1,633 @@ | |||
| /** | |||
| * @file TinyWiFiClientESP8266.h | |||
| * @author Volodymyr Shymanskyy | |||
| * @license LGPL-3.0 | |||
| * @copyright Copyright (c) 2016 Volodymyr Shymanskyy | |||
| * @date Nov 2016 | |||
| */ | |||
| #ifndef TinyGsmClientXBee_h | |||
| #define TinyGsmClientXBee_h | |||
| // #define TINY_GSM_DEBUG Serial | |||
| #if !defined(TINY_GSM_RX_BUFFER) | |||
| #define TINY_GSM_RX_BUFFER 256 | |||
| #endif | |||
| #define TINY_GSM_MUX_COUNT 1 // Multi-plexing isn't supported using command mode | |||
| #include <TinyGsmCommon.h> | |||
| #define GSM_NL "\r" | |||
| static const char GSM_OK[] TINY_GSM_PROGMEM = "OK" GSM_NL; | |||
| static const char GSM_ERROR[] TINY_GSM_PROGMEM = "ERROR" GSM_NL; | |||
| enum SimStatus { | |||
| SIM_ERROR = 0, | |||
| SIM_READY = 1, | |||
| SIM_LOCKED = 2, | |||
| }; | |||
| enum XBeeType { | |||
| S6B = 0, | |||
| LTEC1 = 1, | |||
| }; | |||
| enum RegStatus { | |||
| REG_UNREGISTERED = 0, | |||
| REG_SEARCHING = 2, | |||
| REG_DENIED = 3, | |||
| REG_OK_HOME = 1, | |||
| REG_OK_ROAMING = 5, | |||
| REG_UNKNOWN = 4, | |||
| }; | |||
| class TinyGsm | |||
| { | |||
| public: | |||
| TinyGsm(Stream& stream) | |||
| : stream(stream) | |||
| {} | |||
| public: | |||
| class GsmClient : public Client | |||
| { | |||
| friend class TinyGsm; | |||
| public: | |||
| GsmClient() {} | |||
| GsmClient(TinyGsm& modem, uint8_t mux = 0) { | |||
| init(&modem, mux); | |||
| } | |||
| bool init(TinyGsm* modem, uint8_t mux = 0) { | |||
| this->at = modem; | |||
| this->mux = mux; | |||
| sock_connected = false; | |||
| at->sockets[mux] = this; | |||
| return true; | |||
| } | |||
| public: | |||
| virtual int connect(const char *host, uint16_t port) { | |||
| at->streamClear(); // Empty anything remaining in the buffer; | |||
| at->commandMode(); | |||
| sock_connected = at->modemConnect(host, port, mux); | |||
| at->writeChanges(); | |||
| at->exitCommand(); | |||
| return sock_connected; | |||
| } | |||
| virtual int connect(IPAddress ip, uint16_t port) { | |||
| at->streamClear(); // Empty anything remaining in the buffer; | |||
| at->commandMode(); | |||
| sock_connected = at->modemConnect(ip, port, mux); | |||
| at->writeChanges(); | |||
| at->exitCommand(); | |||
| return sock_connected; | |||
| } | |||
| // This is a hack to shut the socket by setting the timeout to zero and | |||
| // then sending an empty line to the server. | |||
| virtual void stop() { | |||
| at->commandMode(); | |||
| at->sendAT(GF("TM0")); // Set socket timeout to 0; | |||
| at->waitResponse(); | |||
| at->writeChanges(); | |||
| at->exitCommand(); | |||
| at->modemSend("", 1, mux); | |||
| at->streamClear(); // Empty anything remaining in the buffer; | |||
| at->commandMode(); | |||
| at->sendAT(GF("TM64")); // Set socket timeout back to 10seconds; | |||
| at->waitResponse(); | |||
| at->writeChanges(); | |||
| at->exitCommand(); | |||
| at->streamClear(); // Empty anything remaining in the buffer; | |||
| sock_connected = false; | |||
| } | |||
| virtual size_t write(const uint8_t *buf, size_t size) { | |||
| return at->modemSend(buf, size, mux); | |||
| } | |||
| virtual size_t write(uint8_t c) { | |||
| return write(&c, 1); | |||
| } | |||
| virtual int available() { | |||
| return at->stream.available(); | |||
| } | |||
| virtual int read(uint8_t *buf, size_t size) { | |||
| return available(); | |||
| } | |||
| virtual int read() { | |||
| TINY_GSM_YIELD(); | |||
| return at->stream.read(); | |||
| } | |||
| virtual int peek() { return at->stream.peek(); } | |||
| virtual void flush() { at->stream.flush(); } | |||
| virtual uint8_t connected() { | |||
| if (available()) { | |||
| return true; | |||
| } | |||
| return sock_connected; | |||
| } | |||
| virtual operator bool() { return connected(); } | |||
| private: | |||
| TinyGsm* at; | |||
| uint8_t mux; | |||
| bool sock_connected; | |||
| }; | |||
| public: | |||
| /* | |||
| * Basic functions | |||
| */ | |||
| bool begin() { | |||
| return init(); | |||
| } | |||
| bool init() { | |||
| guardTime = 1100; | |||
| commandMode(); | |||
| sendAT(GF("AP0")); // Put in transparent mode | |||
| waitResponse(); | |||
| sendAT(GF("GT64")); // shorten the guard time to 100ms | |||
| waitResponse(); | |||
| writeChanges(); | |||
| sendAT(GF("HS")); // Get the "Hardware Series"; 0x601 for S6B (Wifi) | |||
| // wait for the response | |||
| unsigned long startMillis = millis(); | |||
| while (!stream.available() && millis() - startMillis < 1000) {}; | |||
| String res = streamReadUntil('\r'); // Does not send an OK, just the result | |||
| exitCommand(); | |||
| if (res == "601") beeType = S6B; | |||
| else beeType = LTEC1; | |||
| guardTime = 125; | |||
| return true; | |||
| } | |||
| bool autoBaud(unsigned long timeout = 10000L) { // not supported | |||
| return false; | |||
| } | |||
| void maintain() {} | |||
| bool factoryDefault() { | |||
| commandMode(); | |||
| sendAT(GF("RE")); | |||
| bool ret_val = waitResponse() == 1; | |||
| writeChanges(); | |||
| exitCommand(); | |||
| return ret_val; | |||
| } | |||
| /* | |||
| * Power functions | |||
| */ | |||
| bool restart() { | |||
| commandMode(); | |||
| sendAT(GF("FR")); | |||
| if (waitResponse() != 1) { | |||
| return false; | |||
| } | |||
| delay (2000); // Actually resets about 2 seconds later | |||
| for (unsigned long start = millis(); millis() - start < 60000L; ) { | |||
| if (commandMode()) { | |||
| exitCommand(); | |||
| return true; | |||
| } | |||
| } | |||
| exitCommand(); | |||
| return false;; | |||
| } | |||
| void setupPinSleep() { | |||
| commandMode(); | |||
| sendAT(GF("SM"),1); | |||
| waitResponse(); | |||
| sendAT(GF("SO"),200); | |||
| waitResponse(); | |||
| writeChanges(); | |||
| exitCommand(); | |||
| } | |||
| /* | |||
| * SIM card functions | |||
| */ | |||
| bool simUnlock(const char *pin) { // Not supported | |||
| return false; | |||
| } | |||
| String getSimCCID() { | |||
| commandMode(); | |||
| sendAT(GF("S#")); | |||
| // wait for the response | |||
| unsigned long startMillis = millis(); | |||
| while (!stream.available() && millis() - startMillis < 1000) {}; | |||
| String res = streamReadUntil('\r'); // Does not send an OK, just the result | |||
| exitCommand(); | |||
| return res; | |||
| } | |||
| String getIMEI() { | |||
| commandMode(); | |||
| sendAT(GF("IM")); | |||
| // wait for the response | |||
| unsigned long startMillis = millis(); | |||
| while (!stream.available() && millis() - startMillis < 1000) {}; | |||
| String res = streamReadUntil('\r'); // Does not send an OK, just the result | |||
| exitCommand(); | |||
| return res; | |||
| } | |||
| SimStatus getSimStatus(unsigned long timeout = 10000L) { | |||
| return SIM_READY; // unsupported | |||
| } | |||
| RegStatus getRegistrationStatus() { | |||
| commandMode(); | |||
| if (beeType == S6B) sendAT(GF("AI")); | |||
| else sendAT(GF("CI")); | |||
| // wait for the response | |||
| unsigned long startMillis = millis(); | |||
| while (!stream.available() && millis() - startMillis < 1000) {}; | |||
| String res = streamReadUntil('\r'); // Does not send an OK, just the result | |||
| exitCommand(); | |||
| if(res == GF("0")) | |||
| return REG_OK_HOME; | |||
| else if(res == GF("13") || res == GF("2A")) | |||
| return REG_UNREGISTERED; | |||
| else if(res == GF("FF") || res == GF("22") || res == GF("23") || | |||
| res == GF("40") || res == GF("41") || res == GF("42")) | |||
| return REG_SEARCHING; | |||
| else if(res == GF("24")) | |||
| return REG_DENIED; | |||
| else return REG_UNKNOWN; | |||
| } | |||
| String getOperator() { | |||
| commandMode(); | |||
| sendAT(GF("MN")); | |||
| // wait for the response | |||
| unsigned long startMillis = millis(); | |||
| while (!stream.available() && millis() - startMillis < 1000) {}; | |||
| String res = streamReadUntil('\r'); // Does not send an OK, just the result | |||
| exitCommand(); | |||
| return res; | |||
| } | |||
| /* | |||
| * Generic network functions | |||
| */ | |||
| int getSignalQuality() { | |||
| commandMode(); | |||
| if (beeType == S6B) sendAT(GF("LM")); // ask for the "link margin" - the dB above sensitivity | |||
| else sendAT(GF("DB")); // ask for the cell strenght in dBm | |||
| // wait for the response | |||
| unsigned long startMillis = millis(); | |||
| while (!stream.available() && millis() - startMillis < 1000) {}; | |||
| char buf[2] = {0}; // Set up buffer for response | |||
| buf[0] = streamRead(); | |||
| buf[1] = streamRead(); | |||
| DBG(buf[0], buf[1], "\n"); | |||
| exitCommand(); | |||
| int intr = strtol(buf, 0, 16); | |||
| if (beeType == S6B) return -93 + intr; // the maximum sensitivity is -93dBm | |||
| else return -1*intr; // need to convert to negative number | |||
| } | |||
| bool waitForNetwork(unsigned long timeout = 60000L) { | |||
| for (unsigned long start = millis(); millis() - start < timeout; ) { | |||
| commandMode(); | |||
| if (beeType == S6B) sendAT(GF("AI")); | |||
| else sendAT(GF("CI")); | |||
| // wait for the response | |||
| unsigned long startMillis = millis(); | |||
| while (!stream.available() && millis() - startMillis < 1000) {}; | |||
| String res = streamReadUntil('\r'); // Does not send an OK, just the result | |||
| exitCommand(); | |||
| if (res == GF("0")) { | |||
| return true; | |||
| } | |||
| delay(1000); | |||
| } | |||
| return false; | |||
| } | |||
| /* | |||
| * WiFi functions | |||
| */ | |||
| bool networkConnect(const char* ssid, const char* pwd) { | |||
| commandMode(); | |||
| sendAT(GF("EE"), 2); // Set security to WPA2 | |||
| waitResponse(); | |||
| sendAT(GF("ID"), ssid); | |||
| if (waitResponse() != 1) { | |||
| goto fail; | |||
| } | |||
| sendAT(GF("PK"), pwd); | |||
| if (waitResponse() != 1) { | |||
| goto fail; | |||
| } | |||
| writeChanges(); | |||
| exitCommand(); | |||
| return true; | |||
| fail: | |||
| exitCommand(); | |||
| return false; | |||
| } | |||
| bool networkDisconnect() { | |||
| return false; // Doesn't support disconnecting | |||
| } | |||
| String getLocalIP() { | |||
| commandMode(); | |||
| sendAT(GF("MY")); | |||
| String IPaddr; IPaddr.reserve(16); | |||
| // wait for the response | |||
| unsigned long startMillis = millis(); | |||
| while (stream.available() < 8 && millis() - startMillis < 30000) {}; | |||
| IPaddr = streamReadUntil('\r'); // read result | |||
| return IPaddr; | |||
| } | |||
| IPAddress localIP() { | |||
| String strIP = getLocalIP(); | |||
| int Parts[4] = {0,0,0,0}; | |||
| int Part = 0; | |||
| for (uint8_t i=0; i<strIP.length(); i++) { | |||
| char c = strIP[i]; | |||
| if (c == '.') { | |||
| Part++; | |||
| continue; | |||
| } | |||
| Parts[Part] *= 10; | |||
| Parts[Part] += c - '0'; | |||
| } | |||
| IPAddress res(Parts[0], Parts[1], Parts[2], Parts[3]); | |||
| return res; | |||
| } | |||
| /* | |||
| * GPRS functions | |||
| */ | |||
| bool gprsConnect(const char* apn, const char* user = "", const char* pw = "") { | |||
| commandMode(); | |||
| sendAT(GF("AN"), apn); // Set the APN | |||
| waitResponse(); | |||
| writeChanges(); | |||
| exitCommand(); | |||
| return true; | |||
| } | |||
| bool gprsDisconnect() { // TODO | |||
| return false; | |||
| } | |||
| /* | |||
| * Messaging functions | |||
| */ | |||
| void sendUSSD() { | |||
| } | |||
| void sendSMS() { | |||
| } | |||
| bool sendSMS(const String& number, const String& text) { | |||
| commandMode(); | |||
| sendAT(GF("IP"), 2); // Put in text messaging mode | |||
| waitResponse(); | |||
| sendAT(GF("PH"), number); // Set the phone number | |||
| waitResponse(); | |||
| sendAT(GF("TDD")); // Set the text delimiter to the standard 0x0D (carriabe return) | |||
| waitResponse(); | |||
| writeChanges(); | |||
| exitCommand(); | |||
| stream.print(text); | |||
| stream.write((char)0x0D); // close off with the carriage return | |||
| return true; | |||
| } | |||
| private: | |||
| int modemConnect(const char* host, uint16_t port, uint8_t mux = 0) { | |||
| sendAT(GF("LA"), host); | |||
| String strIP; strIP.reserve(16); | |||
| // wait for the response | |||
| unsigned long startMillis = millis(); | |||
| while (stream.available() < 8 && millis() - startMillis < 30000) {}; | |||
| strIP = streamReadUntil('\r'); // read result | |||
| int Parts[4] = {0,0,0,0}; | |||
| int Part = 0; | |||
| for (uint8_t i=0; i<strIP.length(); i++) { | |||
| char c = strIP[i]; | |||
| if (c == '.') { | |||
| Part++; | |||
| continue; | |||
| } | |||
| Parts[Part] *= 10; | |||
| Parts[Part] += c - '0'; | |||
| } | |||
| IPAddress res(Parts[0], Parts[1], Parts[2], Parts[3]); | |||
| return modemConnect(res, port); | |||
| } | |||
| int modemConnect(IPAddress ip, uint16_t port, uint8_t mux = 0) { | |||
| String host; host.reserve(16); | |||
| host += ip[0]; | |||
| host += "."; | |||
| host += ip[1]; | |||
| host += "."; | |||
| host += ip[2]; | |||
| host += "."; | |||
| host += ip[3]; | |||
| sendAT(GF("IP"), 1); // Put in TCP mode | |||
| waitResponse(); | |||
| sendAT(GF("DL"), host); // Set the "Destination Address Low" | |||
| waitResponse(); | |||
| sendAT(GF("DE"), String(port, HEX)); // Set the destination port | |||
| int rsp = waitResponse(); | |||
| return rsp; | |||
| } | |||
| int modemSend(const void* buff, size_t len, uint8_t mux = 0) { | |||
| stream.write((uint8_t*)buff, len); | |||
| stream.flush(); | |||
| return len; | |||
| } | |||
| bool modemGetConnected(uint8_t mux = 0) { | |||
| commandMode(); | |||
| if (beeType == S6B) sendAT(GF("AI")); | |||
| else sendAT(GF("CI")); | |||
| int res = waitResponse(GF("0")); | |||
| exitCommand(); | |||
| return 1 == res; | |||
| } | |||
| /* Private Utilities */ | |||
| template<typename T> | |||
| void streamWrite(T last) { | |||
| stream.print(last); | |||
| } | |||
| template<typename T, typename... Args> | |||
| void streamWrite(T head, Args... tail) { | |||
| stream.print(head); | |||
| streamWrite(tail...); | |||
| } | |||
| int streamRead() { return stream.read(); } | |||
| String streamReadUntil(char c) { | |||
| TINY_GSM_YIELD(); | |||
| String return_string = stream.readStringUntil(c); | |||
| return_string.trim(); | |||
| if (String(c) == GSM_NL) { | |||
| DBG(return_string, "\r\n"); | |||
| } else DBG(return_string, c); | |||
| return return_string; | |||
| } | |||
| void streamClear(void) { | |||
| while (stream.available()) | |||
| {streamRead();} | |||
| } | |||
| bool commandMode(void) { | |||
| delay(guardTime); // cannot send anything for 1 second before entering command mode | |||
| streamWrite(GF("+++")); // enter command mode | |||
| DBG("\r\n+++\r\n"); | |||
| return 1 == waitResponse(guardTime*2); | |||
| } | |||
| void writeChanges(void) { | |||
| sendAT(GF("WR")); // Write changes to flash | |||
| waitResponse(); | |||
| sendAT(GF("AC")); // Apply changes | |||
| waitResponse(); | |||
| } | |||
| void exitCommand(void) { | |||
| sendAT(GF("CN")); // Exit command mode | |||
| waitResponse(); | |||
| } | |||
| template<typename... Args> | |||
| void sendAT(Args... cmd) { | |||
| streamWrite("AT", cmd..., GSM_NL); | |||
| stream.flush(); | |||
| TINY_GSM_YIELD(); | |||
| DBG(">>> AT ", cmd..., "\r\n"); | |||
| } | |||
| // TODO: Optimize this! | |||
| uint8_t waitResponse(uint32_t timeout, String& data, | |||
| GsmConstStr r1=GFP(GSM_OK), GsmConstStr r2=GFP(GSM_ERROR), | |||
| GsmConstStr r3=NULL, GsmConstStr r4=NULL, GsmConstStr r5=NULL) | |||
| { | |||
| /*String r1s(r1); r1s.trim(); | |||
| String r2s(r2); r2s.trim(); | |||
| String r3s(r3); r3s.trim(); | |||
| String r4s(r4); r4s.trim(); | |||
| String r5s(r5); r5s.trim(); | |||
| DBG("### ..:", r1s, ",", r2s, ",", r3s, ",", r4s, ",", r5s);*/ | |||
| data.reserve(64); | |||
| int index = 0; | |||
| unsigned long startMillis = millis(); | |||
| do { | |||
| TINY_GSM_YIELD(); | |||
| while (stream.available() > 0) { | |||
| int a = streamRead(); | |||
| if (a <= 0) continue; // Skip 0x00 bytes, just in case | |||
| data += (char)a; | |||
| if (r1 && data.endsWith(r1)) { | |||
| index = 1; | |||
| goto finish; | |||
| } else if (r2 && data.endsWith(r2)) { | |||
| index = 2; | |||
| goto finish; | |||
| } else if (r3 && data.endsWith(r3)) { | |||
| index = 3; | |||
| goto finish; | |||
| } else if (r4 && data.endsWith(r4)) { | |||
| index = 4; | |||
| goto finish; | |||
| } else if (r5 && data.endsWith(r5)) { | |||
| index = 5; | |||
| goto finish; | |||
| } | |||
| } | |||
| } while (millis() - startMillis < timeout); | |||
| finish: | |||
| if (!index) { | |||
| data.trim(); | |||
| data.replace(GSM_NL GSM_NL, GSM_NL); | |||
| data.replace(GSM_NL, "\r\n" " "); | |||
| if (data.length()) { | |||
| DBG("### Unhandled:", data, "\r\n"); | |||
| } else DBG("### NO RESPONSE!\r\n"); | |||
| } | |||
| else { | |||
| data.trim(); | |||
| data.replace(GSM_NL GSM_NL, GSM_NL); | |||
| data.replace(GSM_NL, "\r\n "); | |||
| if (data.length()) { | |||
| DBG("<<< ", data, "\r\n"); | |||
| } | |||
| } | |||
| return index; | |||
| } | |||
| uint8_t waitResponse(uint32_t timeout, | |||
| GsmConstStr r1=GFP(GSM_OK), GsmConstStr r2=GFP(GSM_ERROR), | |||
| GsmConstStr r3=NULL, GsmConstStr r4=NULL, GsmConstStr r5=NULL) | |||
| { | |||
| String data; | |||
| return waitResponse(timeout, data, r1, r2, r3, r4, r5); | |||
| } | |||
| uint8_t waitResponse(GsmConstStr r1=GFP(GSM_OK), GsmConstStr r2=GFP(GSM_ERROR), | |||
| GsmConstStr r3=NULL, GsmConstStr r4=NULL, GsmConstStr r5=NULL) | |||
| { | |||
| return waitResponse(1000, r1, r2, r3, r4, r5); | |||
| } | |||
| private: | |||
| int guardTime; | |||
| XBeeType beeType; | |||
| Stream& stream; | |||
| GsmClient* sockets[TINY_GSM_MUX_COUNT]; | |||
| }; | |||
| #endif | |||