513 lines
16 KiB
C++
513 lines
16 KiB
C++
|
#include "ThreadedGSM.h"
|
||
|
|
|
||
|
|
#ifdef THREADEDGSM_DEBUG
|
||
|
|
#define DEBUG_PRINT(x) THREADEDGSM_DEBUG.print(x)
|
||
|
|
#define DEBUG_PRINTLN(x) THREADEDGSM_DEBUG.println(x)
|
||
|
|
#else
|
||
|
|
#define DEBUG_PRINT(x)
|
||
|
|
#define DEBUG_PRINTLN(x)
|
||
|
|
#endif
|
||
|
|
|
||
|
|
ThreadedGSM::ThreadedGSM(Stream & stream)
|
||
|
|
: stream(stream), dte(stream, THREADEDGSM_DTE_BUFFER_SIZE), ringState(RING_WAIT)
|
||
|
|
{
|
||
|
|
for (unsigned long & Interval : Intervals)
|
||
|
|
Interval = 0;
|
||
|
|
|
||
|
|
job = state = requests = 0;
|
||
|
|
// SMSo.Text.reserve(150);
|
||
|
|
// SMSi.Text.reserve(150);
|
||
|
|
}
|
||
|
|
|
||
|
|
void ThreadedGSM::nextJob()
|
||
|
|
{
|
||
|
|
job = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
void ThreadedGSM::setHandlers(conf config)
|
||
|
|
{
|
||
|
|
|
||
|
|
this->configuration = config;
|
||
|
|
}
|
||
|
|
|
||
|
|
void ThreadedGSM::setInterval(IntervalSourceE source, unsigned long interval)
|
||
|
|
{
|
||
|
|
Intervals[source] = interval;
|
||
|
|
tickSync[source] = millis();
|
||
|
|
}
|
||
|
|
|
||
|
|
// Initialization
|
||
|
|
void ThreadedGSM::begin()
|
||
|
|
{
|
||
|
|
requests = (REQ_STARTUP);
|
||
|
|
TimeBase.attachLoop(this);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Call this function for executing thread
|
||
|
|
void ThreadedGSM::exec()
|
||
|
|
{
|
||
|
|
if (dte.getIsBusy())
|
||
|
|
return;
|
||
|
|
|
||
|
|
// intervals
|
||
|
|
for (int i = 0; i < THREADEDGSM_INTERVAL_COUNT; i++) {
|
||
|
|
if (Intervals[i]) {
|
||
|
|
if (millis() - tickSync[i] >= Intervals[i]) {
|
||
|
|
switch (i) {
|
||
|
|
case INTERVAL_CLOCK:
|
||
|
|
requests |= REQ_CLOCK;
|
||
|
|
break;
|
||
|
|
|
||
|
|
case INTERVAL_INBOX:
|
||
|
|
requests |= REQ_INBOX;
|
||
|
|
break;
|
||
|
|
|
||
|
|
case INTERVAL_SIGNAL:
|
||
|
|
requests |= REQ_SIG;
|
||
|
|
break;
|
||
|
|
|
||
|
|
case INTERVAL_BATTERY:
|
||
|
|
requests |= REQ_BATTERY;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
tickSync[i] = millis();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (job == 0) {
|
||
|
|
// no assigned job, assign it
|
||
|
|
if (requests & REQ_CLOCK)
|
||
|
|
job = REQ_CLOCK;
|
||
|
|
else if (requests & REQ_SIG)
|
||
|
|
job = REQ_SIG;
|
||
|
|
else if (requests & REQ_INBOX)
|
||
|
|
job = REQ_INBOX;
|
||
|
|
else if (requests & REQ_OUTBOX)
|
||
|
|
job = REQ_OUTBOX;
|
||
|
|
else if (requests & REQ_STARTUP)
|
||
|
|
job = REQ_STARTUP;
|
||
|
|
else if (requests & REQ_BATTERY)
|
||
|
|
job = REQ_BATTERY;
|
||
|
|
|
||
|
|
if (job) {
|
||
|
|
state = 0;
|
||
|
|
DEBUG_PRINT(F("Job ID: "));
|
||
|
|
DEBUG_PRINTLN(job);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// execute current job
|
||
|
|
if (job == REQ_STARTUP)
|
||
|
|
Startup();
|
||
|
|
else if (job == REQ_CLOCK)
|
||
|
|
Clock();
|
||
|
|
else if (job == REQ_SIG)
|
||
|
|
Signal();
|
||
|
|
else if (job == REQ_INBOX)
|
||
|
|
Inbox();
|
||
|
|
else if (job == REQ_OUTBOX)
|
||
|
|
Outbox();
|
||
|
|
else if (job == REQ_BATTERY)
|
||
|
|
Battery();
|
||
|
|
else
|
||
|
|
CheckRing();
|
||
|
|
}
|
||
|
|
|
||
|
|
// Requests
|
||
|
|
void ThreadedGSM::sendSMS(String & Number, String & Text)
|
||
|
|
{
|
||
|
|
requests |= (REQ_OUTBOX);
|
||
|
|
SMSo.Number = Number;
|
||
|
|
SMSo.Text = Text;
|
||
|
|
}
|
||
|
|
|
||
|
|
void ThreadedGSM::sendSMS(String & Number, const char * Text)
|
||
|
|
{
|
||
|
|
String t = Text;
|
||
|
|
|
||
|
|
sendSMS(Number, t);
|
||
|
|
}
|
||
|
|
|
||
|
|
// States
|
||
|
|
void ThreadedGSM::Startup()
|
||
|
|
{
|
||
|
|
int lastState = state;
|
||
|
|
switch (state) {
|
||
|
|
case STARTUP_POWER_OFF:
|
||
|
|
if (this->configuration.power != nullptr)
|
||
|
|
this->configuration.power(*this, false);
|
||
|
|
tick = millis();
|
||
|
|
state = STARTUP_POWER_OFF_DELAY;
|
||
|
|
break;
|
||
|
|
|
||
|
|
case STARTUP_POWER_OFF_DELAY:
|
||
|
|
if (millis() - tick >= THREADEDGSM_STARTUP_POWER_OFF_DELAY)
|
||
|
|
state = STARTUP_POWER_ON;
|
||
|
|
break;
|
||
|
|
|
||
|
|
case STARTUP_POWER_ON:
|
||
|
|
if (this->configuration.power != nullptr)
|
||
|
|
this->configuration.power(*this, true);
|
||
|
|
// begin delay
|
||
|
|
tick = millis();
|
||
|
|
state = STARTUP_DELAY;
|
||
|
|
break;
|
||
|
|
|
||
|
|
case STARTUP_DELAY:
|
||
|
|
if (millis() - tick >= THREADEDGSM_STARTUP_DELAY) {
|
||
|
|
dte.SendCommand(F("AT\r"), THREADEDGSM_AT_TIMEOUT, "OK\r");
|
||
|
|
state = STARTUP_ENTER_AT;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
|
||
|
|
case STARTUP_ENTER_AT:
|
||
|
|
if (dte.getResult() == DTE::EXPECT_RESULT) {
|
||
|
|
dte.SendCommand(F("AT+CPIN?\r"), 10000, "OK\r");
|
||
|
|
state = STARTUP_CHK_CPIN;
|
||
|
|
} else {
|
||
|
|
state = STARTUP_POWER_OFF;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
|
||
|
|
case STARTUP_CHK_CPIN:
|
||
|
|
if (dte.getResult() == DTE::EXPECT_RESULT) {
|
||
|
|
if (dte.getBuffer().indexOf(F("+CPIN: READY")) != -1) {
|
||
|
|
dte.SendCommand(F("AT+CREG?\r"), THREADEDGSM_AT_TIMEOUT, "OK\r");
|
||
|
|
state = STARTUP_CHK_CREG;
|
||
|
|
} else {
|
||
|
|
state = STARTUP_POWER_OFF;
|
||
|
|
}
|
||
|
|
} else
|
||
|
|
state = STARTUP_POWER_OFF;
|
||
|
|
break;
|
||
|
|
|
||
|
|
case STARTUP_CHK_CREG:
|
||
|
|
if (dte.getResult() == DTE::EXPECT_RESULT) {
|
||
|
|
if ((dte.getBuffer().indexOf(F(",1")) >= 0) || (dte.getBuffer().indexOf(F(",5")) >= 0)) {
|
||
|
|
dte.SendCommand(F("AT+CLTS=1\r"), THREADEDGSM_AT_TIMEOUT, "OK\r");
|
||
|
|
state = STARTUP_CHK_CLTS;
|
||
|
|
} else
|
||
|
|
state = STARTUP_POWER_OFF;
|
||
|
|
} else
|
||
|
|
state = STARTUP_POWER_OFF;
|
||
|
|
break;
|
||
|
|
|
||
|
|
case STARTUP_CHK_CLTS:
|
||
|
|
if (dte.getResult() == DTE::EXPECT_RESULT) {
|
||
|
|
dte.SendCommand(F("AT+CENG=3\r"), THREADEDGSM_AT_TIMEOUT, "OK\r");
|
||
|
|
state = STARTUP_CHK_CENG;
|
||
|
|
} else
|
||
|
|
state = STARTUP_POWER_OFF;
|
||
|
|
break;
|
||
|
|
|
||
|
|
case STARTUP_CHK_CENG:
|
||
|
|
if (dte.getResult() == DTE::EXPECT_RESULT) {
|
||
|
|
requests |= ((REQ_CLOCK) | (REQ_SIG) | (REQ_BATTERY));
|
||
|
|
clearReq(REQ_STARTUP);
|
||
|
|
for (int i = 0; i < THREADEDGSM_INTERVAL_COUNT; i++)
|
||
|
|
tickSync[i] = millis();
|
||
|
|
if (this->configuration.ready != nullptr)
|
||
|
|
this->configuration.ready(*this);
|
||
|
|
} else
|
||
|
|
state = STARTUP_POWER_OFF;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
if (state != lastState) {
|
||
|
|
DEBUG_PRINT(F("STARTUP_STATE: "));
|
||
|
|
DEBUG_PRINTLN(state);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Threads
|
||
|
|
void ThreadedGSM::Clock()
|
||
|
|
{
|
||
|
|
String clockTime;
|
||
|
|
int lastState = state;
|
||
|
|
switch (state) {
|
||
|
|
case CLOCK_REQ:
|
||
|
|
dte.SendCommand(F("AT+CCLK?\r"), THREADEDGSM_AT_TIMEOUT, "OK\r");
|
||
|
|
state = CLOCK_VERIFY;
|
||
|
|
break;
|
||
|
|
|
||
|
|
case CLOCK_VERIFY:
|
||
|
|
int index = dte.getBuffer().indexOf(F("+CCLK: "));
|
||
|
|
if (index >= 0) {
|
||
|
|
// parse clock
|
||
|
|
index += 8;
|
||
|
|
int endindex;
|
||
|
|
endindex = dte.getBuffer().indexOf(F("+"), index);
|
||
|
|
if (endindex >= 0)
|
||
|
|
clockTime = dte.getBuffer().substring(index, endindex);
|
||
|
|
else {
|
||
|
|
endindex = dte.getBuffer().indexOf(F("-"), index);
|
||
|
|
if (endindex >= 0)
|
||
|
|
clockTime = dte.getBuffer().substring(index, endindex);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (endindex >= 0) {
|
||
|
|
NetworkTime ClockTime{};
|
||
|
|
|
||
|
|
ClockTime.year = 2000 + clockTime.substring(0, 2).toInt();
|
||
|
|
ClockTime.month = clockTime.substring(3, 5).toInt();
|
||
|
|
ClockTime.day = clockTime.substring(6, 8).toInt();
|
||
|
|
ClockTime.hour = clockTime.substring(9, 11).toInt();
|
||
|
|
ClockTime.minute = clockTime.substring(12, 14).toInt();
|
||
|
|
ClockTime.second = clockTime.substring(15, 17).toInt();
|
||
|
|
if (this->configuration.clock != nullptr)
|
||
|
|
this->configuration.clock(*this, ClockTime);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
clearReq(REQ_CLOCK);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
if (state != lastState) {
|
||
|
|
DEBUG_PRINT(F("CLOCK_STATE: "));
|
||
|
|
DEBUG_PRINTLN(state);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void ThreadedGSM::Signal()
|
||
|
|
{
|
||
|
|
int lastState = state;
|
||
|
|
switch (state) {
|
||
|
|
case SIGNAL_REQ:
|
||
|
|
dte.SendCommand(F("AT+CSQ\r"), THREADEDGSM_AT_TIMEOUT, "OK\r");
|
||
|
|
state = SIGNAL_VERIFY;
|
||
|
|
break;
|
||
|
|
|
||
|
|
case SIGNAL_VERIFY:
|
||
|
|
int index = dte.getBuffer().indexOf(F("+CSQ: "));
|
||
|
|
if (index >= 0) {
|
||
|
|
// parse signal
|
||
|
|
index += 6;
|
||
|
|
SignalLevel GsmSignal{};
|
||
|
|
GsmSignal.Value = dte.getBuffer().substring(index, index + 2).toInt();
|
||
|
|
GsmSignal.Dbm = dte.getBuffer().substring(index + 3, index + 5).toInt();
|
||
|
|
if (GsmSignal.Value != 0) {
|
||
|
|
if (this->configuration.signal != nullptr)
|
||
|
|
this->configuration.signal(*this, GsmSignal);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
clearReq(REQ_SIG);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
if (state != lastState) {
|
||
|
|
DEBUG_PRINT(F("SIGNAL_STATE: "));
|
||
|
|
DEBUG_PRINTLN(state);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void ThreadedGSM::Battery()
|
||
|
|
{
|
||
|
|
int lastState = state;
|
||
|
|
switch (state) {
|
||
|
|
case BATTERY_REQ:
|
||
|
|
dte.SendCommand(F("AT+CBC\r"), THREADEDGSM_AT_TIMEOUT, "OK\r");
|
||
|
|
state = BATTERY_VERIFY;
|
||
|
|
break;
|
||
|
|
|
||
|
|
case BATTERY_VERIFY:
|
||
|
|
int index = dte.getBuffer().indexOf(F("+CBC:"));
|
||
|
|
if (index >= 0) {
|
||
|
|
BatteryInfo BattInfo{};
|
||
|
|
// parse battery level
|
||
|
|
String buffer = dte.getBuffer().substring(index);
|
||
|
|
String buffer2 = buffer.substring(buffer.indexOf(F(",")) + 1);
|
||
|
|
buffer = buffer2;
|
||
|
|
BattInfo.Percent = buffer2.substring(0, buffer2.indexOf(F(","))).toInt(); // converts the result to interger
|
||
|
|
buffer2 = buffer.substring(buffer.indexOf(F(",")) + 1);
|
||
|
|
BattInfo.Voltage = buffer2.substring(0, buffer2.indexOf(F("\r"))).toInt(); // converts the result to interger
|
||
|
|
if (this->configuration.battery != nullptr)
|
||
|
|
this->configuration.battery(*this, BattInfo);
|
||
|
|
}
|
||
|
|
clearReq(REQ_BATTERY);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
if (state != lastState) {
|
||
|
|
DEBUG_PRINT(F("BATTERY_STATE: "));
|
||
|
|
DEBUG_PRINTLN(state);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void ThreadedGSM::clearReq(int req)
|
||
|
|
{
|
||
|
|
requests &= ~(req);
|
||
|
|
nextJob();
|
||
|
|
}
|
||
|
|
|
||
|
|
void ThreadedGSM::Inbox()
|
||
|
|
{
|
||
|
|
String CMD;
|
||
|
|
int lastState = state;
|
||
|
|
switch (state) {
|
||
|
|
case READ_REQ:
|
||
|
|
SMSi.Text = "";
|
||
|
|
SMSi.Number = "";
|
||
|
|
dte.SendCommand(F("AT+CMGF=0\r"), THREADEDGSM_AT_TIMEOUT, "OK\r"); // SMS Message format set as PDU
|
||
|
|
state = READ_CHK_CMGF;
|
||
|
|
break;
|
||
|
|
|
||
|
|
case READ_CHK_CMGF:
|
||
|
|
if (dte.getResult() == DTE::EXPECT_RESULT) {
|
||
|
|
dte.SendCommand(F("AT+CPMS=\"SM\"\r"), THREADEDGSM_AT_TIMEOUT, "OK\r"); // SIM Message storage
|
||
|
|
state = READ_CHK_CPMS;
|
||
|
|
} else
|
||
|
|
clearReq(REQ_INBOX);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case READ_CHK_CPMS:
|
||
|
|
if (dte.getResult() == DTE::EXPECT_RESULT) {
|
||
|
|
CMD = F("AT+CMGL="); // Read all SMS messages
|
||
|
|
CMD += (int) READ_TYPE_ALL;
|
||
|
|
CMD += "\r";
|
||
|
|
dte.SendCommand(CMD.c_str(), THREADEDGSM_AT_TIMEOUT, ",");
|
||
|
|
state = READ_CHK_CMGL;
|
||
|
|
} else
|
||
|
|
clearReq(REQ_INBOX);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case READ_CHK_CMGL:
|
||
|
|
if (dte.getResult() == DTE::EXPECT_RESULT) {
|
||
|
|
// fetch index
|
||
|
|
int indexStart = dte.getBuffer().indexOf(F("+CMGL: "));
|
||
|
|
if (indexStart >= 0) {
|
||
|
|
Message.Index = dte.getBuffer().substring(indexStart + 7, dte.getBuffer().indexOf(F(","))).toInt();
|
||
|
|
if (Message.Index != 0) {
|
||
|
|
dte.Delay(2000);
|
||
|
|
state = READ_DELAY_CLEAR_BUFF;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (state != READ_DELAY_CLEAR_BUFF)
|
||
|
|
clearReq(REQ_INBOX);
|
||
|
|
|
||
|
|
break;
|
||
|
|
|
||
|
|
case READ_DELAY_CLEAR_BUFF:
|
||
|
|
dte.SendCommand(F("AT+CMGF=1\r"), THREADEDGSM_AT_TIMEOUT, "OK\r"); // SMS Message format set as TEXT
|
||
|
|
state = READ_TEXT_CMGR;
|
||
|
|
break;
|
||
|
|
|
||
|
|
case READ_TEXT_CMGR:
|
||
|
|
if (dte.getResult() == DTE::EXPECT_RESULT) {
|
||
|
|
CMD = F("AT+CMGR="); // Read the SMS message
|
||
|
|
CMD += Message.Index;
|
||
|
|
CMD += "\r";
|
||
|
|
dte.SendCommand(CMD.c_str(), THREADEDGSM_AT_TIMEOUT, "OK\r");
|
||
|
|
state = READ_CHK_CMGR;
|
||
|
|
} else
|
||
|
|
clearReq(REQ_INBOX);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case READ_CHK_CMGR:
|
||
|
|
if (dte.getResult() == DTE::EXPECT_RESULT) {
|
||
|
|
int indexStart = dte.getBuffer().indexOf(F("+CMGR: "));
|
||
|
|
if (indexStart >= 0) {
|
||
|
|
int indexStartPDU = dte.getBuffer().indexOf(F("\r\n"), indexStart);
|
||
|
|
if (indexStartPDU >= 0) {
|
||
|
|
indexStartPDU += 2;
|
||
|
|
int indexEndPDU = dte.getBuffer().indexOf(F("\r"), indexStartPDU);
|
||
|
|
if (indexEndPDU >= 0)
|
||
|
|
SMSi.Text = dte.getBuffer().substring(indexStartPDU, indexEndPDU);
|
||
|
|
}
|
||
|
|
indexStartPDU = dte.getBuffer().indexOf(F(",\""), indexStart);
|
||
|
|
if (indexStartPDU >= 0) {
|
||
|
|
indexStartPDU += 2;
|
||
|
|
int indexEndPDU = dte.getBuffer().indexOf(F("\","), indexStartPDU);
|
||
|
|
if (indexEndPDU >= 0)
|
||
|
|
SMSi.Number = dte.getBuffer().substring(indexStartPDU, indexEndPDU);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
CMD = F("AT+CMGD="); // Delete the SMS message
|
||
|
|
CMD += Message.Index;
|
||
|
|
CMD += "\r";
|
||
|
|
dte.SendCommand(CMD.c_str(), THREADEDGSM_AT_TIMEOUT, "OK\r");
|
||
|
|
state = READ_CHK_CMGD;
|
||
|
|
} else
|
||
|
|
clearReq(REQ_INBOX);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case READ_CHK_CMGD:
|
||
|
|
// if( (dte.getResult() == DTE::EXPECT_RESULT) && (SMS.InboxMsgContents != ""))
|
||
|
|
if (dte.getResult() == DTE::EXPECT_RESULT) {
|
||
|
|
if (this->configuration.incoming != nullptr)
|
||
|
|
this->configuration.incoming(*this, SMSi);
|
||
|
|
}
|
||
|
|
clearReq(REQ_INBOX);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
if (state != lastState) {
|
||
|
|
DEBUG_PRINT(F("INBOX_STATE: "));
|
||
|
|
DEBUG_PRINTLN(state);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void ThreadedGSM::Outbox()
|
||
|
|
{
|
||
|
|
String CMD;
|
||
|
|
|
||
|
|
// CMD.reserve(200);
|
||
|
|
int lastState = state;
|
||
|
|
switch (state) {
|
||
|
|
case SEND_REQ:
|
||
|
|
dte.SendCommand(F("AT+CMGF=1\r"), THREADEDGSM_AT_TIMEOUT, "OK\r"); // SMS Text mode
|
||
|
|
state = SEND_CHK_CMGF;
|
||
|
|
break;
|
||
|
|
|
||
|
|
case SEND_CHK_CMGF:
|
||
|
|
if (dte.getResult() == DTE::EXPECT_RESULT) {
|
||
|
|
CMD = F("AT+CMGS=\"");
|
||
|
|
CMD += SMSo.Number;
|
||
|
|
CMD += "\"\r";
|
||
|
|
dte.SendCommand(CMD.c_str(), 15000, "> ");
|
||
|
|
state = SEND_CHK_RDY;
|
||
|
|
} else
|
||
|
|
clearReq(REQ_OUTBOX);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case SEND_CHK_RDY:
|
||
|
|
if (dte.getResult() == DTE::EXPECT_RESULT) {
|
||
|
|
CMD = SMSo.Text;
|
||
|
|
CMD += (char) 26;
|
||
|
|
dte.SendCommand(CMD.c_str(), 10000, "OK\r");
|
||
|
|
state = SEND_CHK_OK;
|
||
|
|
} else
|
||
|
|
clearReq(REQ_OUTBOX);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case SEND_CHK_OK:
|
||
|
|
if (dte.getResult() == DTE::EXPECT_RESULT) {
|
||
|
|
if (this->configuration.outgoing != nullptr)
|
||
|
|
this->configuration.outgoing(*this);
|
||
|
|
}
|
||
|
|
clearReq(REQ_OUTBOX);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
if (state != lastState) {
|
||
|
|
DEBUG_PRINT(F("OUTBOX_STATE: "));
|
||
|
|
DEBUG_PRINTLN(state);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void ThreadedGSM::CheckRing()
|
||
|
|
{
|
||
|
|
int lastState = ringState;
|
||
|
|
switch (ringState) {
|
||
|
|
case RING_WAIT:
|
||
|
|
break;
|
||
|
|
|
||
|
|
case RING_CHK:
|
||
|
|
if (this->configuration.ring != nullptr) {
|
||
|
|
String s = "Ring";
|
||
|
|
this->configuration.ring(*this, s);
|
||
|
|
}
|
||
|
|
ringState = RING_WAIT;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
if (ringState != lastState) {
|
||
|
|
DEBUG_PRINT(F("RING_STATE: "));
|
||
|
|
DEBUG_PRINTLN(ringState);
|
||
|
|
}
|
||
|
|
}
|