Guia para uso do Shield GPRS GSM SIM900 com o Arduino

ia sobre o SIM900 GSM GPRS Shield com o Arduino. Aprenda como enviar e receber SMS e como fazer e receber chamadas telefônicas com o Arduino.

 

Apresentando o Shield SIM900 GSM GPRS

O Shield SIM900 GSM GPRS é mostrado na figura abaixo.

GSM significa Sistema Global de Comunicações Móveis e é o padrão global para comunicações móveis.

GPRS significa Serviço Geral de Rádio por Pacotes. GPRS é um serviço móvel na comunicação celular 2G e 3G.

 

Aplicações:

O Shield GSM GPRS é particularmente útil, pois permite:

• Conecte-se à Internet através da rede GPRS
• Envie e receba SMS
• Efetuar e receber chamadas telefônicas

Os recursos ts o tornam perfeito para projetos com Arduino como:

• Controle remoto de aparelhos eletrônicos – envio de um SMS para ativar algo;
• Receba notificações – envie SMS para o seu telefone celular se algum movimento for detectado em sua casa;
• Receba dados do sensor – envie SMS periódicos para o seu telefone celular com dados meteorológicos diários.

 

Recursos

Aqui estão algumas das características mais importantes do escudo:

• Compatível com Arduino e clones
• Baseado no módulo SIM900 da SIMCOM
• Permite enviar SMS, MMS, GPRS e áudio via UART usando os comandos AT.
• Possui 12 GPIOs, 2 PWMs e ADC integrado do módulo SIM900
• Quad Band: 850; 900; 1800 e 1900 MHZ, por isso deve funcionar em todos os países com redes GSM (2G)
• Controle via comandos AT
• Suporta RTC (relógio em tempo real) – possui suporte para bateria de 3V CR1220 na parte traseira

Possui conectores de microfone e fone de ouvido para chamadas telefônicas

 

Etapas preliminares

Antes de iniciar o módulo SIM900 GSM GPRS, é necessário considerar alguns aspectos sobre o cartão SIM e a fonte de alimentação do shield.

Cobertura GSM

Verifique se você possui cobertura em uma rede GSM 850 MHz, GSM 900 MHz, DCS 1800 MHz ou PCS 1900 MHz. Por GSM, queremos dizer 2G.

Cartão SIM pré-pago

Recomendamos que você use um plano pré-pago ou um plano com SMS ilimitado para fins de teste. Caso contrário, se algo der errado, talvez você precise pagar uma quantia enorme por centenas de mensagens de texto SMS enviadas por engano. Neste tutorial, estamos usando um plano pré-pago com SMS ilimitado.

O shield usa o tamanho original do cartão SIM, não micro ou nano. Se você possui micro ou nano, considere usar um adaptador de tamanho de cartão SIM.

Desative o bloqueio do PIN

Para usar o cartão SIM com o Shield, é necessário desativar o bloqueio de pinos. A maneira mais fácil de fazer isso é inserir o cartão SIM no seu smartphone e desativar o bloqueio de pinos nas configurações de segurança do telefone.

 

No meu caso, eu precisava passar por: Configurações > Configurações Avançadas > Segurança > Bloqueio do SIM e desligar o cartão SIM de bloqueio com alfinete.

 

Obtendo a fonte de alimentação correta

O Shield possui um soquete de corrente contínua, conforme mostrado na figura abaixo.

 

 

Ao lado da tomada de energia, há uma chave seletora para selecionar a fonte de energia. Ao lado da chave seletora na placa, há uma seta indicando a posição de alternância para usar uma fonte de alimentação externa – mova a chave seletora para usar a fonte de alimentação externa, como mostrado acima.

Para ligar o Shield, é aconselhável usar uma fonte de alimentação de 5V que possa fornecer 2A como a mostrada abaixo. Também pode ser alimentado com 9V 1A ou 12V 1A.

 

Hardware do Shield SIM900 GSM GPRS

A figura abaixo mostra a parte de trás do escudo. Possui um suporte para o cartão SIM e uma bateria de 3V CR1220 para o RTC (relógio em tempo real).

 

A figura abaixo mostra os componentes mais importantes da placa que você precisa prestar atenção.

 

Começando

1) Insira o cartão SIM no suporte do cartão SIM – leia as etapas preliminares na seção anterior.

 

2) Verifique se a antena está bem conectada.

3) Na porta serial, verifique se a tampa do jumper está conectada, como mostra a figura abaixo, para usar o serial do software.

 

4) Ligue o Shield usando uma fonte de alimentação externa de 5V. Certifique-se de selecionar a fonte de alimentação externa com a chave seletora ao lado da tomada DC.

 

5) Para ligar/desligar o Shield, pressione a tecla liga/desliga por cerca de 2 segundos.

6) Em seguida, o LED Status acenderá e o LED NetLight piscará a cada 800 ms até encontrar a rede. Quando encontrar a rede, o LED NetLight começará a piscar a cada três segundos.

Nota: você pode ativar automaticamente o escudo via software. Veja como fazer isso na seção Ativar automaticamente o Shield, após os exemplos de código.

 

7) Você pode testar se o escudo está funcionando corretamente enviando comandos AT do Arduino IDE usando um programador FTDI – como mostraremos mais adiante neste guia.

 

Comandos do SIM900 AT

• Defina o SIM900 para o modo de texto: AT+CMGF=1\r
• Envie SMS para um número: AT+CMGS=PHONE_NUMBER (em formato internacional)
• Leia o primeiro SMS da caixa de entrada: AT+CMGR=1\r
• Leia o segundo SMS da caixa de entrada: AT+CMGR=2\r
• Leia todas as SMS da caixa de entrada: AT+CMGR=ALL
• Ligar para um número: ATDP+PHONE_NUMBER (em formato internacional)
• Desligar uma ligação: ATH
• Receber uma chamada: ATA

Para mais informações, você pode verificar o manual de comandos do SIM900 AT aqui.

 

Testando o Shield com programador FTDI.

Para testar se tudo está funcionando corretamente, você pode testar o escudo enviando comandos AT a partir do monitor serial do Arduino IDE. Para isso, você precisa de um programador FTDI como o mostrado na figura abaixo.

 

1) Conecte o programador FTDI ao Shield GSM, como mostra a figura abaixo.

 

2) Abra o Arduino IDE e selecione a porta COM correta.

3) Abra o monitor serial

4) Selecione a taxa de transmissão de 19200 – a configuração padrão do Shield é 19200 – e retorno de carro. Escreva AT na caixa destacada em vermelho e pressione enter. Veja a figura abaixo.

5) O Shield responderá com OK, se tudo estiver funcionando corretamente.

 

Conectando o Shield ao Arduino

Conecte ao Shield ao Arduino, conforme mostrado nos esquemas abaixo.

 

Enviando um SMS

Para enviar um SMS, carregue o código abaixo na sua placa Arduino.

/*********
  Detalhes completos do projeto
*********/

#include <SoftwareSerial.h>

// Configurar porta serial de software
SoftwareSerial SIM900(7, 8); 

void setup() {
  // O Arduino se comunica com o escudo SIM900 GSM a uma taxa de transmissão de 19200
  // Certifique-se de que corresponde à taxa de transmissão do seu módulo
  SIM900.begin(19200);
  // Dê tempo ao seu escudo GSM, faça logon na rede
  delay(20000);   
  
  // Envie o SMS
  sendSMS();
}

void loop() { 
  
}

void sendSMS() {
  // Comando AT para definir o SIM900 no modo SMS
  SIM900.print("AT+CMGF=1\r"); 
  delay(100);

  // SUBSTITUIR OS X COM O NÚMERO MÓVEL DO RECEPTOR
  // USE CÓDIGO DE FORMATO INTERNACIONAL PARA NÚMEROS MÓVEIS
  SIM900.println("AT + CMGS = \"+XXXXXXXXXXXX\""); 
  delay(100);
  
  // SUBSTITUA COM SEU PRÓPRIO CONTEÚDO DE MENSAGEM SMS
  SIM900.println("Exemplo de mensagem do Arduino Uno."); 
  delay(100);

  // Finalize o comando AT com um ^Z, código ASCII 26
  SIM900.println((char)26); 
  delay(100);
  SIM900.println();
  // Dê tempo ao módulo para enviar SMS
  delay(5000); 
}

 

Nesse código, você começa incluindo a biblioteca SoftwareSerial.h e cria uma porta serial de software nos pinos 7 e 8. (o pino 7 está sendo definido como RX e 8 como TX)

#include <SoftwareSerial.h>
SoftwareSerial SIM900(7, 8);

 

A função sendSMS() criada é o que realmente envia o SMS. Esta função usa os comandos AT: AT+CMGF=1\r e AT+CMGS.

Você precisa alterar o número de celular do destinatário em: (substitua os Xs pelo número de telefone do destinatário)

SIM900.println("AT + CMGS = \"xxxxxxxxxxxxxxx"");

 

O número de celular do destinatário deve estar em formato internacional.

Em seguida, na linha seguinte, você pode editar o texto que deseja enviar.

  // SUBSTITUA COM SEU PRÓPRIO CONTEÚDO DE MENSAGEM SMS
  SIM900.println("Exemplo de mensagem do Arduino Uno."); 

 

Lendo SMS recebidos

Para ler o SMS recebido, carregue o código abaixo no seu Arduino. Após o upload, aguarde 20 segundos para o escudo estabelecer comunicação. Em seguida, teste o script enviando um SMS para o número do cartão SIM do escudo. O SMS é mostrado no monitor serial do Arduino – taxa de transmissão: 19200.

/*********
  Detalhes completos do projeto
*********/

#include <SoftwareSerial.h>

// Configurar porta serial de software
SoftwareSerial SIM900(7, 8); 

// Variável para salvar os caracteres SMS recebidos
char incoming_char=0;

void setup() {
  // O Arduino se comunica com o escudo SIM900 GSM a uma taxa de transmissão de 19200
  // Certifique-se de que corresponde à taxa de transmissão do seu módulo
  SIM900.begin(19200);
  // Para monitor serial
  Serial.begin(19200); 
  // Dê tempo ao seu Shield GSM, faça logon na rede
  delay(20000);

  // Comando AT para definir o SIM900 no modo SMS
  SIM900.print("AT+CMGF=1\r"); 
  delay(100);
  // Configura o módulo para enviar dados SMS para serial após o recebimento
  SIM900.print("AT+CNMI=2,2,0,0,0\r");
  delay(100);
}

void loop() {
  // Exibe qualquer texto que a blindagem GSM envie no monitor serial
  if(SIM900.available() >0) {
    // Obtém o caractere da porta serial celular
    incoming_char=SIM900.read(); 
    // Imprime o caractere recebido no terminal
    Serial.print(incoming_char); 
  }
}

 

Neste código, você define o módulo para enviar os dados do SMS para a saída serial:

SIM900.print("AT+CNMI=2,2,0,0,0\r");

 

Você armazena os caracteres recebidos da mensagem SMS na variável incoming_char.
Você lê os caracteres usando a função SIM900.read().

 

Fazendo uma ligação

Para fazer uma ligação, carregue o seguinte código no seu Arduino.

 

Não se esqueça de editar o código com o número de telefone para o qual você deseja ligar.

/*********
  Detalhes completos do projeto
*********/

#include <SoftwareSerial.h>

// Configurar porta serial de software
SoftwareSerial SIM900(7, 8); 

void setup() {
  // O Arduino se comunica com o escudo SIM900 GSM a uma taxa de transmissão de 19200
  // Certifique-se de que corresponde à taxa de transmissão do seu módulo
  SIM900.begin(19200);
  // Dê tempo ao seu escudo GSM, faça logon na rede
  delay(20000);

  // Faça a ligação
  callSomeone();
}

void loop() {
  
}

void callSomeone() {
  // SUBSTITUA OS X COM O NÚMERO QUE VOCÊ DESMONTA 
  // USAR CÓDIGO DE FORMATO INTERNACIONAL PARA NÚMEROS MÓVEIS
  SIM900.println("ATD + +XXXXXXXXX;");
  delay(100);
  SIM900.println();
  
  // Neste exemplo, a chamada dura apenas 30 segundos
  // Você pode editar a duração da chamada telefônica no tempo de atraso
  delay(30000);
  // Comando AT para desligar
  SIM900.println("ATH"); // desligar
}

Para fazer a chamada, use a função callSomeone() que usa o comando ATD.

SIM900.println("ATD + +XXXXXXXXX;");

Você precisa substituir os X‘s (destacados em vermelho) pelo número de telefone que deseja chamar.

Não se esqueça de conectar um microfone e fones de ouvido para fazer a ligação.

Neste exemplo de código, a chamada é desligada após 30 segundos, usando o comando ATH:

SIM900.println("ATH"); 

Desligar após 30 segundos não é muito útil, mas funciona bem como um exemplo. A idéia é que você use o comando ATH quando um evento for disparado. Por exemplo, conecte um botão ao Arduino que, quando pressionado, envia o comando ATH para desligar o telefone.

 

Atender chamadas telefônicas

O código a seguir atende as chamadas recebidas.

/*********
  Detalhes completos do projeto
*********/

#include <SoftwareSerial.h>

// Configurar porta serial de software
SoftwareSerial SIM900(7, 8); 
char incoming_char=0;

void setup() {
  // O Arduino se comunica com o escudo SIM900 GSM a uma taxa de transmissão de 19200
  // Certifique-se de que corresponde à taxa de transmissão do seu módulo
  SIM900.begin(19200); // for GSM shield
  // Para monitor serial
  Serial.begin(19200); 
  // Dê tempo para fazer logon na rede.
  delay(20000); 
  
  SIM900.print("AT+CLIP=1\r"); // ativar a notificação de identificação de chamadas
  delay(100);
}

void loop() {
  // Exibe qualquer texto que o Shield GSM envie no monitor serial
  if(SIM900.available() >0) {
    // Obtém o caractere do celular serial por 
	// Com uma chamada recebida, uma mensagem "RING" é enviada
    incoming_char=SIM900.read();
    // Verifique se o Shield está enviando uma mensagem "RING"
    if (incoming_char=='R') {
      delay(10);
      Serial.print(incoming_char);
      incoming_char=SIM900.read();
      if (incoming_char =='I') {
        delay(10);
        Serial.print(incoming_char);
        incoming_char=SIM900.read();
        if (incoming_char=='N') {
          delay(10);
          Serial.print(incoming_char);
          incoming_char=SIM900.read();
          if (incoming_char=='G') {
            delay(10);
            Serial.print(incoming_char);
            // Se a mensagem recebida do Shield for RING
            // Envia comandos ATA para atender o telefone
            SIM900.print("ATA\r");
          }
        }
      }
    }
  }
}

 

Quando alguém liga para o número SIM900, ele envia uma mensagem dizendo “TOQUE”. Para saber se alguém está ligando para você, você pode esperar pelos caracteres recebidos do SIM900 e comparar se foi uma mensagem RING. É o que é feito neste código. Quando recebe uma mensagem RING, você envia o comando ATA para atender o telefone.

 

Ligar automaticamente o Shield

Em vez de pressionar manualmente a tecla “power” para ligar o Shield, você pode ligar automaticamente o Shield via software.

 

1) Primeiro, você precisa soldar as conexões R13 no Shield, como mostra a figura abaixo – destacada em vermelho.

 

2) Conecte o D9 na blindagem ao pino do D9 Arduino, conforme mostrado no esquema abaixo.

 

3) Adicione o seguinte trecho de código na função setup(). Isso equivale a pressionar o botão “power” do Shield.

digitalWrite(9, HIGH);
delay(1000);
digitalWrite(9, LOW);
delay(5000);

 

Solução de problemas

Shield não responde com OK

 

Verifique suas conexões TX e RX com o Arduino. Tente repetir o processo alterando o TX com os pinos RX.

 

Verifique também se você selecionou a série do software, colocando a tampa do jumper no local apropriado no seletor de série.

 

Não consigo ver as mensagens no monitor serial

Para ver as mensagens no monitor serial, a blindagem e a taxa de transmissão da porta serial do Arduino devem ser as mesmas. A taxa de transmissão padrão do escudo SIM900 GSM GPRS é 19200. Portanto, selecione a taxa de transmissão do Arduino para 19200.

 

No entanto, se você precisar alterar a taxa de transmissão do escudo, poderá enviar o seguinte comando AT para alterá-lo para 19200 ou outra taxa de transmissão apropriada.

AT+IPR=19200

 

Empacotando

Este tutorial mostra como enviar e receber SMS e fazer e receber chamadas telefônicas com o Arduino. Você pode aplicar os conceitos aprendidos neste tutorial para criar seus próprios projetos para se comunicar através de uma rede de células.