What is proper way to read and delete message from SIM900?

Question

I would like to wait in loop for sms message arrival on my SIM900 and when message is detected , read that message and delete it from the system. What's bothering me is what if another message comes while I am working on this one (Unsolicited message info).

What is proper algorithm to handle sms reading and deletion?

Answer 1

This is how I do similar task

• At start delete all sms from sim memory
• Enable new message alerts using AT+CNMI command
• Use Interrupt based serial communication and make use of a ring buffer to store all in-coming data
• Whenever you will get a new message the modem will send an alert to the controller.
• parse the alert message to know the location of sms
• After reading the SMS delete the sms

---

Below is another approach.

        /*
    *  Description: This example shows hot to read a SMS from SIM memory.
    *  This example only shows the AT commands (and the answers of the module) used
    *  to read the SMS For more information about the AT commands, refer to the AT 
    *  command manual.
    *
    *  Copyright (C) 2013 Libelium Comunicaciones Distribuidas S.L.
    *  http://www.libelium.com
    *
    *  This program is free software: you can redistribute it and/or modify 
    *  it under the terms of the GNU General Public License as published by 
    *  the Free Software Foundation, either version 3 of the License, or 
    *  (at your option) any later version. 
    *  
    *  This program is distributed in the hope that it will be useful, 
    *  but WITHOUT ANY WARRANTY; without even the implied warranty of 
    *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
    *  GNU General Public License for more details. 
    *  
    *  You should have received a copy of the GNU General Public License 
    *  along with this program.  If not, see <http://www.gnu.org/licenses/>. 
    *
    *  Version 0.2
    *  Author: Alejandro Gallego 
    */

    int8_t answer;
    int x;
    int onModulePin= 2;
    char SMS[200];

    void setup(){

        pinMode(onModulePin, OUTPUT);
        Serial.begin(115200);  

        Serial.println("Starting...");
        power_on();

        delay(3000);

        // sets the PIN code
        sendATcommand("AT+CPIN=****", "OK", 2000);

        delay(3000);

        Serial.println("Setting SMS mode...");
        sendATcommand("AT+CMGF=1", "OK", 1000);    // sets the SMS mode to text
        sendATcommand("AT+CPMS=\"SM\",\"SM\",\"SM\"", "OK", 1000);    // selects the memory

        answer = sendATcommand("AT+CMGR=1", "+CMGR:", 2000);    // reads the first SMS
        if (answer == 1)
        {
            answer = 0;
            while(Serial.available() == 0);
            // this loop reads the data of the SMS
            do{
                // if there are data in the UART input buffer, reads it and checks for the asnwer
                if(Serial.available() > 0){    
                    SMS[x] = Serial.read();
                    x++;
                    // check if the desired answer (OK) is in the response of the module
                    if (strstr(SMS, "OK") != NULL)    
                    {
                        answer = 1;
                    }
                }
            }while(answer == 0);    // Waits for the asnwer with time out

            SMS[x] = '\0';

            Serial.print(SMS);    

        }
        else
        {
            Serial.print("error ");
            Serial.println(answer, DEC);
        }


    }


    void loop(){

    }

    void power_on(){

        uint8_t answer=0;

        // checks if the module is started
        answer = sendATcommand("AT", "OK", 2000);
        if (answer == 0)
        {
            // power on pulse
            digitalWrite(onModulePin,HIGH);
            delay(3000);
            digitalWrite(onModulePin,LOW);

            // waits for an answer from the module
            while(answer == 0){     // Send AT every two seconds and wait for the answer
                answer = sendATcommand("AT", "OK", 2000);    
            }
        }

    }

    int8_t sendATcommand(char* ATcommand, char* expected_answer, unsigned int timeout){

        uint8_t x=0,  answer=0;
        char response[100];
        unsigned long previous;

        memset(response, '\0', 100);    // Initialice the string

        delay(100);

        while( Serial.available() > 0) Serial.read();    // Clean the input buffer

        Serial.println(ATcommand);    // Send the AT command 


            x = 0;
        previous = millis();

        // this loop waits for the answer
        do{
            // if there are data in the UART input buffer, reads it and checks for the asnwer
            if(Serial.available() != 0){    
                response[x] = Serial.read();
                x++;
                // check if the desired answer is in the response of the module
                if (strstr(response, expected_answer) != NULL)    
                {
                    answer = 1;
                }
            }
            // Waits for the asnwer with time out
        }while((answer == 0) && ((millis() - previous) < timeout));    

        return answer;
    }