From 78bd8a981d75eb21b14dcad5596f518f0b38dfd4 Mon Sep 17 00:00:00 2001 From: Pablo2048 Date: Sun, 3 Sep 2023 12:22:16 +0200 Subject: [PATCH] Prejmenovani promennych pro zbaveni se this-> --- src/DTE.cpp | 102 ++++++------ src/DTE.h | 16 +- src/ThreadedGSM.cpp | 370 ++++++++++++++++++++++---------------------- src/ThreadedGSM.h | 30 ++-- 4 files changed, 259 insertions(+), 259 deletions(-) diff --git a/src/DTE.cpp b/src/DTE.cpp index 738a24b..a394160 100644 --- a/src/DTE.cpp +++ b/src/DTE.cpp @@ -1,114 +1,114 @@ #include "DTE.h" DTE::DTE(Stream & stream, unsigned int size) - : stream(stream), bufferSize(size), result(EXPECT_RESULT) + : mStream(stream), mBufferSize(size), mResult(EXPECT_RESULT) { - buffer.reserve(size); + mBuffer.reserve(size); } void DTE::SendCommand(const char * command, unsigned long timeout, const char * response1, const char * response2, const char * response3) { - match = 0; - result = EXPECT_BUSY; - response[0] = response1; - response[1] = response2; - response[2] = response3; - this->timeout = timeout; + mMatch = 0; + mResult = EXPECT_BUSY; + mResponse[0] = response1; + mResponse[1] = response2; + mResponse[2] = response3; + mTimeout = timeout; flush(); - stream.print(command); - buffer = ""; - tick = millis(); + mStream.print(command); + mBuffer = ""; + mTick = millis(); process(); } void DTE::SendCommand(const __FlashStringHelper * command, unsigned long timeout, const char * response1, const char * response2, const char * response3) { - match = 0; - result = EXPECT_BUSY; - response[0] = response1; - response[1] = response2; - response[2] = response3; - this->timeout = timeout; - // clear rx buffer + mMatch = 0; + mResult = EXPECT_BUSY; + mResponse[0] = response1; + mResponse[1] = response2; + mResponse[2] = response3; + mTimeout = timeout; + // clear rx mBuffer flush(); // send command - stream.print((const __FlashStringHelper *) command); - buffer = ""; - tick = millis(); + mStream.print((const __FlashStringHelper *) command); + mBuffer = ""; + mTick = millis(); process(); } void DTE::Delay(unsigned long delay) { - timeout = delay; - result = EXPECT_DELAY; - tick = millis(); + mTimeout = delay; + mResult = EXPECT_DELAY; + mTick = millis(); process(); } bool DTE::getIsBusy() { process(); - return (result == EXPECT_BUSY) || (result == EXPECT_DELAY); + return (mResult == EXPECT_BUSY) || (mResult == EXPECT_DELAY); } DTE::CommandResult DTE::getResult() { - return result; + return mResult; } unsigned int DTE::getMatch() const { - return match; + return mMatch; } String & DTE::getBuffer() { - return buffer; + return mBuffer; } void DTE::flush() { - // clear rx buffer - while (stream.available()) { - stream.read(); + // clear rx mBuffer + while (mStream.available()) { + mStream.read(); } } void DTE::process() { - if (result == EXPECT_DELAY) { - if (millis() - tick >= timeout) - result = EXPECT_RESULT; + if (mResult == EXPECT_DELAY) { + if (millis() - mTick >= mTimeout) + mResult = EXPECT_RESULT; return; } - if (result != EXPECT_BUSY) + if (mResult != EXPECT_BUSY) return; char c; unsigned long now = millis(); - while (millis() - tick < timeout) { - while (stream.available() && (buffer.length() < bufferSize)) { - c = stream.read(); - buffer.concat(c); - if (buffer.endsWith(response[0])) { - match = 0; - result = EXPECT_RESULT; + while (millis() - mTick < mTimeout) { + while (mStream.available() && (mBuffer.length() < mBufferSize)) { + c = mStream.read(); + mBuffer.concat(c); + if (mBuffer.endsWith(mResponse[0])) { + mMatch = 0; + mResult = EXPECT_RESULT; return; - } else if (response[1].length() != 0) { - if (buffer.endsWith(response[1])) { - match = 1; - result = EXPECT_RESULT; + } else if (mResponse[1].length() != 0) { + if (mBuffer.endsWith(mResponse[1])) { + mMatch = 1; + mResult = EXPECT_RESULT; return; } - } else if (response[2].length() != 0) { - if (buffer.endsWith(response[2])) { - match = 2; - result = EXPECT_RESULT; + } else if (mResponse[2].length() != 0) { + if (mBuffer.endsWith(mResponse[2])) { + mMatch = 2; + mResult = EXPECT_RESULT; return; } } @@ -118,5 +118,5 @@ void DTE::process() } // time out - result = EXPECT_TIMEOUT; + mResult = EXPECT_TIMEOUT; } diff --git a/src/DTE.h b/src/DTE.h index 63c928e..57afdab 100644 --- a/src/DTE.h +++ b/src/DTE.h @@ -18,14 +18,14 @@ class DTE { }; protected: - String buffer; - Stream & stream; - unsigned int bufferSize; - String response[3]; - unsigned long timeout; - unsigned long tick; - unsigned int match; - CommandResult result; + String mBuffer; + Stream & mStream; + unsigned int mBufferSize; + String mResponse[3]; + unsigned long mTimeout; + unsigned long mTick; + unsigned int mMatch; + CommandResult mResult; public: DTE(Stream & stream, unsigned int size); diff --git a/src/ThreadedGSM.cpp b/src/ThreadedGSM.cpp index 5747e87..3d5e5f9 100644 --- a/src/ThreadedGSM.cpp +++ b/src/ThreadedGSM.cpp @@ -9,29 +9,28 @@ #endif ThreadedGSM::ThreadedGSM(Stream & stream) - : stream(stream), dte(stream, THREADEDGSM_DTE_BUFFER_SIZE), ringState(RING_WAIT) + : mStream(stream), mDte(stream, THREADEDGSM_DTE_BUFFER_SIZE), mRingState(RING_WAIT) { - for (unsigned long & Interval : Intervals) - Interval = 0; - job = state = requests = 0; - // SMSo.Text.reserve(150); - // SMSi.Text.reserve(150); + mSMSo.Text.reserve(150); + mSMSi.Text.reserve(150); } void ThreadedGSM::nextJob() { - job = 0; + + mJob = 0; } void ThreadedGSM::setHandlers(conf config) { - this->configuration = config; + mConfiguration = config; } void ThreadedGSM::setInterval(IntervalSourceE source, unsigned long interval) { + Intervals[source] = interval; tickSync[source] = millis(); } @@ -39,14 +38,15 @@ void ThreadedGSM::setInterval(IntervalSourceE source, unsigned long interval) // Initialization void ThreadedGSM::begin() { - requests = (REQ_STARTUP); + + mRequests = (REQ_STARTUP); TimeBase.attachLoop(this); } // Call this function for executing thread void ThreadedGSM::exec() { - if (dte.getIsBusy()) + if (mDte.getIsBusy()) return; // intervals @@ -55,19 +55,19 @@ void ThreadedGSM::exec() if (millis() - tickSync[i] >= Intervals[i]) { switch (i) { case INTERVAL_CLOCK: - requests |= REQ_CLOCK; + mRequests |= REQ_CLOCK; break; case INTERVAL_INBOX: - requests |= REQ_INBOX; + mRequests |= REQ_INBOX; break; case INTERVAL_SIGNAL: - requests |= REQ_SIG; + mRequests |= REQ_SIG; break; case INTERVAL_BATTERY: - requests |= REQ_BATTERY; + mRequests |= REQ_BATTERY; break; } tickSync[i] = millis(); @@ -75,40 +75,40 @@ void ThreadedGSM::exec() } } - 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 (mJob == 0) { + // no assigned mJob, assign it + if (mRequests & REQ_CLOCK) + mJob = REQ_CLOCK; + else if (mRequests & REQ_SIG) + mJob = REQ_SIG; + else if (mRequests & REQ_INBOX) + mJob = REQ_INBOX; + else if (mRequests & REQ_OUTBOX) + mJob = REQ_OUTBOX; + else if (mRequests & REQ_STARTUP) + mJob = REQ_STARTUP; + else if (mRequests & REQ_BATTERY) + mJob = REQ_BATTERY; - if (job) { - state = 0; + if (mJob) { + mState = 0; DEBUG_PRINT(F("Job ID: ")); - DEBUG_PRINTLN(job); + DEBUG_PRINTLN(mJob); } } - // execute current job - if (job == REQ_STARTUP) + // execute current mJob + if (mJob == REQ_STARTUP) Startup(); - else if (job == REQ_CLOCK) + else if (mJob == REQ_CLOCK) Clock(); - else if (job == REQ_SIG) + else if (mJob == REQ_SIG) Signal(); - else if (job == REQ_INBOX) + else if (mJob == REQ_INBOX) Inbox(); - else if (job == REQ_OUTBOX) + else if (mJob == REQ_OUTBOX) Outbox(); - else if (job == REQ_BATTERY) + else if (mJob == REQ_BATTERY) Battery(); else CheckRing(); @@ -117,9 +117,9 @@ void ThreadedGSM::exec() // Requests void ThreadedGSM::sendSMS(String & Number, String & Text) { - requests |= (REQ_OUTBOX); - SMSo.Number = Number; - SMSo.Text = Text; + mRequests |= (REQ_OUTBOX); + mSMSo.Number = Number; + mSMSo.Text = Text; } void ThreadedGSM::sendSMS(String & Number, const char * Text) @@ -132,90 +132,90 @@ void ThreadedGSM::sendSMS(String & Number, const char * Text) // States void ThreadedGSM::Startup() { - int lastState = state; - switch (state) { + int lastState = mState; + switch (mState) { case STARTUP_POWER_OFF: - if (this->configuration.power != nullptr) - this->configuration.power(*this, false); - tick = millis(); - state = STARTUP_POWER_OFF_DELAY; + if (mConfiguration.power != nullptr) + mConfiguration.power(*this, false); + mTick = millis(); + mState = STARTUP_POWER_OFF_DELAY; break; case STARTUP_POWER_OFF_DELAY: - if (millis() - tick >= THREADEDGSM_STARTUP_POWER_OFF_DELAY) - state = STARTUP_POWER_ON; + if (millis() - mTick >= THREADEDGSM_STARTUP_POWER_OFF_DELAY) + mState = STARTUP_POWER_ON; break; case STARTUP_POWER_ON: - if (this->configuration.power != nullptr) - this->configuration.power(*this, true); + if (mConfiguration.power != nullptr) + mConfiguration.power(*this, true); // begin delay - tick = millis(); - state = STARTUP_DELAY; + mTick = millis(); + mState = 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; + if (millis() - mTick >= THREADEDGSM_STARTUP_DELAY) { + mDte.SendCommand(F("AT\r"), THREADEDGSM_AT_TIMEOUT, "OK\r"); + mState = 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; + if (mDte.getResult() == DTE::EXPECT_RESULT) { + mDte.SendCommand(F("AT+CPIN?\r"), 10000, "OK\r"); + mState = STARTUP_CHK_CPIN; } else { - state = STARTUP_POWER_OFF; + mState = 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; + if (mDte.getResult() == DTE::EXPECT_RESULT) { + if (mDte.getBuffer().indexOf(F("+CPIN: READY")) != -1) { + mDte.SendCommand(F("AT+CREG?\r"), THREADEDGSM_AT_TIMEOUT, "OK\r"); + mState = STARTUP_CHK_CREG; } else { - state = STARTUP_POWER_OFF; + mState = STARTUP_POWER_OFF; } } else - state = STARTUP_POWER_OFF; + mState = 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; + if (mDte.getResult() == DTE::EXPECT_RESULT) { + if ((mDte.getBuffer().indexOf(F(",1")) >= 0) || (mDte.getBuffer().indexOf(F(",5")) >= 0)) { + mDte.SendCommand(F("AT+CLTS=1\r"), THREADEDGSM_AT_TIMEOUT, "OK\r"); + mState = STARTUP_CHK_CLTS; } else - state = STARTUP_POWER_OFF; + mState = STARTUP_POWER_OFF; } else - state = STARTUP_POWER_OFF; + mState = 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; + if (mDte.getResult() == DTE::EXPECT_RESULT) { + mDte.SendCommand(F("AT+CENG=3\r"), THREADEDGSM_AT_TIMEOUT, "OK\r"); + mState = STARTUP_CHK_CENG; } else - state = STARTUP_POWER_OFF; + mState = STARTUP_POWER_OFF; break; case STARTUP_CHK_CENG: - if (dte.getResult() == DTE::EXPECT_RESULT) { - requests |= ((REQ_CLOCK) | (REQ_SIG) | (REQ_BATTERY)); + if (mDte.getResult() == DTE::EXPECT_RESULT) { + mRequests |= ((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); + for (unsigned long & i : tickSync) + i = millis(); + if (mConfiguration.ready != nullptr) + mConfiguration.ready(*this); } else - state = STARTUP_POWER_OFF; + mState = STARTUP_POWER_OFF; break; } - if (state != lastState) { + if (mState != lastState) { DEBUG_PRINT(F("STARTUP_STATE: ")); - DEBUG_PRINTLN(state); + DEBUG_PRINTLN(mState); } } @@ -223,26 +223,26 @@ void ThreadedGSM::Startup() void ThreadedGSM::Clock() { String clockTime; - int lastState = state; - switch (state) { + int lastState = mState; + switch (mState) { case CLOCK_REQ: - dte.SendCommand(F("AT+CCLK?\r"), THREADEDGSM_AT_TIMEOUT, "OK\r"); - state = CLOCK_VERIFY; + mDte.SendCommand(F("AT+CCLK?\r"), THREADEDGSM_AT_TIMEOUT, "OK\r"); + mState = CLOCK_VERIFY; break; case CLOCK_VERIFY: - int index = dte.getBuffer().indexOf(F("+CCLK: ")); + int index = mDte.getBuffer().indexOf(F("+CCLK: ")); if (index >= 0) { // parse clock index += 8; int endindex; - endindex = dte.getBuffer().indexOf(F("+"), index); + endindex = mDte.getBuffer().indexOf(F("+"), index); if (endindex >= 0) - clockTime = dte.getBuffer().substring(index, endindex); + clockTime = mDte.getBuffer().substring(index, endindex); else { - endindex = dte.getBuffer().indexOf(F("-"), index); + endindex = mDte.getBuffer().indexOf(F("-"), index); if (endindex >= 0) - clockTime = dte.getBuffer().substring(index, endindex); + clockTime = mDte.getBuffer().substring(index, endindex); } if (endindex >= 0) { @@ -254,192 +254,192 @@ void ThreadedGSM::Clock() 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); + if (mConfiguration.clock != nullptr) + mConfiguration.clock(*this, ClockTime); } } clearReq(REQ_CLOCK); break; } - if (state != lastState) { + if (mState != lastState) { DEBUG_PRINT(F("CLOCK_STATE: ")); - DEBUG_PRINTLN(state); + DEBUG_PRINTLN(mState); } } void ThreadedGSM::Signal() { - int lastState = state; - switch (state) { + int lastState = mState; + switch (mState) { case SIGNAL_REQ: - dte.SendCommand(F("AT+CSQ\r"), THREADEDGSM_AT_TIMEOUT, "OK\r"); - state = SIGNAL_VERIFY; + mDte.SendCommand(F("AT+CSQ\r"), THREADEDGSM_AT_TIMEOUT, "OK\r"); + mState = SIGNAL_VERIFY; break; case SIGNAL_VERIFY: - int index = dte.getBuffer().indexOf(F("+CSQ: ")); + int index = mDte.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(); + GsmSignal.Value = mDte.getBuffer().substring(index, index + 2).toInt(); + GsmSignal.Dbm = mDte.getBuffer().substring(index + 3, index + 5).toInt(); if (GsmSignal.Value != 0) { - if (this->configuration.signal != nullptr) - this->configuration.signal(*this, GsmSignal); + if (mConfiguration.signal != nullptr) + mConfiguration.signal(*this, GsmSignal); } } clearReq(REQ_SIG); break; } - if (state != lastState) { + if (mState != lastState) { DEBUG_PRINT(F("SIGNAL_STATE: ")); - DEBUG_PRINTLN(state); + DEBUG_PRINTLN(mState); } } void ThreadedGSM::Battery() { - int lastState = state; - switch (state) { + int lastState = mState; + switch (mState) { case BATTERY_REQ: - dte.SendCommand(F("AT+CBC\r"), THREADEDGSM_AT_TIMEOUT, "OK\r"); - state = BATTERY_VERIFY; + mDte.SendCommand(F("AT+CBC\r"), THREADEDGSM_AT_TIMEOUT, "OK\r"); + mState = BATTERY_VERIFY; break; case BATTERY_VERIFY: - int index = dte.getBuffer().indexOf(F("+CBC:")); + int index = mDte.getBuffer().indexOf(F("+CBC:")); if (index >= 0) { BatteryInfo BattInfo{}; // parse battery level - String buffer = dte.getBuffer().substring(index); + String buffer = mDte.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 + BattInfo.Percent = buffer2.substring(0, buffer2.indexOf(F(","))).toInt(); // converts the mResult 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); + BattInfo.Voltage = buffer2.substring(0, buffer2.indexOf(F("\r"))).toInt(); // converts the mResult to interger + if (mConfiguration.battery != nullptr) + mConfiguration.battery(*this, BattInfo); } clearReq(REQ_BATTERY); break; } - if (state != lastState) { + if (mState != lastState) { DEBUG_PRINT(F("BATTERY_STATE: ")); - DEBUG_PRINTLN(state); + DEBUG_PRINTLN(mState); } } void ThreadedGSM::clearReq(int req) { - requests &= ~(req); + mRequests &= ~(req); nextJob(); } void ThreadedGSM::Inbox() { String CMD; - int lastState = state; - switch (state) { + int lastState = mState; + switch (mState) { 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; + mSMSi.Text = ""; + mSMSi.Number = ""; + mDte.SendCommand(F("AT+CMGF=0\r"), THREADEDGSM_AT_TIMEOUT, "OK\r"); // SMS Message format set as PDU + mState = 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; + if (mDte.getResult() == DTE::EXPECT_RESULT) { + mDte.SendCommand(F("AT+CPMS=\"SM\"\r"), THREADEDGSM_AT_TIMEOUT, "OK\r"); // SIM Message storage + mState = READ_CHK_CPMS; } else clearReq(REQ_INBOX); break; case READ_CHK_CPMS: - if (dte.getResult() == DTE::EXPECT_RESULT) { + if (mDte.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; + mDte.SendCommand(CMD.c_str(), THREADEDGSM_AT_TIMEOUT, ","); + mState = READ_CHK_CMGL; } else clearReq(REQ_INBOX); break; case READ_CHK_CMGL: - if (dte.getResult() == DTE::EXPECT_RESULT) { + if (mDte.getResult() == DTE::EXPECT_RESULT) { // fetch index - int indexStart = dte.getBuffer().indexOf(F("+CMGL: ")); + int indexStart = mDte.getBuffer().indexOf(F("+CMGL: ")); if (indexStart >= 0) { - Message.Index = dte.getBuffer().substring(indexStart + 7, dte.getBuffer().indexOf(F(","))).toInt(); + Message.Index = mDte.getBuffer().substring(indexStart + 7, mDte.getBuffer().indexOf(F(","))).toInt(); if (Message.Index != 0) { - dte.Delay(2000); - state = READ_DELAY_CLEAR_BUFF; + mDte.Delay(2000); + mState = READ_DELAY_CLEAR_BUFF; } } } - if (state != READ_DELAY_CLEAR_BUFF) + if (mState != 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; + mDte.SendCommand(F("AT+CMGF=1\r"), THREADEDGSM_AT_TIMEOUT, "OK\r"); // SMS Message format set as TEXT + mState = READ_TEXT_CMGR; break; case READ_TEXT_CMGR: - if (dte.getResult() == DTE::EXPECT_RESULT) { + if (mDte.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; + mDte.SendCommand(CMD.c_str(), THREADEDGSM_AT_TIMEOUT, "OK\r"); + mState = 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 (mDte.getResult() == DTE::EXPECT_RESULT) { + int indexStart = mDte.getBuffer().indexOf(F("+CMGR: ")); if (indexStart >= 0) { - int indexStartPDU = dte.getBuffer().indexOf(F("\r\n"), indexStart); + int indexStartPDU = mDte.getBuffer().indexOf(F("\r\n"), indexStart); if (indexStartPDU >= 0) { indexStartPDU += 2; - int indexEndPDU = dte.getBuffer().indexOf(F("\r"), indexStartPDU); + int indexEndPDU = mDte.getBuffer().indexOf(F("\r"), indexStartPDU); if (indexEndPDU >= 0) - SMSi.Text = dte.getBuffer().substring(indexStartPDU, indexEndPDU); + mSMSi.Text = mDte.getBuffer().substring(indexStartPDU, indexEndPDU); } - indexStartPDU = dte.getBuffer().indexOf(F(",\""), indexStart); + indexStartPDU = mDte.getBuffer().indexOf(F(",\""), indexStart); if (indexStartPDU >= 0) { indexStartPDU += 2; - int indexEndPDU = dte.getBuffer().indexOf(F("\","), indexStartPDU); + int indexEndPDU = mDte.getBuffer().indexOf(F("\","), indexStartPDU); if (indexEndPDU >= 0) - SMSi.Number = dte.getBuffer().substring(indexStartPDU, indexEndPDU); + mSMSi.Number = mDte.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; + mDte.SendCommand(CMD.c_str(), THREADEDGSM_AT_TIMEOUT, "OK\r"); + mState = 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); + // if( (mDte.getResult() == DTE::EXPECT_RESULT) && (SMS.InboxMsgContents != "")) + if (mDte.getResult() == DTE::EXPECT_RESULT) { + if (mConfiguration.incoming != nullptr) + mConfiguration.incoming(*this, mSMSi); } clearReq(REQ_INBOX); break; } - if (state != lastState) { + if (mState != lastState) { DEBUG_PRINT(F("INBOX_STATE: ")); - DEBUG_PRINTLN(state); + DEBUG_PRINTLN(mState); } } @@ -448,65 +448,65 @@ void ThreadedGSM::Outbox() String CMD; // CMD.reserve(200); - int lastState = state; - switch (state) { + int lastState = mState; + switch (mState) { case SEND_REQ: - dte.SendCommand(F("AT+CMGF=1\r"), THREADEDGSM_AT_TIMEOUT, "OK\r"); // SMS Text mode - state = SEND_CHK_CMGF; + mDte.SendCommand(F("AT+CMGF=1\r"), THREADEDGSM_AT_TIMEOUT, "OK\r"); // SMS Text mode + mState = SEND_CHK_CMGF; break; case SEND_CHK_CMGF: - if (dte.getResult() == DTE::EXPECT_RESULT) { + if (mDte.getResult() == DTE::EXPECT_RESULT) { CMD = F("AT+CMGS=\""); - CMD += SMSo.Number; + CMD += mSMSo.Number; CMD += "\"\r"; - dte.SendCommand(CMD.c_str(), 15000, "> "); - state = SEND_CHK_RDY; + mDte.SendCommand(CMD.c_str(), 15000, "> "); + mState = SEND_CHK_RDY; } else clearReq(REQ_OUTBOX); break; case SEND_CHK_RDY: - if (dte.getResult() == DTE::EXPECT_RESULT) { - CMD = SMSo.Text; + if (mDte.getResult() == DTE::EXPECT_RESULT) { + CMD = mSMSo.Text; CMD += (char) 26; - dte.SendCommand(CMD.c_str(), 10000, "OK\r"); - state = SEND_CHK_OK; + mDte.SendCommand(CMD.c_str(), 10000, "OK\r"); + mState = 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); + if (mDte.getResult() == DTE::EXPECT_RESULT) { + if (mConfiguration.outgoing != nullptr) + mConfiguration.outgoing(*this); } clearReq(REQ_OUTBOX); break; } - if (state != lastState) { + if (mState != lastState) { DEBUG_PRINT(F("OUTBOX_STATE: ")); - DEBUG_PRINTLN(state); + DEBUG_PRINTLN(mState); } } void ThreadedGSM::CheckRing() { - int lastState = ringState; - switch (ringState) { + int lastState = mRingState; + switch (mRingState) { case RING_WAIT: break; case RING_CHK: - if (this->configuration.ring != nullptr) { + if (mConfiguration.ring != nullptr) { String s = "Ring"; - this->configuration.ring(*this, s); + mConfiguration.ring(*this, s); } - ringState = RING_WAIT; + mRingState = RING_WAIT; break; } - if (ringState != lastState) { + if (mRingState != lastState) { DEBUG_PRINT(F("RING_STATE: ")); - DEBUG_PRINTLN(ringState); + DEBUG_PRINTLN(mRingState); } } diff --git a/src/ThreadedGSM.h b/src/ThreadedGSM.h index bc08a7b..26f0c72 100644 --- a/src/ThreadedGSM.h +++ b/src/ThreadedGSM.h @@ -144,25 +144,25 @@ class ThreadedGSM : public Executable RING_CHK, }; - unsigned long tick; + unsigned long mTick = 0; struct { - int Index; // Index of readed message - } Message; + int Index; // Index of read message + } Message{}; - SMSInfo SMSi; // Inbox SMS (incoming) - SMSInfo SMSo; // Outbox SMS (outgoing) + SMSInfo mSMSi; // Inbox SMS (incoming) + SMSInfo mSMSo; // Outbox SMS (outgoing) - Stream & stream; - DTE dte; + Stream & mStream; + DTE mDte; - unsigned long tickSync[THREADEDGSM_INTERVAL_COUNT]; - unsigned long Intervals[THREADEDGSM_INTERVAL_COUNT]; + unsigned long tickSync[THREADEDGSM_INTERVAL_COUNT]{}; + unsigned long Intervals[THREADEDGSM_INTERVAL_COUNT]{}; // callbacks - // conf configuration = {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}; - conf configuration{0}; + // conf mConfiguration = {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}; + conf mConfiguration{}; enum ReqTypes { REQ_CLOCK = 1, @@ -172,10 +172,10 @@ class ThreadedGSM : public Executable REQ_STARTUP = 16, REQ_BATTERY = 32, }; - int requests; - int state; - int job; - int ringState; + int mRequests = 0; + int mState = 0; + int mJob = 0; + int mRingState; // functions public: explicit ThreadedGSM(Stream & stream);