Como usar o GPIO do SIM900

Já vimos o básico, depois vimos um pouco mais, com exemplo de como enviar, receber e apagar SMS. Apesar de divertido, qual a finalidade disso se não pudermos usar um atuador ou sensor? Por isso nesse artigo veremos como usar o GPIO do SIM900, que está lá, sobre o shield, porém sem pinos. Na imagem de destaque já fiz as soldas e vou discorrer um pouco mais sobre a disposição dos pinos, que não são muito claras.

Como usar o GPIO do SIM900 com comandos AT?

Bem, tudo o que escrevi sobre ele foi utilizando os comandos AT. Às vezes não vale a pena carregar toda uma biblioteca para a memória para fazer funções que podemos fazer com pouco trabalho. É bem o caso da interação com esse shield, que recebe comandos AT via serial. Em contrapartida, ler a documentação pode ser uma boa pedida.

Para usar o GPIO do SIM900, fiquei matutando maneiras elaboradas de fazê-lo, mas no final de tudo não passaria de comunicação serial. Então, para provar o conceito fiz uma bridge, escrevendo o comando na serial e recebendo-o na função loop. Ao identificar a mensagem como comando AT para o GPIO, imediatamente o repasso para o shield. Foi a maneira mais simples para interação direta, mas para SMS é bom fazer de outro jeito, não seria nada agradável ter que decorar o comando AT para compor uma mensagem.

Soldar os pinos no shield

Não tem jeito, será necessário um ferro de solda sim. Soldar ambos os slots lhe dará acesso a todos os GPIOs, mas no mínimo devemos soldar o externo, do lado oposto aos jumpers, como na imagem abaixo (a barra de pinos verde):

Multímetro

Antes de fazer wiring, nada é mais objetivo do que utilizar um instrumento de aferição, certo? Meu novo companheiro de bancada é esse multímetro vendido pela Eletrogate (você encontra nesse link) com deliciosos recursos, como você pode ver nesse artigo e no vídeo relacionado.

Foi a melhor e mais rápida maneira que encontrei para confirmar a ação do comando enviado pela serial.

Levantar e baixar o GPIO do SIM900

São 4 bytes seguidos do comando, que compõe a ação que será tomada. Para enviar um comando para levantar o GPIO1, utiliza-se:

"AT+SGPIO=0,1,1,1"

AT+SGPIO=

Essa é a chave do comando, seguida pelo valor

Operation

O primeiro byte é o modo de operação. O valor 0 configura em modo de função. O valor 1 lê o nível do GPIO, mas śo é válido quando o pino for configurado como INPUT.

GPIO

O segundo byte é o nímero do GPIO a ser configurado, sem segredos.

Function

O terceiro byte é a função. As opções são:

0 - configura como input.

1 - configura como output.

2 - configura como keypad.

Level

0 - GPIO low.

1 - GPIO alto.

PWM do SIM900

Mais abaixo está disposto o pinout do shield. O SIM900 oferece 2 PWM que podem ser utilizados para propósito geral. O formato do comando para o PWM é:

AT+SPWM=1,63,100

Os valores são:

Index

O número do pino PWM.

Period

Período do intervalo. O limite é 0 a 126 no 0. Se configurado para 1 ou 2 a range é de 0 à 65535.

Level

Pode ser de 0 à 100, que pode ser convertido para duty ratio.

O código para aceitar manipulação do GPIO pela serial foi adicionado ao código de exemplo do artigo anterior. O código completo está disposto abaixo (lembre-se de colocar um número válido para envio e para validar o retorno):

#include <Arduino.h>

#define CEL_NUMBER "987654321"
#define KEYWORD "status"

char rcv[100] = {0};
uint8_t index = 0;
char incoming = 0;

//Protótipos de funções
void sendSMS(char *msg);
void receiveSMS();
bool parseCelNumber(char *tok, bool is_done);
void parseMessage(char *tok);
void deleteSMS();
void setGPIO(String str);

void setGPIO(String str){
    /* operation, gpio, function, level
    [operation]
    0 - Configura o GPIO function.
    1 - Lê o nível do GPIO. Só é válido quando configurado como input.

    [gpio]
    O GPIO a ser configurado.

    [function]
    Somente quando operation for 0.
    0 - configura como input
    1 - configura como output
    2 - configura como keypad

    [level]
    0 - gpio low
    1 - gpio high
    */
    Serial1.println(str);
    Serial.print("str: ");
    Serial.println(str);

}

//O espaço é limitado. A exclusão pode ser feita com periodicidade ou a cada boot da MCU.
void deleteSMS(){
    Serial1.print("AT+CMGDA=\"");
    Serial1.println("DEL ALL\"");
    delay(2000);
    Serial.println("Mensagens deletadas");
}
//Só dá atenção à mensagem se for originada pelo celular da macro CEL_NUMBER.
bool parseCelNumber(char *tok, bool is_done){
    if (is_done){
        return true;
    }

    char *pch = 0;
    pch = strstr(tok,CEL_NUMBER);
    if (pch != NULL){
        Serial.println("Numero de comando OK. Lendo...");
        return true;
    }
    return false;
}

//Le a mensagem. se tiver "Djames", imprime um texto na serial. Se for status, envia o status por SMS.
void parseMessage(char *tok){
    String msg = tok;
    if (msg.indexOf("Djames") > -1){
        Serial.println("Manual do Maker");
    }
    else if (msg.indexOf(KEYWORD) >-1){
        sendSMS("Tudo tranquilo.");
    }
}

//Rotina para enviar SMS. Não deve ser utilizada no loop.
void sendSMS(char *msg){
  Serial.println("Um momento...");
  Serial1.print("\r");
  Serial1.flush();
  delay(1000);
  Serial1.print("AT+CMGF=1\r");
  Serial1.flush();
  delay(1000);
  Serial.println("Enviando para Djames...");
  Serial1.print("AT+CMGS=\"+5511987654321\"\r"); 
  Serial1.flush();
  delay(1000);
  Serial1.print(msg);   //texto
  delay(1000);
  Serial1.write(26);  //Equivalente a Ctrl+Z
}

//Rotina para receber SMS. Pode ser chamada no loop.
void receiveSMS(){
  /* A resposta inicia com +CMT:. todos os campos na resposta são separados por virgula, 
  sendo o primeiro campo o numero do telefone, segundo campo o nome do sender, o terceiro
  campo o timestamp e o quarto campo, a mensagem atual.
  Diferente do envio, o loop pode ser alimentado, fazendo a leitura constante do shield.
  Ex. do formato da mensagem:
  +CMT: "+5511987654321","Quem enviou","01/01/75,01:02:03+14","Ralou, moto."
  */
  Serial1.print("AT+CMGF=1\r");
  Serial1.flush();
  delay(500);
  Serial1.println("AT+CNMI=1,2,0,0,0"); //le a mensagem mais recente
  delay(500);
  memset(rcv,0,100);
  while (Serial1.available()){
    incoming   = Serial1.read();
    rcv[index] = incoming;
    index++;
  }
  index = 0;

  char *rest = rcv;
  char *token;
  bool accept = false;
  if (strstr(rcv,"+CMT")){
      while ((token = strtok_r(rest,",",&rest)) != NULL){
        //Serial.println(token);
        accept = parseCelNumber(token, accept);
        if (accept){
            parseMessage(token);
        }
      }
  }
  delay(1000);
}

void setup()
{
  Serial1.begin(19200);  
  Serial.begin(9600);
  Serial.println("Started!");
  deleteSMS();
}

void loop()
{
    String v;
    char z;
    while (Serial.available()){
        z = Serial.read();
        v = v + String(z);
    }
    if (v.length() > 0){
        if (v.indexOf("SGPIO") > -1 || v.indexOf("SPWM") > -1){
             char *comm;
             v.toCharArray(comm,v.length());
             setGPIO(v);
        }
        
    }
    
    receiveSMS();
}

Pinos de debug

No canto oposto aos pinos de GPIO, temos os pinos de debug, TX, RX, PWR, GND. Vamos experimentá-lo com o use de outra ferramenta; o Bus Pirate, da Dangerous Prototype. Essa ferramenta já está em uma versão bem mais atual que a minha e pode ser adquirida na SeeedStudio (com 3 'e's mesmo). É um pouquinho caro, considerando a necessidade de comprar os probes e também é uma boa ideia ter o case. Logo, vão-se nessa compra 45 dólares, mais despesas de envio, mais os impostos que o "papai estado" cobra sem fazer nada por você. Se estiver motivado, eis o link de compra.

Não precisaremos conectar o TX, porque apenas quereremos escutar a comunicação. Desse modo, devemos apenas colocar os probes RX no TX do shield e o GND ao GND do shield, ambos nos pinos de debug. Lembrando que a velocidade padrão da UART do SIM900 é de 19200, faremos algo como demonstrado nesse vídeo, com Raspberry.

Mostrarei no vídeo a escuta no shield.

Vídeo

No video disponível em breve no canal DobitaobyteBrasil no Youtube mostro a operação, o envio de SMS e a recepção de SMS. Ainda estou para testar o debug e, correndo tudo bem, entra na edição do vídeo, se inscreva no canal e ative o sininho para receber notificações!

Pinout do shield EFCom e GPIO do SIM900

No documento indicado mais acima você encontra a pinagem, mas apenas para simplificar, caso não queira acessar o documento, eis a pinagem:

Enfim, com isso já temos material o suficiente para fazermos nossos projetos utilizando telefonia, certo? Por enquanto está encerrada a série com esse shield, tendo mostrado o envio de SMS, recepção de SMS, GPIO SIM900, PWM SIM900, exclusão de SMS.

Onde comprar?

Ainda não adquiriu? Tcs, que pena, vai ficar só olhando então. Ou então, abra uma aba no Baú da Eletrônica e adquira o seu e comece seus projetos de longo alcance com esse Shield SIM900!

Projetos para sua empresa

Manual do Maker é mais do que um blog. Somos uma empresa de serviços, cuja principal atividade é desenvolvimento e implementação de projetos embarcados e IoT. Trabalhamos dentro da legalidade, emitindo nota fiscal de serviço, elaboração de requisitos de sistema e documentação do código. Não importa onde você esteja, montamos a prova de conceito e gravamos vídeo do projeto antes de entregar o código e/ou hardware configurado.

Em parceria com a AFEletrônica, projetamos e produzimos hardware industrial, para lhe entregar a melhor experiência para seu projeto. Entre em contato: vendas@afeletronica.com.br Ou direto comigo: djames.suhanko@gmail.com

Será um prazer tê-lo como nosso cliente!