segunda-feira, 18 de novembro de 2013

Rastreador Arduino SIM900 + GPS I

Olá,


Nesse post vamos juntar dois módulos para criar um rastreador que informe latitude e longitude concatenado em um link de mapas do Google.

O primeiro passo é instalar a biblioteca TinyGPS++, essa biblioteca serve para comunicar com modulo GPS e adquirir os dados mais facilmente, quebrando todas informações, muito útil e bem feita.

Vamos por partes, esse primeiro código é para testar seu modulo GPS, lembre-se que as configurações de baud rate assim como pinos Software Serial podem e vão variar de modulo para modulo. Fique atento a esses detalhes do contrario o código não vai funcionar.

  1. #include <TinyGPS++.h> // inclui biblioteca
  2. #include <SoftwareSerial.h> // inclui biblioteca
  3. TinyGPSPlus gps; // inicia gsp
  4. SoftwareSerial ss(2,3); // inicia portas soft serial
  5. char server[] = "https://maps.google.com.br/maps?q="; // define caminho do link para receber lat e long(concatenar)
  6. String data; // define String de dados
  7. float dado_lat; // variáveis de armazenamento
  8. char lat_aux[10]; // variáveis de armazenamento
  9. String latParaString; // variáveis de armazenamento
  10. float dado_lng; // variáveis de armazenamento
  11. char lng_aux[10]; // variáveis de armazenamento
  12. String lngParaString; // variáveis de armazenamento
  13. void setup()
  14. {
  15.   Serial.begin(9600); // inicia porta serial HW
  16.   ss.begin(4800); // inicia porta serial SW (atencao para baud rate)
  17. }
  18. void loop()
  19. {
  20.   while (ss.available() > 0)
  21.     if (gps.encode(ss.read()))
  22.       displayInfo();
  23. }
  24. // faz leitura lat e lon, processa os dados e concatena junto com link do google
  25. void displayInfo()
  26. {
  27.   if (gps.location.isValid())
  28.   {
  29.     dado_lat=gps.location.lat();
  30.     dado_lng=gps.location.lng();
  31.    
  32.     dtostrf(dado_lat,4,4,lat_aux);
  33.     latParaString = String(lat_aux);
  34.    
  35.     dtostrf(dado_lng,4,4,lng_aux);
  36.     lngParaString = String(lng_aux);
  37.    
  38.     data+=(server);
  39.     data+=(latParaString);
  40.     data+=",";
  41.     data+=(lngParaString);
  42.     Serial.println(data);
  43.    
  44.   }
  45.   else
  46.   {
  47.     Serial.print(F("INVALID"));
  48.   }
  49.   Serial.println();
  50. }


O Código acima, basicamente faz a leitura da latitude e longitude do GPS, apos adquirir esses dados, as informações são processadas de forma juntar(concatenar) tudo com link do Google maps, a saida no serial monitor fica assim:

https://maps.google.com.br/maps?q=XX.XXX,YY.YYY

Onde X é latitude e Y longitude.


Se esse código esta funcionando para você, ou seja, seu modulo esta configurado corretamente e possui sinal na antena GPS, podemos passar para o próximo passo que é enviar esses dados via SMS usando o modulo GSM SIM900.

No próximo post vamos mostrar como transmitir os dados para seu celular, de forma criar um rastreador!



quinta-feira, 14 de novembro de 2013

Arduino GPRS - SIM900, Ler SMS Executar Ação II

Olá pessoal,

Ao longo desses meses, muitos leitores do blog tiveram problemas com esse código : Arduino GPRS - SIM900, Ler SMS Executar Ação

Nesse post, vou tentar esclarecer ainda mais esse assunto e demonstrar um código mais eficiente e a prova de erros que podem acontecer.

Primeiro vamos falar do serviço de SMS, Serviço de mensagens curtas (em inglês: Short Message Service, SMS) é um serviço disponível em telefones celulares digitais que permite o envio de mensagens curtas (até 160 caracteres) entre estes equipamentos. Foi originalmente foi projetado como parte do GSM (Sistema de comunicação móvel global) padrão digital de telefone celular, mas está agora disponível num vasto leque de redes, incluindo redes 3G e LTE.

Uma informação importante é que SMS destinada a usuário da mesma operadora possui tempo de processamento mais rápido pelo sistema, já que trafega na mesma rede. Ao enviar uma mensagem para usuários de outras operadoras o processo pode ser mais lendo, e não 100% confiável. O sistema também pode sofrer falhas na rede, o que acumula numero de SMS a serem entregues.

Dito isso, vamos a parte que nos interessa. Nos estamos usando o modulo GSM baseado no SIM900 para fazer o envio dessa SMS, no meio de tudo isso esta o Arduino para coordenar todo processo.
Antes de continuar lendo esse post, certifique-se que seu módulo esta operando corretamente com o Arduino, nesse post você encontra mais informações: Arduino GPRS - SIM900, Introdução I.

Não adianta passar para tópicos mais avançados se você ainda não dominou o interfaceamento dos módulos! Entenda o que é baud rate e como isso pode afetar o seu código, e como selecionar os pinos de software serial para fazer tal comunicação. Isso é de extrema importância visto que no mercado temos placas de diversos modelos, que não seguem o mesmo padrão, e na maioria dos casos funcionam de maneiras diferentes.

O programa a seguir foi testado durante 3 dias sem desligar o sistema, não tivemos nenhum problema no recebimento de SMS, todas ações foram executadas. Testado e aprovado!! :-)

Download do código.

Esta tudo comentado, leita o programa com atenção!

  1. #include <SoftwareSerial.h>
  2. SoftwareSerial myGSM(3,2);// define pinos TX/RX da porta software serial VARIA DE MODULO PARA MODULO!
  3. const int vermelho  = A0; // define saida LED vermelho
  4. const int verde     = A1; // define saida LED verde
  5. const int azul      = A2; // define saida LED azul
  6. String  linhaAtual  = "";              
  7. String  sms         = "";  
  8. String  smsAnterior = "";  
  9. boolean lendoSMS    = false;
  10. char inChar         = 0;
  11. void setup()
  12. {
  13.   delay(2500); // delay para inicializar sistema com segurança
  14.   myGSM.begin(19200);// inicia soft serial com baud rate 19200 VARIA DE MODULO PARA MODULO!
  15.   Serial.begin(19200);// inicia porta serial do arduino
  16.   testaModulo();// testa modulo se OK esta correto
  17.    Serial.println("Configurando SMS modo texto");
  18.   myGSM.println("AT+CMGF=1");
  19.   delay(800);
  20.   Serial.println("Apagando todas SMSs posteriores");
  21.   myGSM.println("AT+CMGD=1,4");
  22.   delay(800);
  23.   pinMode(vermelho,OUTPUT);
  24.   pinMode(verde,OUTPUT);
  25.   pinMode(azul,OUTPUT);
  26.   digitalWrite(vermelho,LOW);
  27.   digitalWrite(verde,LOW);
  28.   digitalWrite(azul,LOW);
  29. }
  30. void loop()
  31. {
  32.   myGSM.println("AT+CMGR=1");
  33.   delay(2000);
  34.   while(myGSM.available()!=0)
  35.   {
  36.     inChar = myGSM.read();
  37.     linhaAtual += inChar;
  38.     if (inChar == '\n')
  39.     {
  40.       linhaAtual = "";
  41.     }
  42.     if (linhaAtual.endsWith(">"))
  43.     {
  44.       lendoSMS = true;
  45.       sms = "";
  46.     }
  47.     if (lendoSMS)
  48.     {
  49.       if (inChar != '<')
  50.       {
  51.         sms += inChar;
  52.       }
  53.       else
  54.       {
  55.         lendoSMS = false;
  56.         if(sms!=smsAnterior)
  57.         {
  58.           sms.replace(">","");
  59.           Serial.print("SMS Recebido: ");
  60.           Serial.println(sms);
  61.           smsAnterior=sms;
  62.         }
  63.         if(sms == "Acende Vermelho")
  64.         {
  65.           Serial.println("Acendendo Vermelho");
  66.           digitalWrite(vermelho,HIGH);
  67.         }
  68.         if(sms == "Apaga Vermelho")
  69.         {
  70.           Serial.println("Apagando Vermelho");
  71.           digitalWrite(vermelho,LOW);
  72.         }
  73.         if(sms == "Acende Verde")
  74.         {
  75.           Serial.println("Acendendo Verde");
  76.           digitalWrite(verde,HIGH);
  77.         }
  78.         if(sms == "Apaga Verde")
  79.         {
  80.           Serial.println("Apagando Verde");
  81.           digitalWrite(verde,LOW);
  82.         }
  83.         if(sms == "Acende Azul")
  84.         {
  85.           Serial.println("Acendendo Azul");
  86.           digitalWrite(azul,HIGH);
  87.         }
  88.         if(sms == "Apaga Azul")
  89.         {
  90.           Serial.println("Apagando Azul");
  91.           digitalWrite(azul,LOW);
  92.         }
  93.         if(sms == smsAnterior)
  94.         {
  95.           myGSM.println("AT+CMGD=1,4");
  96.           delay(800);
  97.           sms="";
  98.         }    
  99.       }
  100.     }
  101.   }
  102.   myGSM.flush();
  103.   Serial.flush();
  104. }
  105. void testaModulo()
  106. {
  107.   Serial.println("Testando modulo GSM");
  108.   myGSM.println("AT");
  109.   mostraDadosSerial();
  110.   Serial.println("");
  111. }
  112. void mostraDadosSerial()
  113. {
  114.   delay(100);
  115.   while(myGSM.available()!=0)
  116.   {
  117.     Serial.write(myGSM.read());
  118.   }
  119. }

Funcionamento do circuito, cadastrei as seguintes ações:

  • Acende Vermelho
  • Apaga Vermelho
  • Acende Verde
  • Apaga Verde
  • Acende Azul
  • Apaga Azul
As saídas A0 A1 e A2 estão conectadas em um LED RGB, cada SMS acende ou apaga uma cor, no vídeo a seguir fica fácil visualizar o funcionamento:



Espero ter ajudado quem estava com duvidas. Esse código sem duvidas é mais robusto. se no inicio do programa você não receber na porta serial a seguinte mensagem:


Testando modulo GSM
AT

OK

Se funcionar assim vai ficar sua porta serial:


Foto do circuito:



Quer dizer que seu modulo não está configurado corretamente! siga novamente as instruções  Arduino GPRS - SIM900, Introdução I e tenha certeza que a conexão entre o modulo SIM900 - Arduino - Computador esta correta.


Próximo post, fazendo leitura de SMS e enviando localização atual GPS em formato do link Google Maps!