Você que já conhece o Shield GSM SIM900 e sabe do que ele é capaz, agora tem mais uma opção de placa que, além de mais recursos, tem um layout que pode facilitar a adaptação no seu projeto. É o módulo GSM GPRS SIM800L, que vamos usar nesse post para controlar um Arduino Uno usando mensagens de texto SMS enviadas por um smartphone.

Módulo GSM GPRS SIM800L

O SIM800L é um excelente módulo para projetos de IoT (Internet of Things ou Internet das Coisas), pois além do baixo consumo realiza a comunicação via interface serial, o que facilita a adaptação para as mais variadas placas e microcontroladores que usem esse tipo de comunicação.

O módulo é quad-band (GSM850MHz, EGSM900MHz, DCS1800MHz e PCS1900MHz), suporta GPRS e tem conector para antena externa, permitindo que a placa fique por exemplo dentro de uma caixa lacrada e com apenas a antena exposta, garantindo a perfeita recepção do sinal.

Conexões do módulo SIM800L

O módulo que vamos utilizar tem sete pinos, sendo dois para a alimentação (5V e GND), quatro para a serial/UART e um pino de reset. Na parte superior, podemos ver o conector para antena e o CI SIM800L (datasheet), além dos leds indicadores de energia e conexão com a rede GSM (NET):

SIM800L Detalhes pinos

Na parte inferior, temos o slot para cartão SIM, que faz a conexão com a rede de telefonia celular e que vamos usar neste post como receptor de mensagens SMS.

Com relação ao led NET, ao energizar o módulo ele pisca em intervalos de 1 segundo. Depois que a rede de telefonia é encontrada, o led pisca à cada 3 segundos.

Módulo com antena

Na imagem acima podemos ver o módulo com o pigtail SMA e a antena instalados.

Conexão do SIM800L com Arduino Uno

Como mencionamos anteriormente a alimentação do módulo é de 5V, e para comunicação com o microcontrolador vamos usar os pinos 10 e 11, emulando uma serial com a ajuda da biblioteca SoftwareSerial. 

Circuito Arduino Uno e Módulo GSM SIM800L

No circuito acima temos 2 leds ligados às portas digitais 4 e 5. Esses leds serão acesos conforme a mensagem SMS recebida.

Recomendo utilizar alimentação externa para o módulo SIM800L (usei uma fonte de 5V/2A), pois alimentando apenas com o Arduino o módulo reiniciava sempre que se conectava à rede de telefonia celular.

Programa SMS SIM800L

O programa que vamos utilizar para controle do Arduino usa a biblioteca SIM800L (download), que facilita o uso de comandos para envio de SMS, realizar chamadas, recuperar dados do cartão SIM, etc. Descompacte a pasta e coloque-a dentro da pasta LIBRARIES da IDE do Arduino.

No programa também carregamos a biblioteca SoftwareSerial, necessária para que a biblioteca SIM800L funcione. Nesse caso, usaremos os pinos digitais 10 e 11 para emular uma interface serial e realizar a comunicação com o módulo. Não se esqueça de utilizar no slot da placa um cartão SIM válido e desbloqueado.

No loop temos a parte que fica aguardando a chegada de uma mensagem de texto SMS. Quando essa mensagem é recebida, é analisada pelos comandos IF para determinar qual led do circuito deve ser aceso: as mensagens L1 e D1 acendem e apagam, respectivamente, o led vermelho. As mensagens L2 e D2 fazem a mesma coisa com o led verde, e você pode customizar as mensagens de acordo com as necessidades do seu projeto.

Repare que temos comandos reduzidos para apagar as mensagens da memória (linha 22), recuperar o número de telefone (linha 39) e o texto do SMS (linha 30) já que esse trabalho é todo feito pela biblioteca.

//Programa: Controle de Arduino por SMS com SIM800L
//Autor: Arduino e Cia

#include <Sim800l.h>
#include <SoftwareSerial.h>

Sim800l Sim800l;

String textSms, numberSms;
uint8_t LED1 = 4; //Conexao Led vermelho
uint8_t LED2 = 5; //Conexao Led verde
bool error;

void setup()
{
  Serial.begin(9600);
  pinMode(LED1, OUTPUT);
  pinMode(LED2, OUTPUT);

  Sim800l.begin();
  Serial.print("Limpando SMS antigos...");
  error = Sim800l.delAllSms(); //Apaga SMS
  Serial.println(" Apagados!");
  Serial.println("\nAguardando comandos por SMS...");
}

void loop()
{
  //Le o SMS da posicao 1
  textSms = Sim800l.readSms(1);

  //Verifica se o SMS foi recebido e eh valido
  if (textSms.indexOf("OK") != -1)
  {
    //Verifica se o SMS esta vazio
    if (textSms.length() > 7)
    {
      //Retorna o numero do celular que enviou o SMS
      numberSms = Sim800l.getNumberSms(1);
      //Mostra o numero do telefone no Serial Monitor
      Serial.println(numberSms);
      //Converte o texto para maiusculas
      textSms.toUpperCase();

      //Caso receba L1, acende o led 1 (vermelho)
      if (textSms.indexOf("L1") != -1)
      {
        Serial.println("Led 1 Ligado");
        digitalWrite(LED1, 1);
      }
      //Caso receba D1, apaga o led 1 (vermelho)
      else if (textSms.indexOf("D1") != -1)
      {
        Serial.println("Led 1 Desligado");
        digitalWrite(LED1, 0);

      }
      //Caso receba L2, acende o led 2 (verde)
      else if (textSms.indexOf("L2") != -1)
      {
        Serial.println("Led 2 Ligado");
        digitalWrite(LED2, 1);

      }
      //Caso receba D2, apaga o led 2 (verde)
      else if (textSms.indexOf("D2") != -1)
      {
        Serial.println("Led 2 Desligado");
        digitalWrite(LED2, 0);
      }
      //Apaga todos as mensagens da memoria, garantindo que o proximo
      //SMS esteja sempre na posicao 1
      Sim800l.delAllSms();
    }
  }
}

Você pode acompanhar o recebimento de SMS utilizando o Serial Monitor, que mostra a mensagem que foi recebida, e também o número do celular do qual ela foi enviada:

Serial Monitor SIM800L
 

Comandos AT com o módulo SIM800L

Assim como acontece com outros módulos GSM, você também pode controlar e obter informações do módulo SIM800L utilizando comandos AT. Isso é muito útil, por exemplo, quando você precisa fazer um teste básico para saber se a conexão foi feita corretamente e se há comunicação entre o módulo e a placa controladora.

Para isso, carregue o programa abaixo no Arduino. Você pode usar o mesmo circuito montado anteriormente:

//Programa: Comandos AT com o SIM800L
//Autor: Arduino e Cia

#include <SoftwareSerial.h>

//TX do SIM800L conectado ao pino 10
#define SIM800_TX_PIN 10

//RX do SIM800L conectado ao pino 11
#define SIM800_RX_PIN 11

SoftwareSerial serialSIM800(SIM800_TX_PIN, SIM800_RX_PIN);

void setup()
{
  //Comunicacao serial para uso com o Serial Monitor
  Serial.begin(9600);
  while (!Serial);

  //Comunicacao com o modulo SIM800L
  serialSIM800.begin(4800);
  delay(1000);

  Serial.println("Envie o comando AT para o SIM800L...");
}

void loop()
{
  //Mostra no Serial Monitor os dados enviados pelo modulo
  if (serialSIM800.available())
  {
    Serial.write(serialSIM800.read());
  }

  //Envia os comandos AT para o modulo
  if (Serial.available())
  {
    serialSIM800.write(Serial.read());
  }
}

Abra o Serial Monitor, selecione “Ambos, NL e CR” na parte inferior da janela e digite os comandos AT na parte superior:

Serial Monitor - Comandos AT

Você encontra a lista completa de comandos AT disponíveis para o módulo GSM SIM800L neste link.

Finalmente, no vídeo abaixo podemos ver o circuito de controle do Arduino via SMS em funcionamento:

 

Você também pode usar este programa para controlar relés, sensores e outros equipamentos conectados ao Arduino, ou usar o módulo SIM800L com outras placas como Raspberry Pi, Beaglebone e outras que utilizem a comunicação serial.

Gostou? Confira outros posts usando módulos GSM aqui mesmo no Arduino e Cia!

5/5 - (4 votos)