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.
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):
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.
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.
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:
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:
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!