Shield EFCom V1.2 SIM900

Existem diversos módulos prontos com GSM, alguns mais simples e mais baratos, outros mais completos e mais caros. Dessa vez escrevo sobre o shield EFCom V1.2 com SIM900 (da imagem de destaque).

Características

Esse módulo é baseado no SIM900  GPRS, que entrega 4 frequências GSM/GPRS de 850, 900, 1800 e 1900MHz. Oferece suporte a voz, SMS, dados e fax.

O shield é configurado e controlado via UART usando comandos AT. Possui 2 blocos de jmpers para conectá-lo a qualquer um dos pinos entre D0 e D3 (para utilizar hardware ou software serial), sendo bastante interessante para uso junto ao Arduino Leonardo, se desejar usar hardware serial.

Outra característica interessante desse shield é seu super-capacitor, que fornece alimentação ao RTC, garantindo mais de um dia sem energia sem perder a configuração quando desligado da alimentação.

Além de poder usar o botão S_PWR para alimentá-lo manualmente, há também a possibilidade de fazê-lo através do pino digital 6, assim como reset digital através do pino 5.

Ele é compatível com Arduino UNO, Leonardo e Mega. Todos os pinos do SIM 900 estão dispostos no shield, para quem quiser se aventurar.

Pra finalizar com a cereja de bolo, ele conta com um slot para o display Nokia 5100.

Alimentação

É importantíssimo citar que esses módulos tem pico de 2A e trabalham com tensão variável entre 3.1 e 4.8V. Isso Não será uma preocupação porque o cricuito já faz o ajuste de tensão (para baixo, obviamente), mas garanta a corrente ou o módulo não funcionará.

A principal recomendação para esse módulo é utilizar uma fonte de 9V com corrente suficiente para suprir os picos.  Não ouse utilizá-lo alimentando pela USB, porque de lá só sai 500mA e não há dúvidas de que além de não funcionar, ainda pode queimar sua porta USB.

Recomendações extras

O SIM deve estar desbloqueado, é impreterível.

O dispositivo é sensível a umidade, não devendo ficar exposto, mas sua antena permitir-lhe-á a utilização de um case, bastando expor a antena.

O padrão da serial desse shield é 19200bps, 8-N-1, mas pode ser mudando através de comandos AT. O manual de comandos AT que encontrei já referenciam outra placa, a do próprio site o link já foi pro beleléu.

Definição dos pinos

A placa é forrada de recursos, sem a devida orientação fica até difícil lidar com ela. Os recursos dispostos são mostrados no seguinte desenho:

Onde comprar?

Esse shield é do nosso parceiro Baú da Eletrônica. Não é um shield baratinho, é para quem investe no hobby ou para projetos que o necessitem. Dito isso, espero não ouvir murmúrios em comentários nos grupos de tecnologia do Facebook, ok?

O link para comprar o shield EFCom V1.2 SIM900 é esse.

Luz de status

É importante notar o funcionamento dos LEDs. Normalmente a rede não estabiliza quando a tensão e/ou corrente não estão atendendo aos requisitos.

Chamadas de voz e GPRS

Para fazer uso dos recursos de voz e áudio nesse shield, será necessário também um microfone e fones de ouvido (ou caixinhas de som).

Se desejar usar dados, obviamente necessitará contrar um plano para tal, mas para SMS e ligação, o plano de dados é dispensável.

Criando uma configuração de teste para o Shield EFCom V1.2 SIM900

Como já citado, podemos utilizar a UART dos pinos 0 e 1 ou software serial nos pinos 2 e 3, configuráveis via jumper, na borda ao lado da antena.

Usando UART nativa ou biblioteca SoftwareSerial

Os conjuntos de pinos mais na borda da placa são os pinos D0 e D1, como pode ser lido na própria impressão da placa.  Mais para o lado de dentro estão dispostos os pinos D2 e D3, que também podem ser configurados como TX e RX a gosto, diferente dos pinos para UART nativa. No caso do Arduino UNO, me parece uma solução bastante confortável a utilização da biblioteca SoftwareSerial. Já para o Leonardo, os pinos D0 e D1 são livres para uso, uma vez que a USB-serial utiliza outro recurso da placa que não esses pinos. Mas nada impede de optar pela serial por software e garantir a portabilidade do código para ambas as placas.

Apenas instale a biblioteca SoftwareSerial e crie a porta serial nos pinos 2 e 3, caso tenha tenha escolhido essa opção invés da UART nativa:

#include <SoftwareSerial.h>
SoftwareSerial mySerial(2, 3);
 
void setup()
{
  mySerial.begin(19200); // lembre-se: velocidade padrão do AFCom
  ...
}
...

Buffer de recepção

Se os dados entrantes resultarem em mais de 64 bytes, modifique o buffer padrão da biblioteca SoftwareSerial:

#define _SS_MAX_RX_BUFF 64 //está no header da lib.

De outro modo resultará em um buffer overflow.

Ler SMS

Para ler um SMS, basta passar o comando AT seguido do index da mensagem. Por exemplo:

AT+CMGR=01

Se a mensagem estiver truncada, aumente o valor do buffer, tentando ao máximo evitar desperdício de memória.

O sketch mínimo para esse teste:

#include <SoftwareSerial.h>
SoftwareSerial mySerial(2, 3);
 
void setup()
{
  mySerial.begin(19200);
  mySerial.println("AT+CMGR=01"); 
}

void loop(){

}

Suba o sketch para o Arduino, usando sua IDE preferida. Particularmente, hoje eu prefiro utilizar o VisualStudio no Linux. É sem dúvida a melhor IDE para programar em C++, além de que podemos programar para o Arduino instalando o plugin PlatformIO. Baixe essa fantástica IDE nesse Link, basta escolher sua plataforma (Linux, Mac ou Windows).

O código disposto na imagem acima pertence ao artigo anterior, do relé de estado sólido do nosso parceiro Fulltronic. Usei apenas para figurar minha sugestão de IDE.

Após subir o sketch, abra o monitor serial (seja lá qual for a IDE, ou um terminal como screen, GTKTerm, Cutecom ou o cu (com todo o respeito).

Pressione e segure o botão de alimentação por 3 ou 4 segundos no shield EFCom v1.2 para ligá-lo. Deve levar algo em torno de 30 segundos até que ele se conecte à rede. Veja a tabela de código de status mais acima; o LED deverá piscar em intervalos longos, em torno de 3 segundos.

Para começar a ver mensagens no monitor serial, desative o auto-bauding usando o comando:

AT+IPR=19200

O valor padrão é 0.

O comando enviado para a serial deve mandatoriamente conter CR ao final da mensagem (isso significa "\r" automático, não "CR" literal).

Enviar SMS

Para enviar um SMS é tão simples quanto. Pode-se enviar no formato texto ou binário, depende da necessidade. Para uma simples mensagem de texto, utilize o modo:

AT+CMGF=1

O shield responde com um OK. Então devemos passar o nímero de telefone para envio:

AT+CMGS=+5511987654321

Onde temos +55 para Brasil, 11 para código de área de São Paulo e o número fictício de telefone 9 8765-4321. O shield envia um sinal >, a partir de onde podemos entrar com a mensagem a enviar. Após digitar a mensagem, use o método bizarro de finalização Ctrl+Z ou envie um hexa 0x1A (que me parece o mais sensato, tanto para interação humana quanto para a automação do envio de SMS - e provavelmente a combinação Ctrl+Z não funcionará em qualquer programa ou plataforma).

Adicionando o display Nokia5100

Se quiser adicionar o display ao projeto, é bastante simples. Utilize Uma biblioteca para o display e escreva os dados para ele. Pode ser ótimo para debug, uma vez que o Arduino não esteja mais conectado à porta USB e seja necessário reparar o modo de operação.

Um código de exemplo:

#include <LCD5110_Graph.h>
#include <SoftwareSerial.h>

LCD5110 myGLCD(9,10,11,12,13);

extern uint8_t SmallFont[];

#define RX_PIN 2
#define TX_PIN 3

SoftwareSerial mySerial(RX_PIN, TX_PIN);
 
void setup()
{
  myGLCD.InitLCD();
  myGLCD.setFont(SmallFont);
  
  mySerial.begin(19200);                 //Baud default do shield  
  Serial.begin(19200);                  // Baud da usb-serial   
  Serial.println("Manual do Maker");
  
  myGLCD.clrScr();
  myGLCD.print("EFCom Shield", CENTER, 0);
  myGLCD.print("Teste 01", LEFT, 12);
  myGLCD.print("--cut here-->8", LEFT, 30);
  myGLCD.update();
}
 
void loop()
{
    int i             = 0;
    char someChar[32] = {0};
    
    if(Serial.available()){
        do{
          someChar[i++] = Serial.read();
        }
        while (Serial.available());
        mySerial.print(someChar);
    }  
    else if(mySerial.available()){
       do{
          someChar[i++] = mySerial.read();
        }
        while (Serial.available());
        Serial.print(someChar);
    }
}

Notas adicionais

É bom considerar a possibilidade de subir sketches sem que o shield esteja acoplado ao Arduino, entre outros problemas, evitará erro na comunicação durante o upload.

Sempre que for remover ou colocar o shield sobre o Arduino, garanta que não estejam energizados.

Faça uma dupla-checagem para garantir que a configuração determinada no sketch seja realmente condizente com o pinout selecionado nos jumpers.

Lembre-se que a conexão UART não é correspondente, isto é, não conecte TX a TX e RX a RX. A denominação TX significa que o pino fará Transmissão (Transmit), enquanto o pino RX faz a Recepção (Receive). Logo, em uma comunicação UART deve-se ligar o pino TX ao RX e vice-versa.

Não ligue o módulo sem antena.

Não se esqueça de colocar alimentação o suficiente para suprir os picos do SIM900. Se não leu direito o artigo, volte lá em cima e leia novamente a parte de alimentação.

Ao realimentá-los, será necessário ligar o shield EFCom V1.2 SIM900 novamente, como supracitado. Após ligá-lo acesse o botão de reset do Arduino para que rode o sketch do início novamente, ou determine um delay antes que o sketch suba, ou adicione uma condição para a qual deva-se esperar ser atendida antes de entrar no loop.

Lembre-se que ambas as seriais estão sendo configuradas em 19200 e provavelmente seu monitor serial estará em 9600 ou 115200. Nesse caso, aparecerão apenas caracteres estranhos no monitor serial, lembre-se de ajustar a velocidade dele também.

Exemplo de envio de SMS automático

Esse código serve como base para implementações. Farei algumas bastante significativas, mas em outro artigo. Esse é o de apresentação do produto.

void setup()
{
  Serial.begin(19200);  
  Serial.print("\r");
  delay(1000);                    //Aguarda pelo "OK"
  Serial.print("AT+CMGF=1\r");    //Coloca em modo texto
  delay(1000);
  
  Serial.print("AT+CMGS=\"+5511987654321\"\r");    //Numero para envio
  delay(1000);
  Serial.print("Shield EFCom V1.2 SIM900\r");   //texto
  delay(1000);
  Serial.print(26,BYTE);  //Equivalente a Ctrl+Z
}

void loop()
{
    /* Só coloque envio controlado aqui. Nada automático*/
}

Não coloque nada no loop sem antes depurar bastante pela serial, a não ser que você seja sócio de uma empresa de telefonia. Esse sketch envia uma vez e pronto, não faz mais nada.

Efetuar chamadas e controlar GPIO

Ainda fazendo-o através da interface de comandos AT, um exemplo prático seria:

#include <SoftwareSerial.h>

int count = 0;

SoftwareSerial mySerial(2,3);

String msg;

void setup(){
    mySerial.begin(19200);
    Serial.begin(19220);
    delay(2000);
}

void loop(){
    count = 0;
    mySerial.println("ATD987654321;"); //repare o ; no comando ATD
    delay(2000);
    //se usar softserial, não use isso
    Serial.println("AT+SPWM=2,63,100");
    delay(100);
    Serial.println("AT+SPWM=1,63,100);
    delay(100);
    for (uint8_t i=0; i<13;i++){
        msg = "AT+SGPIO=0," + String(i) + ",1,1";
        Serial.println(msg);
        delay(100);
    }
    delay(500);
    Serial.println("AT+SPWM=1,63,0");
    delay(100);
    Serial.println("AT+SPWM=2,63,0");
    delay(100);
    for (uint8_t j=0; j<13;j++){
        msg = "AT+SGPIO=0,"+ String(j) + ",1,0";
        Serial.println(msg);
        delay(100);
    }
    count++;
    if (count == 5){
        Serial.println("ATH");
    }
}

Biblioteca GSM

Como já citado, existem diversas bibliotecas GSM no repositório do Arduino, baixe-as e teste-as após fazer a prova de conceito com os comandos AT.

Pretendo escrever em breve um artigo usando o PBX Asterisk no Raspberry para interagir com esse shield EFCom V1.2 SIM900, vamos ver se consigo utilizar SIP para ligar do celular para o PBX e transferir uma ligação. Se der certo, será um artigo bacana. Mas antes disso, preciso fazer o vídeo dessa prova de conceito, então, se ainda não é inscrito em nosso canal Dobitaobytebrasil no Youtube, aproveite para se inscrever, ative o sininho para receber notificações e até a próxima!

Inscreva-se no nosso canal Manual do Maker no YouTube.

Também estamos no Instagram.