JSD/TinyGSM_Senseright
3
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Update API and examples

Browse Source
This commit is contained in:
Volodymyr Shymanskyy
2016-12-08 14:03:37 +02:00
parent f9ef69cb6d
commit f11060e885
9 changed files with 203 additions and 138 deletions
Download Patch File Download Diff File Expand all files Collapse all files

112
TinyGsmClient.h
View File

@@ -61,8 +61,7 @@ enum RegStatus {
}; };
class TinyGsmClient class TinyGsm
: public Client
{ {
typedef TinyGsmFifo<uint8_t, TINY_GSM_RX_BUFFER> RxFifo; typedef TinyGsmFifo<uint8_t, TINY_GSM_RX_BUFFER> RxFifo;
@@ -83,17 +82,40 @@ class TinyGsmClient
#endif #endif
public: public:
TinyGsmClient(Stream& stream, uint8_t mux = 1) TinyGsm(Stream& stream)
: stream(stream) : stream(stream)
, mux(mux)
, sock_available(0)
, sock_connected(false)
{} {}
public: public:
class GsmClient : public Client
{
friend class TinyGsm;
typedef TinyGsmFifo<uint8_t, TINY_GSM_RX_BUFFER> RxFifo;
public:
GsmClient() {
init(NULL, -1);
}
GsmClient(TinyGsm& at, uint8_t mux = 1) {
init(&at, mux);
}
bool init(TinyGsm* at, uint8_t mux = 1) {
this->at = at;
this->mux = mux;
at->sockets[mux] = this;
sock_available = 0;
sock_connected = false;
return true;
}
public:
virtual int connect(const char *host, uint16_t port) { virtual int connect(const char *host, uint16_t port) {
return modemConnect(host, port); rx.clear();
sock_connected = at->modemConnect(host, port, mux);
return sock_connected;
} }
virtual int connect(IPAddress ip, uint16_t port) { virtual int connect(IPAddress ip, uint16_t port) {
@@ -105,18 +127,18 @@ public:
host += ip[2]; host += ip[2];
host += "."; host += ".";
host += ip[3]; host += ip[3];
return modemConnect(host.c_str(), port); //TODO: c_str may be missing return connect(host.c_str(), port);
} }
virtual void stop() { virtual void stop() {
sendAT(GF("+CIPCLOSE="), mux); at->sendAT(GF("+CIPCLOSE="), mux);
sock_connected = false; sock_connected = false;
waitResponse(); at->waitResponse();
} }
virtual size_t write(const uint8_t *buf, size_t size) { virtual size_t write(const uint8_t *buf, size_t size) {
maintain(); at->maintain();
return modemSend(buf, size); return at->modemSend(buf, size, mux);
} }
virtual size_t write(uint8_t c) { virtual size_t write(uint8_t c) {
@@ -124,12 +146,12 @@ public:
} }
virtual int available() { virtual int available() {
maintain(); at->maintain();
return rx.size() + sock_available; return rx.size() + sock_available;
} }
virtual int read(uint8_t *buf, size_t size) { virtual int read(uint8_t *buf, size_t size) {
maintain(); at->maintain();
size_t cnt = 0; size_t cnt = 0;
while (cnt < size) { while (cnt < size) {
size_t chunk = min(size-cnt, rx.size()); size_t chunk = min(size-cnt, rx.size());
@@ -140,9 +162,9 @@ public:
continue; continue;
} }
// TODO: Read directly into user buffer? // TODO: Read directly into user buffer?
maintain(); at->maintain();
if (sock_available > 0) { if (sock_available > 0) {
modemRead(rx.free()); at->modemRead(rx.free(), mux);
} else { } else {
break; break;
} }
@@ -159,13 +181,20 @@ public:
} }
virtual int peek() { return -1; } //TODO virtual int peek() { return -1; } //TODO
virtual void flush() { stream.flush(); } virtual void flush() { at->stream.flush(); }
virtual uint8_t connected() { virtual uint8_t connected() {
maintain(); at->maintain();
return sock_connected; return sock_connected;
} }
virtual operator bool() { return connected(); } virtual operator bool() { return connected(); }
private:
TinyGsm* at;
uint8_t mux;
uint16_t sock_available;
bool sock_connected;
RxFifo rx;
};
public: public:
@@ -180,7 +209,7 @@ public:
if (waitResponse() != 1) { if (waitResponse() != 1) {
return false; return false;
} }
getSimStatus();
return true; return true;
} }
@@ -297,13 +326,13 @@ public:
default: return SIM_ERROR; default: return SIM_ERROR;
} }
} }
return 0; return SIM_ERROR;
} }
RegStatus getRegistrationStatus() { RegStatus getRegistrationStatus() {
sendAT(GF("+CREG?")); sendAT(GF("+CREG?"));
if (waitResponse(GF(GSM_NL "+CREG: 0,")) != 1) { if (waitResponse(GF(GSM_NL "+CREG: 0,")) != 1) {
return 0; return REG_UNKNOWN;
} }
int status = stream.readStringUntil('\n').toInt(); int status = stream.readStringUntil('\n').toInt();
waitResponse(); waitResponse();
@@ -335,8 +364,8 @@ public:
/* /*
* GPRS functions * GPRS functions
*/ */
bool networkConnect(const char* apn, const char* user, const char* pwd) { bool gprsConnect(const char* apn, const char* user, const char* pwd) {
networkDisconnect(); gprsDisconnect();
// AT+CGATT? // AT+CGATT?
// AT+CGATT=1 // AT+CGATT=1
@@ -381,7 +410,7 @@ public:
return true; return true;
} }
bool networkDisconnect() { bool gprsDisconnect() {
sendAT(GF("+CIPSHUT")); sendAT(GF("+CIPSHUT"));
return waitResponse(60000L) == 1; return waitResponse(60000L) == 1;
} }
@@ -411,13 +440,16 @@ public:
*/ */
private: private:
int modemConnect(const char* host, uint16_t port) { int modemConnect(const char* host, uint16_t port, uint8_t mux) {
sendAT(GF("+CIPSTART="), mux, ',', GF("\"TCP"), GF("\",\""), host, GF("\","), port); sendAT(GF("+CIPSTART="), mux, ',', GF("\"TCP"), GF("\",\""), host, GF("\","), port);
sock_connected = (1 == waitResponse(75000L, GF("CONNECT OK" GSM_NL), GF("CONNECT FAIL" GSM_NL), GF("ALREADY CONNECT" GSM_NL))); int rsp = waitResponse(75000L,
return sock_connected; GF("CONNECT OK" GSM_NL),
GF("CONNECT FAIL" GSM_NL),
GF("ALREADY CONNECT" GSM_NL));
return (1 == rsp);
} }
int modemSend(const void* buff, size_t len) { int modemSend(const void* buff, size_t len, uint8_t mux) {
sendAT(GF("+CIPSEND="), mux, ',', len); sendAT(GF("+CIPSEND="), mux, ',', len);
if (waitResponse(GF(">")) != 1) { if (waitResponse(GF(">")) != 1) {
return -1; return -1;
@@ -431,7 +463,7 @@ private:
return data.toInt(); return data.toInt();
} }
size_t modemRead(size_t size) { size_t modemRead(size_t size, uint8_t mux) {
#ifdef GSM_USE_HEX #ifdef GSM_USE_HEX
sendAT(GF("+CIPRXGET=3,"), mux, ',', size); sendAT(GF("+CIPRXGET=3,"), mux, ',', size);
if (waitResponse(GF("+CIPRXGET: 3,")) != 1) { if (waitResponse(GF("+CIPRXGET: 3,")) != 1) {
@@ -445,7 +477,7 @@ private:
#endif #endif
stream.readStringUntil(','); // Skip mux stream.readStringUntil(','); // Skip mux
size_t len = stream.readStringUntil(',').toInt(); size_t len = stream.readStringUntil(',').toInt();
sock_available = stream.readStringUntil('\n').toInt(); sockets[mux]->sock_available = stream.readStringUntil('\n').toInt();
for (size_t i=0; i<len; i++) { for (size_t i=0; i<len; i++) {
#ifdef GSM_USE_HEX #ifdef GSM_USE_HEX
@@ -458,13 +490,13 @@ private:
while (stream.available() < 1) { delay(1); } while (stream.available() < 1) { delay(1); }
char c = stream.read(); char c = stream.read();
#endif #endif
rx.put(c); sockets[mux]->rx.put(c);
} }
waitResponse(); waitResponse();
return len; return len;
} }
size_t modemGetAvailable() { size_t modemGetAvailable(uint8_t mux) {
sendAT(GF("+CIPRXGET=4,"), mux); sendAT(GF("+CIPRXGET=4,"), mux);
size_t result = 0; size_t result = 0;
for (byte i = 0; i < 2; i++) { for (byte i = 0; i < 2; i++) {
@@ -479,12 +511,12 @@ private:
} }
} }
if (!result) { if (!result) {
sock_connected = modemGetConnected(); sockets[mux]->sock_connected = modemGetConnected(mux);
} }
return result; return result;
} }
bool modemGetConnected() { bool modemGetConnected(uint8_t mux) {
sendAT(GF("+CIPSTATUS="), mux); sendAT(GF("+CIPSTATUS="), mux);
int res = waitResponse(GF(",\"CONNECTED\""), GF(",\"CLOSED\""), GF(",\"CLOSING\""), GF(",\"INITIAL\"")); int res = waitResponse(GF(",\"CONNECTED\""), GF(",\"CLOSED\""), GF(",\"CLOSING\""), GF(",\"INITIAL\""));
waitResponse(); waitResponse();
@@ -544,7 +576,7 @@ private:
gotNewData = true; gotNewData = true;
data = ""; data = "";
} else if (data.indexOf(GF(GSM_NL "1, CLOSED" GSM_NL)) >= 0) { //TODO: use mux } else if (data.indexOf(GF(GSM_NL "1, CLOSED" GSM_NL)) >= 0) { //TODO: use mux
sock_connected = false; sockets[1]->sock_connected = false;
data = ""; data = "";
} }
} }
@@ -557,7 +589,7 @@ finish:
data = ""; data = "";
} }
if (gotNewData) { if (gotNewData) {
sock_available = modemGetAvailable(); sockets[1]->sock_available = modemGetAvailable(1);
} }
return index; return index;
} }
@@ -578,11 +610,9 @@ finish:
private: private:
Stream& stream; Stream& stream;
const uint8_t mux; GsmClient* sockets[5];
RxFifo rx;
uint16_t sock_available;
bool sock_connected;
}; };
typedef TinyGsm::GsmClient TinyGsmClient;
#endif #endif

14
examples/BlynkClient/BlynkClient.ino
View File

@@ -42,13 +42,14 @@ char user[] = "";
char pass[] = ""; char pass[] = "";
// Hardware Serial on Mega, Leonardo, Micro // Hardware Serial on Mega, Leonardo, Micro
#define GsmSerial Serial1 #define SerialAT Serial1
// or Software Serial on Uno, Nano // or Software Serial on Uno, Nano
//#include <SoftwareSerial.h> //#include <SoftwareSerial.h>
//SoftwareSerial GsmSerial(2, 3); // RX, TX //SoftwareSerial SerialAT(2, 3); // RX, TX
TinyGsmClient gsm(GsmSerial); TinyGsm modem(SerialAT);
TinyGsmClient client(modem);
void setup() void setup()
{ {
@@ -57,15 +58,14 @@ void setup()
delay(10); delay(10);
// Set GSM module baud rate // Set GSM module baud rate
GsmSerial.begin(115200); SerialAT.begin(115200);
delay(3000); delay(3000);
// Restart takes quite some time // Restart takes quite some time
// You can skip it in many cases // You can skip it in many cases
Serial.println("Restarting modem..."); modem.restart();
gsm.restart();
Blynk.begin(auth, gsm, apn, user, pass); Blynk.begin(auth, modem, apn, user, pass);
} }
void loop() void loop()

30
examples/FileDownload/FileDownload.ino
View File

@@ -19,13 +19,14 @@ char user[] = "";
char pass[] = ""; char pass[] = "";
// Use Hardware Serial on Mega, Leonardo, Micro // Use Hardware Serial on Mega, Leonardo, Micro
#define GsmSerial Serial1 #define SerialAT Serial1
// or Software Serial on Uno, Nano // or Software Serial on Uno, Nano
//#include <SoftwareSerial.h> //#include <SoftwareSerial.h>
//SoftwareSerial GsmSerial(2, 3); // RX, TX //SoftwareSerial SerialAT(2, 3); // RX, TX
TinyGsmClient client(GsmSerial); TinyGsm modem(SerialAT);
TinyGsmClient client(modem);
char server[] = "cdn.rawgit.com"; char server[] = "cdn.rawgit.com";
char resource[] = "/vshymanskyy/tinygsm/master/extras/test_10k.hex"; char resource[] = "/vshymanskyy/tinygsm/master/extras/test_10k.hex";
@@ -38,31 +39,38 @@ void setup() {
delay(10); delay(10);
// Set GSM module baud rate // Set GSM module baud rate
GsmSerial.begin(115200); SerialAT.begin(115200);
delay(3000); delay(3000);
// Restart takes quite some time // Restart takes quite some time
// You can skip it in many cases // You can skip it in many cases
Serial.println("Restarting modem..."); modem.restart();
client.restart();
} }
void printPercent(uint32_t readLength, uint32_t contentLength) { void printPercent(uint32_t readLength, uint32_t contentLength) {
// If we know the total length // If we know the total length
if (contentLength != -1) { if (contentLength != -1) {
Serial.print(F("\r ")); Serial.print("\r ");
Serial.print((100.0 * readLength) / contentLength); Serial.print((100.0 * readLength) / contentLength);
Serial.println('%'); Serial.print('%');
} else { } else {
Serial.println(readLength); Serial.println(readLength);
} }
} }
void loop() { void loop() {
Serial.print("Waiting for network...");
if (!modem.waitForNetwork()) {
Serial.println(" fail");
delay(10000);
return;
}
Serial.println(" OK");
Serial.print("Connecting to "); Serial.print("Connecting to ");
Serial.print(apn); Serial.print(apn);
if (!client.networkConnect(apn, user, pass)) { if (!modem.gprsConnect(apn, user, pass)) {
Serial.println(" failed"); Serial.println(" fail");
delay(10000); delay(10000);
return; return;
} }
@@ -134,7 +142,7 @@ void loop() {
client.stop(); client.stop();
Serial.println("Server disconnected"); Serial.println("Server disconnected");
client.networkDisconnect(); modem.gprsDisconnect();
Serial.println("GPRS disconnected"); Serial.println("GPRS disconnected");
Serial.println(); Serial.println();

27
examples/MqttClient/MqttClient.ino
View File

@@ -35,14 +35,15 @@ char user[] = "";
char pass[] = ""; char pass[] = "";
// Use Hardware Serial on Mega, Leonardo, Micro // Use Hardware Serial on Mega, Leonardo, Micro
#define GsmSerial Serial1 #define SerialAT Serial1
// or Software Serial on Uno, Nano // or Software Serial on Uno, Nano
//#include <SoftwareSerial.h> //#include <SoftwareSerial.h>
//SoftwareSerial GsmSerial(2, 3); // RX, TX //SoftwareSerial SerialAT(2, 3); // RX, TX
TinyGsmClient gsm(GsmSerial); TinyGsm modem(SerialAT);
PubSubClient mqtt(gsm); TinyGsmClient client(modem);
PubSubClient mqtt(client);
const char* broker = "test.mosquitto.org"; const char* broker = "test.mosquitto.org";
@@ -63,18 +64,24 @@ void setup() {
delay(10); delay(10);
// Set GSM module baud rate // Set GSM module baud rate
GsmSerial.begin(115200); SerialAT.begin(115200);
delay(3000); delay(3000);
// Restart takes quite some time // Restart takes quite some time
// You can skip it in many cases // You can skip it in many cases
Serial.println("Restarting modem..."); modem.restart();
gsm.restart();
Serial.print("Waiting for network...");
if (!modem.waitForNetwork()) {
Serial.println(" fail");
while (true);
}
Serial.println(" OK");
Serial.print("Connecting to "); Serial.print("Connecting to ");
Serial.print(apn); Serial.print(apn);
if (!gsm.networkConnect(apn, user, pass)) { if (!modem.gprsConnect(apn, user, pass)) {
Serial.println(" failed"); Serial.println(" fail");
while (true); while (true);
} }
Serial.println(" OK"); Serial.println(" OK");
@@ -88,7 +95,7 @@ boolean mqttConnect() {
Serial.print("Connecting to "); Serial.print("Connecting to ");
Serial.print(broker); Serial.print(broker);
if (!mqtt.connect("GsmClientTest")) { if (!mqtt.connect("GsmClientTest")) {
Serial.println(" failed"); Serial.println(" fail");
return false; return false;
} }
Serial.println(" OK"); Serial.println(" OK");

26
examples/WebClient/WebClient.ino
View File

@@ -17,13 +17,14 @@ char user[] = "";
char pass[] = ""; char pass[] = "";
// Use Hardware Serial on Mega, Leonardo, Micro // Use Hardware Serial on Mega, Leonardo, Micro
#define GsmSerial Serial1 #define SerialAT Serial1
// or Software Serial on Uno, Nano // or Software Serial on Uno, Nano
//#include <SoftwareSerial.h> //#include <SoftwareSerial.h>
//SoftwareSerial GsmSerial(2, 3); // RX, TX //SoftwareSerial SerialAT(2, 3); // RX, TX
TinyGsmClient client(GsmSerial); TinyGsm modem(SerialAT);
TinyGsmClient client(modem);
char server[] = "cdn.rawgit.com"; char server[] = "cdn.rawgit.com";
char resource[] = "/vshymanskyy/tinygsm/master/extras/logo.txt"; char resource[] = "/vshymanskyy/tinygsm/master/extras/logo.txt";
@@ -34,20 +35,27 @@ void setup() {
delay(10); delay(10);
// Set GSM module baud rate // Set GSM module baud rate
GsmSerial.begin(115200); SerialAT.begin(115200);
delay(3000); delay(3000);
// Restart takes quite some time // Restart takes quite some time
// You can skip it in many cases // You can skip it in many cases
Serial.println("Restarting modem..."); modem.restart();
client.restart();
} }
void loop() { void loop() {
Serial.print("Waiting for network...");
if (!modem.waitForNetwork()) {
Serial.println(" fail");
delay(10000);
return;
}
Serial.println(" OK");
Serial.print("Connecting to "); Serial.print("Connecting to ");
Serial.print(apn); Serial.print(apn);
if (!client.networkConnect(apn, user, pass)) { if (!modem.gprsConnect(apn, user, pass)) {
Serial.println(" failed"); Serial.println(" fail");
delay(10000); delay(10000);
return; return;
} }
@@ -81,7 +89,7 @@ void loop() {
client.stop(); client.stop();
Serial.println("Server disconnected"); Serial.println("Server disconnected");
client.networkDisconnect(); modem.gprsDisconnect();
Serial.println("GPRS disconnected"); Serial.println("GPRS disconnected");
// Do nothing forevermore // Do nothing forevermore

12
keywords.txt
View File

@@ -1,19 +1,23 @@
####################################### #######################################
# Data types (KEYWORD1) # Data types (KEYWORD1)
####################################### #######################################
TinyGsm KEYWORD1
TinyGsmClient KEYWORD1 TinyGsmClient KEYWORD1
SerialAT KEYWORD1
SerialMon KEYWORD1
####################################### #######################################
# Methods and Functions (KEYWORD2) # Methods and Functions (KEYWORD2)
####################################### #######################################
begin KEYWORD2 begin KEYWORD2
restart KEYWORD2 restart KEYWORD2
networkConnect KEYWORD2 waitForNetwork KEYWORD2
networkDisconnect KEYWORD2 getSimStatus KEYWORD2
gprsConnect KEYWORD2
gprsDisconnect KEYWORD2
factoryReset KEYWORD2 factoryReset KEYWORD2
GsmSerial KEYWORD3
####################################### #######################################
# Literals (LITERAL1) # Literals (LITERAL1)
####################################### #######################################

42
tools/AT_Debug/AT_Debug.ino
View File

@@ -9,7 +9,7 @@
**************************************************************/ **************************************************************/
// Set serial for debug console (to the Serial Monitor, speed 115200) // Set serial for debug console (to the Serial Monitor, speed 115200)
#define SerialMonitor Serial #define SerialMon Serial
// Set serial for AT commands (to the module) // Set serial for AT commands (to the module)
// Use Hardware Serial on Mega, Leonardo, Micro // Use Hardware Serial on Mega, Leonardo, Micro
@@ -20,11 +20,11 @@
//SoftwareSerial SerialAT(2, 3); // RX, TX //SoftwareSerial SerialAT(2, 3); // RX, TX
#include <TinyGsmClient.h> #include <TinyGsmClient.h>
TinyGsmClient gsm(SerialAT); TinyGsm modem(SerialAT);
void setup() { void setup() {
// Set console baud rate // Set console baud rate
SerialMonitor.begin(115200); SerialMon.begin(115200);
delay(5000); delay(5000);
} }
@@ -33,43 +33,43 @@ void loop() {
uint32_t rate = 0; uint32_t rate = 0;
uint32_t rates[] = { 115200, 9600, 57600, 19200, 74400, 74880 }; uint32_t rates[] = { 115200, 9600, 57600, 19200, 74400, 74880 };
SerialMonitor.println("Autodetecting baud rate"); SerialMon.println("Autodetecting baud rate");
for (unsigned i = 0; i < sizeof(rates)/sizeof(rates[0]); i++) { for (unsigned i = 0; i < sizeof(rates)/sizeof(rates[0]); i++) {
SerialMonitor.print(String("Trying baud rate ") + rates[i] + "... "); SerialMon.print(String("Trying baud rate ") + rates[i] + "... ");
SerialAT.begin(rates[i]); SerialAT.begin(rates[i]);
delay(10); delay(10);
if (gsm.autoBaud(3000)) { if (modem.autoBaud(2000)) {
rate = rates[i]; rate = rates[i];
SerialMonitor.println(F("OK")); SerialMon.println(F("OK"));
break; break;
} else { } else {
SerialMonitor.println(F("fail")); SerialMon.println(F("fail"));
} }
} }
if (!rate) { if (!rate) {
SerialMonitor.println(F("***********************************************************")); SerialMon.println(F("***********************************************************"));
SerialMonitor.println(F(" Module does not respond!")); SerialMon.println(F(" Module does not respond!"));
SerialMonitor.println(F(" Check your Serial wiring")); SerialMon.println(F(" Check your Serial wiring"));
SerialMonitor.println(F(" Check the module is correctly powered and turned on")); SerialMon.println(F(" Check the module is correctly powered and turned on"));
SerialMonitor.println(F("***********************************************************")); SerialMon.println(F("***********************************************************"));
delay(30000L); delay(30000L);
return; return;
} }
// Access AT commands from Serial Monitor // Access AT commands from Serial Monitor
SerialMonitor.println(F("***********************************************************")); SerialMon.println(F("***********************************************************"));
SerialMonitor.println(F(" You can now send AT commands")); SerialMon.println(F(" You can now send AT commands"));
SerialMonitor.println(F(" Enter \"AT\" (without quotes), and you should see \"OK\"")); SerialMon.println(F(" Enter \"AT\" (without quotes), and you should see \"OK\""));
SerialMonitor.println(F(" If it doesn't work, select \"Both NL & CR\" in Serial Monitor")); SerialMon.println(F(" If it doesn't work, select \"Both NL & CR\" in Serial Monitor"));
SerialMonitor.println(F("***********************************************************")); SerialMon.println(F("***********************************************************"));
while(true) { while(true) {
if (SerialAT.available()) { if (SerialAT.available()) {
SerialMonitor.write(SerialAT.read()); SerialMon.write(SerialAT.read());
} }
if (SerialMonitor.available()) { if (SerialMon.available()) {
SerialAT.write(SerialMonitor.read()); SerialAT.write(SerialMon.read());
} }
delay(0); delay(0);
} }

30
tools/FactoryReset/FactoryReset.ino
View File

@@ -10,7 +10,7 @@
**************************************************************/ **************************************************************/
// Set serial for debug console (to the Serial Monitor, speed 115200) // Set serial for debug console (to the Serial Monitor, speed 115200)
#define SerialMonitor Serial #define SerialMon Serial
// Set serial for AT commands (to the module) // Set serial for AT commands (to the module)
// Use Hardware Serial on Mega, Leonardo, Micro // Use Hardware Serial on Mega, Leonardo, Micro
@@ -22,33 +22,33 @@
#include <TinyGsmClient.h> #include <TinyGsmClient.h>
#include <StreamDebugger.h> #include <StreamDebugger.h>
StreamDebugger DebugAT(SerialAT, SerialMonitor); StreamDebugger debugger(SerialAT, SerialMon);
TinyGsmClient gsm(DebugAT); TinyGsm modem(debugger);
void setup() { void setup() {
// Set console baud rate // Set console baud rate
SerialMonitor.begin(115200); SerialMon.begin(115200);
delay(10); delay(10);
// Set GSM module baud rate // Set GSM module baud rate
SerialAT.begin(115200); SerialAT.begin(115200);
delay(3000); delay(3000);
if (!gsm.begin()) { if (!modem.begin()) {
SerialMonitor.println(F("***********************************************************")); SerialMon.println(F("***********************************************************"));
SerialMonitor.println(F(" Cannot initialize module!")); SerialMon.println(F(" Cannot initialize module!"));
SerialMonitor.println(F(" Use File -> Examples -> TinyGSM -> tools -> AT_Debug")); SerialMon.println(F(" Use File -> Examples -> TinyGSM -> tools -> AT_Debug"));
SerialMonitor.println(F(" to find correct configuration")); SerialMon.println(F(" to find correct configuration"));
SerialMonitor.println(F("***********************************************************")); SerialMon.println(F("***********************************************************"));
return; return;
} }
bool ret = gsm.factoryDefault(); bool ret = modem.factoryDefault();
SerialMonitor.println(F("***********************************************************")); SerialMon.println(F("***********************************************************"));
SerialMonitor.print (F(" Return settings to Factory Defaults: ")); SerialMon.print (F(" Return settings to Factory Defaults: "));
SerialMonitor.println((ret) ? "OK" : "FAIL"); SerialMon.println((ret) ? "OK" : "FAIL");
SerialMonitor.println(F("***********************************************************")); SerialMon.println(F("***********************************************************"));
} }
void loop() { void loop() {

48
tools/SimpleTest/SimpleTest.ino
View File

@@ -12,15 +12,12 @@
// Increase buffer fo see less commands // Increase buffer fo see less commands
#define GSM_RX_BUFFER 256 #define GSM_RX_BUFFER 256
#include <TinyGsmClient.h>
#include <StreamDebugger.h>
char apn[] = "YourAPN"; char apn[] = "YourAPN";
char user[] = ""; char user[] = "";
char pass[] = ""; char pass[] = "";
// Set serial for debug console (to the Serial Monitor, speed 115200) // Set serial for debug console (to the Serial Monitor, speed 115200)
#define SerialMonitor Serial #define SerialMon Serial
// Set serial for AT commands (to the module) // Set serial for AT commands (to the module)
// Use Hardware Serial on Mega, Leonardo, Micro // Use Hardware Serial on Mega, Leonardo, Micro
@@ -30,15 +27,19 @@ char pass[] = "";
//#include <SoftwareSerial.h> //#include <SoftwareSerial.h>
//SoftwareSerial SerialAT(2, 3); // RX, TX //SoftwareSerial SerialAT(2, 3); // RX, TX
StreamDebugger DebugAT(SerialAT, SerialMonitor); #include <StreamDebugger.h>
TinyGsmClient client(DebugAT); StreamDebugger debugger(SerialAT, SerialMon);
#include <TinyGsmClient.h>
TinyGsm modem(debugger);
TinyGsmClient client(modem);
char server[] = "cdn.rawgit.com"; char server[] = "cdn.rawgit.com";
char resource[] = "/vshymanskyy/tinygsm/master/extras/test_simple.txt"; char resource[] = "/vshymanskyy/tinygsm/master/extras/test_simple.txt";
void setup() { void setup() {
// Set console baud rate // Set console baud rate
SerialMonitor.begin(115200); SerialMon.begin(115200);
delay(10); delay(10);
// Set GSM module baud rate // Set GSM module baud rate
@@ -47,12 +48,19 @@ void setup() {
// Restart takes quite some time // Restart takes quite some time
// You can skip it in many cases // You can skip it in many cases
SerialMonitor.println("Restarting modem..."); SerialMon.println("Restarting modem...");
client.restart(); modem.restart();
SerialMon.println("Waiting for network... ");
if (modem.waitForNetwork()) {
SerialMon.println("OK");
} else {
SerialMon.println("fail");
}
} }
void loop() { void loop() {
if (!client.networkConnect(apn, user, pass)) { if (!modem.networkConnect(apn, user, pass)) {
delay(10000); delay(10000);
return; return;
} }
@@ -76,7 +84,7 @@ void loop() {
while (client.connected() && millis() - timeout < 10000L) { while (client.connected() && millis() - timeout < 10000L) {
while (client.available()) { while (client.available()) {
char c = client.read(); char c = client.read();
//SerialMonitor.print(c); //SerialMon.print(c);
bytesReceived += 1; bytesReceived += 1;
timeout = millis(); timeout = millis();
} }
@@ -84,16 +92,16 @@ void loop() {
client.stop(); client.stop();
client.networkDisconnect(); modem.networkDisconnect();
SerialMonitor.println(); SerialMon.println();
SerialMonitor.println("************************"); SerialMon.println("************************");
SerialMonitor.print (" Received: "); SerialMon.print (" Received: ");
SerialMonitor.print(bytesReceived); SerialMon.print(bytesReceived);
SerialMonitor.println("bytes"); SerialMon.println("bytes");
SerialMonitor.print (" Test: "); SerialMon.print (" Test: ");
SerialMonitor.println((bytesReceived == 1000) ? "PASSED" : "FAIL"); SerialMon.println((bytesReceived == 1000) ? "PASSED" : "FAIL");
SerialMonitor.println("************************"); SerialMon.println("************************");
// Do nothing forevermore // Do nothing forevermore
while (true) { while (true) {