SIMlib.cpp

Go to the documentation of this file.

 
#include "utility/SIMlib.h"
 
#ifdef HW_SERIAL
GSM::GSM(long baud){
    #ifdef ESP32
        Serial2.begin(DEFAULT_BAUD_RATE, SERIAL_8N1, RX, TX);
    #else
        Serial2.begin(baud);
    #endif
 
    _pSerialHandler = new SerialHandler(&Serial2);
    _pParser = new ParserGSM(_pSerialHandler, &_newMsg, &_lastMsgIndex);
    _pPhoneBuffer = _pParser->getPointPhoneBuf();
}
#endif
 
GSM::GSM(uint8_t rx, uint8_t tx, long baud) {
Stream *pGsmSerial = nullptr;
 
#ifdef SW_SERIAL
    #ifdef ESP8266
        pGsmSerial = new SoftwareSerial();
        ((SoftwareSerial*) pGsmSerial)->begin(baud, SWSERIAL_8N1, rx, tx, false, RX_BUF_SIZE, 0);
    #else
        pGsmSerial = new SoftwareSerial(rx, tx);
        ((SoftwareSerial*) pGsmSerial)->begin(baud);
    #endif
#else
    #ifdef ESP32
        Serial2.begin(baud, SERIAL_8N1, rx, tx);
    #else
        Serial2.begin(baud);
    #endif
    pGsmSerial = &Serial2;
#endif
    _pSerialHandler = new SerialHandler(pGsmSerial);
    _pParser = new ParserGSM(_pSerialHandler, &_newMsg, &_lastMsgIndex);
    _pPhoneBuffer = _pParser->getPointPhoneBuf();   
}
 
GSM::GSM(Stream* pGsmSerial) {
    _pSerialHandler = new SerialHandler(pGsmSerial);
    _pParser = new ParserGSM(_pSerialHandler, &_newMsg, &_lastMsgIndex);
    _pPhoneBuffer = _pParser->getPointPhoneBuf();   
}
 
void GSM::checkGsmOutput(){
    _pSerialHandler->periodicSerialCheck();
    //check if SMS is received
    if(_pSerialHandler->isRxBufferAvailable()){
        if(_pParser->identifyIncomingMsg(incomingSms)){
            if(sendCommand(_pParser->makeDynamicCmd(smsReading, _lastMsgIndex))){
                _pParser->getPhoneNumber();
                _pParser->getMsg();
                _pMsgBuffer = _pParser->getPointMsgBuf();
                if(_lastMsgIndex > 10){
                    deleteMsgGsmStack();
                }
                else{
                    deleteMsg();
                }
            }
            else{
                Serial.println(F("ERR"));
                deleteMsgGsmStack();
            }
        }
    }
    _pSerialHandler->setRxBufferAvailability(false);
}
 
bool GSM::isNewMsgAvailable(){
    return _newMsg;
}
 
char* GSM::getMsg(){
    _newMsg = false; //sms is returned, preparing logical variable for new msg
    return _pMsgBuffer;
}
 
char* GSM::getPhoneNum(){
    return _pPhoneBuffer;
}
 
void GSM::begin(){
    while(sendCommand(basicCommand) != true){
        delay(1000);
        Serial.println(F("GSM IS OFFLINE"));
    }
    Serial.println(F("GSM IS ONLINE"));
    delay(1000);
    while(sendCommand(gsmMode) != true){
        delay(1000);
        Serial.println(F("CONFIG FAILED"));
    }
    Serial.println(F("GSM IS CONFIGURED"));
    delay(1000);
    while(sendCommand(plainTextMode) != true){
        delay(1000);
        Serial.println(F("MSG SETTING FAILED"));
    }
    Serial.println(F("MSG SET TO TEXT"));
    delay(1000);
}
 
bool GSM::sendCommand(const char* cmd){
    _pSerialHandler->serialWrite(cmd);
    return _pParser->getResponse(confirmFeedback);
}
 
void GSM::deleteMsg(){
    if(sendCommand(_pParser->makeDynamicCmd(deleteSms, _lastMsgIndex))){
        Serial.println(F("MSG DELETED"));
        _lastMsgIndex--;
    }
    else{
        Serial.println(F("DELETE ERR"));
    }
}
 
void GSM::deleteMsgGsmStack(){
    while(_lastMsgIndex != 0){
        deleteMsg();
    }
}
 
GSM::ParserGSM::ParserGSM(GSM::SerialHandler* pSerialHandler, bool* newMsg, uint8_t* lastMsgIndex){
    _pSerialHandler = pSerialHandler;
    _pNewMsg = newMsg;
    _pLastMsgIndex = lastMsgIndex;
}
 
bool GSM::ParserGSM::getResponse(const char* searchedChar){
    _pSerialHandler->feedbackSerialCheck();
    _pRxBuffer = _pSerialHandler->getRxBufferP();
    if(_pSerialHandler->isRxBufferAvailable()){
        if(strstr(_pRxBuffer, "OK") != nullptr){
            _pSerialHandler->setRxBufferAvailability(false);
            return true;
        }
        else{
            return false;
        }
    }
    return false;
}
 
void GSM::ParserGSM::getMsg(){
    _pRxBuffer = _pSerialHandler->getRxBufferP();
    char* tmpStr = strrchr(_pRxBuffer, '\"') + 3;
    //if semicolon is not present, message is not valid
    if(strrchr(tmpStr, ';') != nullptr){
        char* endMsgPointer = strrchr(tmpStr, ';') + 1;
        uint8_t counter = 0;
 
        if(_msgBuffer != nullptr){
            free(_msgBuffer);
        }
        _msgBuffer = (char*)malloc(strlen(tmpStr) - strlen(endMsgPointer) + 1);
        while(&tmpStr[counter] != endMsgPointer){
            _msgBuffer[counter] = tmpStr[counter];
            counter++;
        }
        _msgBuffer[counter] = '\0';
        *_pNewMsg = true;
    }
}
 
void GSM::ParserGSM::getPhoneNumber(){
    _pRxBuffer = _pSerialHandler->getRxBufferP();
    char* tmpStr = strstr(_pRxBuffer, "\"+") + 2;
    char* endMsgPointer = strstr(tmpStr, "\",\"\",\"");
    uint8_t counter = 0;
 
    memset(_phoneBuffer, 0, sizeof(_phoneBuffer));
    while(&tmpStr[counter] != endMsgPointer){
        _phoneBuffer[counter] = tmpStr[counter];
        counter++;
    }
    _phoneBuffer[counter] = '\0';
}
 
char* GSM::ParserGSM::getPointMsgBuf(){
    return _msgBuffer;
}
 
char* GSM::ParserGSM::getPointPhoneBuf(){
    return _phoneBuffer;
}
 
bool GSM::ParserGSM::identifyIncomingMsg(const char* command){
    _pRxBuffer = _pSerialHandler->getRxBufferP();
    char *tmpStr = strstr(_pRxBuffer, command);
    if(tmpStr != nullptr){
        if(strncmp(tmpStr, incomingSms, strlen(incomingSms)) == 0){
            *_pLastMsgIndex = GetIndex(tmpStr, ',');
            _pSerialHandler->setRxBufferAvailability(false);
            return true;
        }
    }
    _pSerialHandler->setRxBufferAvailability(false);
    return false;    
}
 
char* GSM::ParserGSM::makeDynamicCmd(const char* command, uint8_t id){
    if(_cmdBuffer != nullptr){
        free(_cmdBuffer);
    }
 
    //+ 3 – array cells for 2 digit number and end char
    _cmdBuffer = (char*)malloc(strlen(command) + 3);
    strcpy(_cmdBuffer, command);
    sprintf(&_cmdBuffer[strlen(command)], "%d", id);
    _cmdBuffer[strlen(command) + 2] = '\0';
    return _cmdBuffer;
}
 
uint8_t GSM::ParserGSM::GetIndex(char* buffer, char startSym){
    char *tmpStr = strchr(buffer, startSym) + 1;
    uint8_t indexLenCount = 0;
    while(tmpStr[indexLenCount] >= 0x31 && tmpStr[indexLenCount] <= 0x39){
        indexLenCount++;
    }
    tmpStr[indexLenCount] = '\0';
    return (uint8_t)atoi(tmpStr);
}
 
GSM::SerialHandler::SerialHandler(Stream* pGsmSerial){
    _pGsmSerial = pGsmSerial;
}
void GSM::SerialHandler::serialWrite(const char* command){
    _periodicReading = false;
    _pGsmSerial->println(command);
    _pGsmSerial->flush();
    delay(200);
    _periodicReading = true;
}
 
void GSM::SerialHandler::periodicSerialCheck(){
    if(_periodicReading){
        if(_periodicReadingFlag){
            _lastReadTime = millis();
            _periodicReadingFlag = false;
        }
 
        if((millis() - _lastReadTime) >= PERIODIC_READ_TIME){
            uint16_t var;
            var = _pGsmSerial->available();
            delay(100);
            if(var > 0 && _periodicReading){
                serialRead(var);
            }
            _periodicReadingFlag = true;
        }
    }
}
 
void GSM::SerialHandler::feedbackSerialCheck(){
    unsigned long timeFlag = millis();
    while(millis() < (timeFlag + 1000)){
        uint16_t var;
        var = _pGsmSerial->available();
        delay(100);
        if(var > 0){
            serialRead(var);
            break;
        }
    }
}
 
char* GSM::SerialHandler::getRxBufferP(){
    return _rxBuffer;
}
 
bool GSM::SerialHandler::isRxBufferAvailable(){
    return _rxBufferAvailable;
}
 
void GSM::SerialHandler::setRxBufferAvailability(bool var){
    _rxBufferAvailable = var;
}
 
void GSM::SerialHandler::serialRead(uint8_t incomingBytes){
    if(_rxBuffer != nullptr){
        free(_rxBuffer);
        _rxBuffer = nullptr;
    }
    _rxBuffer = (char*)malloc(sizeof(char) * (incomingBytes + 1));
    _pGsmSerial->readBytes(_rxBuffer, incomingBytes);
    _rxBuffer[incomingBytes] = '\0';
    _rxBufferAvailable = true;
}