Conectando “coisas” através do Bluetooth

 

bluetooth-logo

Uma rede sem fio local (e pessoal) porreta é sem dúvida a Bluetooth (BT). Hoje em nosso dia-a-dia é comum encontrar-nos com celulares, aparelhos de som, cameras, etc., entrelaçados com a ajuda da famosa “luzinha azul”

No mundo do IoT e da automação em geral, é muito comum deparar-nos com controles remotos via celulares utilizando tecnologia BT. Isso é devido a 2 componentes básicos mas muito importantes:

  1. Plataforma de desenvolvimento para OS ANDROID
  2. Módulos BT baratos e acessíveis (Como por exemplo o HC-06)

Neste tutorial, vou desenvolver algumas idéias de como controlar as saídas de um Arduíno através de um celular de maneira a mover um Robot, acionar lâmpadas em uma casa, etc.

No mercado é comum encontrar módulos de BT 3.0  “Master-Slave” como o HC-05  e “Slaves” como o HC-06. Já mais recentemente, apareceram os HC-08 e HC-10 que trabalham com tecnologia BT 4.0 ou BLE (“Bluetooth Low Energy”). Os módulos BLE são os únicos que podem ser conectados a um Iphone, pois infelizmente a Apple não fornece suporte a ao BT 3.0.

Para os projetos discutidos aqui, usarei um HC-06 que é bem popular e barato (Bye, bye, Iphone, vamos de Android!). O Módulo é alimentado com 5V o que faz com que ele seja facilmente conectado a um Arduino

HC06 PinsUNO por exemplo, para receber e transmitir informações a outros dispositivos como um PC ou um telefone celular. Seus pinos de transmissão e recepção podem ser conectados diretamente ao UNO, não havendo a necessidade de se utilizar divisores de tensão como vimos no caso do ESP8266.

Na prática, o HC-06 deve ser ligado diretamente aos pinos 0 e 1 do Arduino (Serial):

  • HC06-Tx ao Arduino pin 0 (Rx)
  • HC06-Rx ao Arduino pin 1 (Tx)

Ao se usar a entrada serial por HW do UNO é muito importante lembrar-se que o HC-06 não pode estar fisicamente conectado aos pinos 0 e 1 durante a carga do programa, isso porque o USB também usa essa mesma serial.  Uma maneira simples de se contornar esse probleminha (se seu projeto não utiliza muitos GPIOs do UNO) é usar uma porta serial por SW através da library SoftwareSerial (a mesma que usamos no caso do ESP8266). Em nosso caso aqui, usaremos os pinos 10 e 11 do UNO (Tx, Rx respectivamente).

UNO-HC06

O passo seguinte será escrever um codigo bem simples para se poder testar, programar e inicializar o HC-o6:

Para iniciar, incluir a Library Software Serial, definindo a variável “BT” como a nova porta serial.

#include <SoftwareSerial.h>
SoftwareSerial BT(10, 11); // RX, TX
String command = ""; // Stores response of bluetooth device
 
void setup()
{
 Serial.begin(9600);
 Serial.println("Type AT commands!");
 BT.begin(9600); // HC-06 usually default baud-rate
}

Em seguida vem o corpo principal do código que simplesmente espera por dados vindos do BT e uma vez que eles chegem, os mesmos são escritos no Serial Monitor. Da mesma maneira, se podem enviar comandos AT desde o monitor serial até o módulo HC-06.

void loop()
{
 if (BT.available()) // receive data if available.
 {
  while(BT.available()) // "keep receiving".
  {
   delay(10); //Delay added to make thing stable 
   char c = BT.read(); //Conduct a serial read
   command += c; //build the string.
  } 
  Serial.println(command);
  command = ""; // No repeats
 } 
 if (Serial.available())
 {
  delay(10); 
  BT.write(Serial.read());
 }
}

 

Uma vez carregado o programa, faça alguns testes básicos. Por exemplo, envie “AT“, o módulo deverá responder “OK“. Pergunte a versão do Firmware: “AT+VERSION”, o módulo deverá responser, por exemplo: “linvorV1.8“. Com o HC-06 é possível definir um nome para o módulo por exemplo: “AT+NAMEMJRoBot_BT_HC06“.  Mas diferente de outros módulos, voce não conseguirá saber qual é o nome que está definido para o módulo. Ao se enviar o comando anterior, o HC-06 responderá simplesmente: “OKsetname”

Em geral, o HC-o6 vem de fábrica com o password (ou PIN): 1234. Voce poderá definir um novo com o comando AT: AT+PINxxxx onde ‘xxxx‘ serão 4 números.

OK! Módulo conectado ao UNO e funcionando. Hora de lançar mão do velho e bom celular Android!!!

Existem muitas apps na loja da Google que podem ser utilizadas. Vou sugerir duas delas, por serem as que usarei nos tutoriais deste blog. Essas apps foram desenvolvidas por mim utilizando o MIT Application2 tool (veja projeto aqui) e estão disponíveis sem custo na loja da Google:

  1. MJRoBot II BT Control
  2. MJRoBot BT Digital Analog Voice Control

MJRoBot BT IconO App MJR0Bot II foi desenvolvido para comandar Robots. Ele basicamente envia um caracter para cada comando de direção, modos AUTO/MANUAL, velocidade + e velocidade-. Alem de permitir o envio de mensagens em modo texto.

2015-12-11 20.26.44 copy

 

MJRoBot BT Ctrl app Logo

O App. MJRoBot Digital Analog Voice Control, envia comandos para acionamento digitais (ligar/desligar) tanto por botões como por voz e comandos numéricos para controle de PWMs (0-255).

FullSizeRender 10

 

Faça o Download de qualquer uma das duas Apps, vá ao set-up do celular e procure o modulo BT fazendo a conexão (entre com o PIN 1234 ou algum outro definido por você).  Isso deverá ser feito uma única vez, pois o celular guardará os dados de conexão. Uma vez que o celular e o HC-06 estão conversando, é só usar as APPs.

A partir da segunda vez, ao lançar-se a app, o modulo BT estará desconectado.

FullSizeRender 14

Acione o botão de BT, para que o app informe dos modulos disponíveis:

FullSizeRender 12

Selecione o nome do módulo (No caso é esse com o HC-06 ao final).

O App então mostrará “CONNECTED”, informando que está “pared” com o HC-06

FullSizeRender 13

A partir daí, é só ir acionando os botões do APP e observar no Monitor Serial, o que é que o APP está enviando.

Por exemplo, acionando “ON” e “OFF” sequencialmente para os 4 devices, no caso da APP MJR0Bot BT Digi/Ana/Voice Ctrl, o resultado seria:

dev1on
dev1off
dev2on
dev2off
dev3on
dev3off
dev4on
dev4off 

Agora que já temos um App para o Android e sabemos como funciona um modulo BT, vamos colocar a mão na massa e criar algo de util!

Controlando as saídas do Arduino.

Vamos construir o circuito abaixo:

Picture1

A idéia será usar o App MJRoBot Digi/Ana/Voice Ctrl para acender e apagar os LEDS e também controlar a intensidade dos mesmos.

Estaremos relacionando:

  • Device 1: "dev1on/dev1off" ==> LED Red ==> Pin 3 do UNO
  • Device 2: "dev2on/dev2off" ==> LED Yellow ==> Pin 5 do UNO
  • Device 3: "dev3on/dev3off" ==> LED Green==> Pin 6 do UNO
  • Device 4: "dev4on/dev4off" ==> LED Blue==> Pin 9 do UNO

Ou seja, ao acionar o botão “ON” relacionado ao “Device 1”, a mensagem de texto “dev1on”será enviada ao Arduino. Ao receber essa mensagem, o LED vermelho deverá acender e assim por diante.

Observe que os 4 pinos são pinos com capacidade de gerar PWM. Isso é importante para a utilização dos “sliders” da App, que enviarão valores para controlar a intensidade dos LEDs via PWM

  • Dev A0: "r/ 0-255" ==> LED Red ==> Pin 3 do UNO
  • Dev A1: "y/ 0-255" ==> LED Yellow ==> Pin 5 do UNO
  • Dev A2: "g/ 0-255" ==> LED Green==> Pin 6 do UNO
  • Dev A3: "b/ 0-255" ==> LED Blue==> Pin 9do UNO

No caso dos controles deslizantes (“sliders”), antes dos valores para controle do PWM (0 a 255), um caracter será enviado para que o Arduino saiba de que “slider” estará chegando o comando.

O código:

Setup inicial:

#include <SoftwareSerial.h>
SoftwareSerial BT(10, 11); //TX, RX respectively
String device;
const int dev1 = 3; //PWM
const int dev2 = 5; //PWM
const int dev3 = 6; //PWM
const int dev4 = 9; //PWM
void setup() 
{
 BT.begin(9600);
 Serial.begin(9600);
 
 pinMode(dev1, OUTPUT);
 pinMode(dev2, OUTPUT);
 pinMode(dev3, OUTPUT);
 pinMode(dev4, OUTPUT);
}

Podemos dividir a parte principal do programa em 4 blocos:

  1. Espera dos comandos BT e construção da variável “device”
  2. Acionamento dos LEDS a partir dos botões
  3. Acionamento dos LEDS a partir de comandos de voz
  4. Controle do intensidade dos LEDs via Sliders
void loop() 
{
 while (BT.available()) 
 {
   delay(10); //Delay added to make thing stable 
   char c = BT.read(); //Conduct a serial read
   device += c; //build the string.
 } 
   if (device.length() > 0) 
 {
   Serial.println(device); 
   // Button control:
   if (device == "dev1on") {digitalWrite(dev1, HIGH);}
   else if (device == "dev1off") {digitalWrite(dev1, LOW);}
   else if (device == "dev2on") {digitalWrite(dev2, HIGH);}
   else if (device == "dev2off") {digitalWrite(dev2, LOW);}
   else if (device == "dev3on") {digitalWrite(dev3, HIGH);}
   else if (device == "dev3off") {digitalWrite(dev3, LOW);}
   else if (device == "dev4on") {digitalWrite(dev4, HIGH);}
   else if (device == "dev4off") {digitalWrite(dev4, LOW);}
 
   // Voice control:
   else if (device == "ligar um" || device == "Ligar 1") {digitalWrite(dev1, HIGH);}
   else if (device == "desligar um" || device == "desligar 1") {digitalWrite(dev1, LOW);}
   else if (device == "ligar som" || device == "Ligar som") {digitalWrite(dev2, HIGH);}
   else if (device == "desligar som" || device == "Desligar som") {digitalWrite(dev2, LOW);}
   else if (device == "ligar TV" || device == "Ligar TV") {digitalWrite(dev3, HIGH);}
   else if (device == "desligar TV" || device == "Desligar TV") {digitalWrite(dev3, LOW);}
   else if (device == "ligar quarto" || device == "Ligar quarto") {digitalWrite(dev4, HIGH);}
   else if (device == "desligar quarto" || device == "Desligar quarto") {digitalWrite(dev4, LOW);}
   // Slider control:
   char colour = device[0]; 
   int value = device[2]; 
   Serial.print(" "); 
   Serial.println(value); 
   if ( colour == 'r') 
   { 
     analogWrite(dev1, value); // use value to set PWM for LED brightness 
   } 
     if ( colour == 'y') 
   { 
     analogWrite(dev2, value); // use value to set PWM for LED brightness 
   } 
     if ( colour == 'g') 
  { 
    analogWrite(dev3, value); // use value to set PWM for LED brightness 
  } 
    if ( colour == 'b') 
  { 
    analogWrite(dev4, value); 
  }
  device=""; //Reset the variable
 } 
}

 

Link para o código Arduino

No vídeo abaixo, uma demonstração da porção programa acima (botões & Slider):

O controle de dispositivos IoT por voz é uma tendência nos dias de hoje. Conseguir este tipo de controle com o conjunto Arduino/HC-06/Android é extremamente simples. Os dispositivos Android já possuem essa característica “de fábrica”. No App que desenvolví, apenas acrescentei um botão que faz com que o Android “escute” um comando e o envie em formato texto para o Arduino. O codigo se encarrega de “ler” a string que chega.

Em vermelho, ressalto no código alguns possíveis comandos de voz. Ao receber por  “Ligar TV” por exemplo, o LED verde (correspondente ao device 3) acenderá (em vez do LED podíamos ter uma relé que ligaria a TV).

No vídeo abaixo, uma pequena demonstração do controle por voz:

 

Bom, acredito que já é possível ver o enorme potencial do controle de “coisas” usando BT/Android/Arduino. Em meus próximos posts estarei desenvolvendo Robots que poderão ser controlados remotamente como vimos aqui.

Um abraço e até mais!

 

Anúncios

Basic stuff – “O ovo”…. ou será “a galinha”….?

Para começar (e se desenvolver) no mundo da eletrônica, o melhor caminho sem dúvida é a internet! Vai aqui uma super dica de como se tornar um grande programador através da técnica do “Psychding”:

Psychding

Heheheheheh! Seria bom se só isso resolvesse! Mas ajuda, claro! Mas para aprender mesmo, vale a pena uns cursos, muita leitura e claro, “mãos na massa!”. Para o pessoal que está no Brasil um site muito legal é o:

Laboratório de Garagem

Como o pessoal do Garagem mesmo explica, “O Laboratório de Garagem é uma iniciativa voltada para a integração, colaboração e apoio aos desenvolvedores independentes de ciência e tecnologia, ou como gostamos de ser chamados: garagistas.

Somos uma rede social, uma incubadora, uma loja virtual e um grupo de pessoas que acreditam que a próxima revolução pode (e vai) sair de uma garagem, ainda mais se ela estiver conectada a muitas outras garagens.

Eu também sou um dos garagistas e tenho procurado dar meus pitecos por lá. Vale a pena se associar, participar, mandar sugestões, etc. O pessoal de lá é muito legal, estão sempre prontos a ajudar, não importando se as dúvidas são básicas ou complicadas!

O Lab de Garagem por exemplo, tem um curso on-line básico muito legal (em português) para quem quer se iniciar no mundo dos Arduinos:

Curso Arduino – Loboratorio de Garagem

É isso aí! Inté!

Marcelo Rovai no Garagem

O ESP8266 parte 3 – Acionando LEDs remotamente

Depois de um longo e tenebroso inverno, chegamos ao ponto de acionar LEDs (ou qualquer coisa) remotamente via WiFi. Para quem entrou direto nesse post, vale a pena dar uma sapeada em meus 2 posts anteriores:

  1. O ESP8266 – Serial WIFI Module
  2. O ESP8266 parte 2 – Web Server

A diferença básica aqui, é que ao invés do Arduino criar uma pagina web para enviar as informações capturadas, agora será uma página criada anteriormente em HTML e hospedada em algum sitio web (no nosso caso aqui estará em emu desktop) que enviará os dados. Esta pagina estará recebendo comandos de um usuário enviando-os via WiFi ao Arduino.

LED Ctrl

O Circuito:

O circuito é bem simples. As conexões do ESP8266 com o UNO são as mesmas dos posts anteriores, apenas acrescentamos os 3 LEDs a 3 GPIOs do UNO:

GPIO 11: LED azul
GPIO 12: LED vermelho
GPIO 11: LED verde

ES8266_Arduino_UNO_GPIO_Control

O código HTML:

A Página deve ser gerada em HTML em um editor qualquer e salva no desktop.

HTML Buttons

A parte principal do codigo HTML abaixo, é a geração dos “botões”, no caso “ON” e “OFF”. Observe que para cada botão (são 6 no total, 2 para cada GPIO), é gerado um “id” específico. Por exemplo, se o botão “ON” para o GPIO 11 for pressionado, o id será “111”, ou seja os dois primeiros dígitos para a identificação do GPIO (no caso “11”) e o 3o. dígito para o estado, no caso “1” ou “ON”. Se fosse “OFF”, o Id sería 110. No caso, na saída digital do pino 11, está o LED azul.

Uma vez gerado o “id” uma função na página se encarrega de enviar-la para para o IP address do ESP8266. Observe que o endereço que aparece no set-up do ESP 8266 tem que ser incluído na linha ==> $.get(“http://10.0.1.14:80/&#8221;, {pin:p});

HTML Button click

No monitor serial se pode observar o valor do pin que é gerado pela página.

Serial monitor ongoing

As primeiras vezes que testei o programa, tive vários problemas e o mais importante foi que observei que só era possível enviar 5 comandos aos LEDs. Isso porque  a cada envío de informação o ESP8255 considerava uma conexão aberta (CONNECT 0, 1, 2, 3, 4) e o limite é 5.

Observei também que quando fazia um “refresh” na página, o connect, voltava a zero. A solução foi incluir um novo codigo HTML, que forçava o refresh automático da página (código tipo “META”). No caso optei por fazer um refresh a cada 15s para não ficar muito ruim para o usuário. Funcionou sem problemas:

HTTP-EQUIV=”refresh” CONTENT=”15″>

O código do Arduino:

O código é muito parecido com o código anterior:

Inicializa, faz o setup das portas, “reseta” e inicializa o ESP8266, etc., usando as mesmas funções definidas no post anterior.

A diferença básica está na porção em verde do código contido  no “Loop”:

void loop()
{
  if(esp8266.available())
  {
    if(esp8266.find("+IPD,"))
    {
      delay(1000);
      
      int connectionId = esp8266.read()-48; 
      esp8266.find("pin="); 
      int pinNumber = (esp8266.read()-48)*10; 
      pinNumber += (esp8266.read()-48); 
      int statusLed =(esp8266.read()-48);
      digitalWrite(pinNumber, statusLed)
      
      String closeCommand = "AT+CIPCLOSE="; 
      closeCommand+=connectionId; 
      closeCommand+="\r\n";
      sendData(closeCommand,1000,DEBUG);
    }
  }
}

Ao ler o “id”, por exemplo “111”, o código separa os primeiros dois dígitos e constrói a variável “pinNumber”. Com o 3o. dígito, se obtém o “statusLed”. A função digitalWrite enviará o status do LED, no caso do exemplo “1” para o GPIO correspondente (ou “pinNumber”), no exemplo 11.

No vídeo abaixo, pode-se ver um exemplo do acionamento remoto dos LEDs:

Para finalizar, no link abaixo deixo o codigo completo para o Arduino e para a pagina em codigo HTML.

Link para os codigos fonte no GItHub

Conclusão

Como sempre, espero que este projeto ajude outras pessoas a encontrar seu caminho no apaixonante mundo da eletrônica, robótica e do IoT!

Não deixe de visitar e seguir minha página: MJRoBot.org no Facebook

“Saludos desde el sur del mundo!” 😉

Um abraço e até o próximo post!

Obrigado

Marcelo

O ESP8266 parte 2 – Web Server

Em meu post anterior procurei descrever o que é, como ligar, testar e configurar o ESP8266 (vamos chamar-lo ESP para simplificar). Aqui vamos dar uma pincelada no que se deve fazer com o ESP para interagir com os GPIOs do Arduino remotamente via web .

Alguém disse uma vez “If you can blink a LED you can do anything”. No mundo dos sistemas embebidos (“Embebed systems”), esse dizer é uma verdade verdadeira ululante! Quando você faz com que um LED acenda a partir de um sinal gerado em uma das portas do Arduino, ou que ele possa ler o status de uma chave ou sensor, o que está realmente acontecendo é a interação do mundo da eletrônica com o mundo físico! Conseguir essa interação via uma página da internet é de fato toda a essência do IoT.

image

A primeira configuracão que testarei, será o ES8266 funcionando como um servidor web local, conectado a um Arduino MEGA. Vamos instalar botões em dois GPIOs digitais do Arduino (Pinos 8 e 9) simulando o estado de algum sensor e um potenciômetro na porta analógica A0, simulando os dados fornecidos por um sensor analógico, como por exemplo temperatura (os “inputs” do diagram acima). A função do ESP8266 será ler esses sinais, gerar uma página HTML  simples, publicando os resultados em tempo real na web! Cool!!!!!!!!

O circuito:

Webserver circuit

Observe que  o circuito é basicamente o mesmo que o do post anterior, apenas adicionei dois botões (normalmente abertos) conectados entre as entradas do Arduino  e o VCC (via um resistor de 10K para não gerar um curto-circuito, claro). Ao pressionar o botão, o que estamos fazendo é colocar um sinal HIGH na entrada digital do Arduino. O potenciômetro (também de 10K) será montado entre VCC (5V) e Terra, com seu pino central conectado a entrada analógica A0 do MEGA. O pot controlará o nível de tensão na entrada analógica A0,  a qual variará de “0V a 5V”. O MEGA lerá a tensão no pino AO e seu ADC interno (Analogic Digital Converter), convertendo a mesma para um valor que variará respectivamente de “0 a 1023”.

O Código:

O que farei aqui, será ressaltar as principais diferenças da sketch anterior ( O ESP8266 Serial Wifi Module), mas não se preocupem que no final, deixo o link para o código completo:

  • Antes de mais nada, depois das definições e set up geral como já foi visto anteiormente, é importante iniciar o ESP como um servidor. Para isso, a função InitWifiModule()
void InitWifiModule()
{
  sendData("AT+RST\r\n", 2000, DEBUG); // reset
  sendData("AT+CWJAP=\"Your network ID\",\"password\"\r\n", 2000, DEBUG); 
  delay(3000);
  sendData("AT+CWMODE=1\r\n", 1000, DEBUG);
  sendData("AT+CIFSR\r\n", 1000, DEBUG); // Show IP Adress
  sendData("AT+CIPMUX=1\r\n", 1000, DEBUG); // Multiple conexions
  sendData("AT+CIPSERVER=1,80\r\n", 1000, DEBUG); // start comm port 80
}
  • No loop principal, se espera para ver se o ESP está enviando algo e se o string  “+IPD” é encontrado significa que a pagina foi identificada (veja a cópia do monitor serial mais abaixo).
  • Esperamos 300 milisegundos para garantir que o buffer serial tenha lido todos os dados.
  • Como a função read() retorna ASCII, é importante que ao se carregar o connection ID, seja subtraído o valor “48” do dado lido. 48 é o código do primeiro caracter decimal “0”. Assim se o dado 49 (codigo ASCII para  “1”) é recebido, ao subtrair 48, o resultado será um digito puro (“1”).
  • Em verde, está o código HTML que será enviada ao Browser para a construção da página (Note que mesmo que você não seja familiar com a linguagem HTML, em vermelho está o que aparecerá escrito na página, fique livre para customizer-la a seu gosto).
  • Em azul, as informações são enviadas (Comando CPISEND) e em laranja se fecha a conexão (comando CPICLOSE).
void loop()
{
   if (esp8266.available()) // check if 8266 is sending data
   {
      if (esp8266.find("+IPD,"))
      {
         delay(300);
         int connectionId = esp8266.read() - 48;
 
         String webpage = "<head><meta http-equiv=""refresh"" content=""3";
         webpage += "</head><h1>MJRoBot WebServer ESP8266</h1><h2>Ardin: ";
         webpage += "D8 status ==> ";
         int a = digitalRead(8);
         webpage += a;
         webpage += "<h2>Arduino Pin: D9 status ==> ";
         int b = digitalRead(9);
         webpage += b;
         webpage += "<h2>Arduino Pin: A0 data ===> ";
         int c = analogRead(0);
         webpage += c;
         webpage += "</h2>";
 
        String cipSend = "AT+CIPSEND=";
        cipSend += connectionId;
        cipSend += ",";
        cipSend += webpage.length();
        cipSend += "\r\n";
       sendData(cipSend, 1000, DEBUG);
       sendData(webpage, 1000, DEBUG);
 
      String closeCommand = "AT+CIPCLOSE=";
      closeCommand += connectionId; // append connection id
      closeCommand += "\r\n";
      sendData(closeCommand, 3000, DEBUG);
     }
  }
}
  • A função “sendData()” enviará os comandos AT para o ESP
  • Quando o esp8266.available é TRUE, significa que existem dados disponíveis , portanto a resposta “c” é montada
String sendData(String command, const int timeout, boolean debug)
{
  String response = "";
  esp8266.print(command);
  long int time = millis();
  while ( (time + timeout) > millis())
      {
        while (esp8266.available())
            {
              char c = esp8266.read(); // read the next character.
              response += c;
            }
      }
      if (debug)
        {
          Serial.print(response);
        }
      return response;
}
  • Durante a conexão o monitor serial apresenta os dados abaixo:
  • Muito importante é o segundo IP address que aparece no monitor: 10.0.1.2

Serial - Conxion

 

  • Ao entrar com o IP acima, em um browser, o ESP montará a pagina HTML que foi programada e começará a enviar as informações capturadas nas entradas do MEGA:

Webserver page

  • No monitor Serial, se observará os dados que são continuamente atualizados:

Serial Ongoing comm

  • No vídeo abaixo se poderá observar o WebServer funcionando:

 

Link para a sketch do Arduino MEGA e do diagrama eletrônico

Tudo o que foi visto aqui para o Arduino MEGA poderia ser executado com um Arduino UNO, ou qualquer outro da família.

A diferença básica será a utilização de outros GPIOs como port serial. Como o UNO só tem 1 port, usaremos a biblioteca softwareSerial () para definir os pinos 2 e 3 como RX e TX respectivamente (note que isso só funciona para velocidades mais baixas que 19.600bauds)

As definições iniciais no código devem ser alteradas para:

#include <SoftwareSerial.h> 
SoftwareSerial esp8266(2,3);  //Rx ==> Pin 2; TX ==> Pin3

#define speed8266 9600 

O restante do código para o UNO funcionará da mesma maneira que para o MEGA.

O novo circuito:

ESP8266_WebServer_UNO

O vídeo abaixa, mostra o UNO como um WebServer executando o mesmo código anterior:

Link para o vídeo do WebServer funcionando com o UNO

Conclusão

Bom, é isso aí. Como havia dito, essa menina não é fácil! e ainda não vimos os LEDs piscarem! Mas isso fica para um próximo post. Façam o download do programa completo abaixo, mão na massa e boa sorte!

Como sempre, espero que este projeto ajude outras pessoas a encontrar seu caminho no apaixonante mundo da eletrônica e do IoT!

Não deixe de visitar e seguir minha página: MJRoBot.org no Facebook

“Saludos desde el sur del mundo!” 😉

Um abraço e até o próximo post!

Obrigado

Marcelo

 

 

 

 

 

O ESP8266 parte 1 – Serial WIFI Module

Caminho das pedras para fazer o set-up e testar o modulo ESP8266 com um Arduino MEGA.

O ESP8266 é talvez o mais versátil modulo serial para se conectar “coisas” a internet, daí ele ser tão popular no mundo do IoT. Ele é um modulo completo, que inclui um microprocessador que pode ser programado diretamente via o IDE do Arduino (em C++), ou em outros ambientes para compilação (usualmente usando uma linguagem de alto nível própria, o “Lua”). Para se controlar “coisas”, não há necessidade de se ter o Arduino propriamente dito para a interface, pois o ESP8266 possui 2 GPIOs (dois “pinos” de entrada/saída).

Link para o Forum específico do ESP8266

Features:

  • 802.11 b/g/n
  • Wi-Fi Direct (P2P), soft-AP
  • Integrated TCP/IP protocol stack
  • Integrated TR switch, balun, LNA, power amplifier and matching network
  • Integrated PLLs, regulators, DCXO and power management units
  • +19.5dBm output power in 802.11b mode
  • Power down leakage current of <10uA
  • 1MB Flash Memory
  • Integrated low power 32-bit CPU could be used as application processor
  • SDIO 1.1 / 2.0, SPI, UART
  • STBC, 1×1 MIMO, 2×1 MIMO
  • A-MPDU & A-MSDU aggregation & 0.4ms guard interval
  • Wake up and transmit packets in < 2ms
  • Standby power consumption of < 1.0mW (DTIM3)

Meio cheio de palavrões acima, mas é bom ter a mão “just in case”.

Até hoje, eu somente estudei o ESP8266 junto com o Arduino, substituindo a necessidade de um relativamente caro shield para wiFi (Shield, são umas plaquinhas que se instalam ao Arduino para expandir suas capacidades).  Ainda não brinquei com a menina no modo “stand alone”, isso ficará para um post mais adiante. A propósito, o ESP8266 é realmente uma menina bonita e prendada, mas como todas elas, dão um trabalho ……… 😉

Testando o ESP8266 com comandos AT:

Bom, a primeira coisa que se tem que fazer é testar o módulo com comandos AT, que é o standard de comunicação. Em geral o modulo vem de fabrica falando em uma velocidade de 115.200 bauds. isso acaba complicando, pois no caso do Arduino UNO (vou usar só UNO daqui para frente), só a Serial por HW “0” , (pinos 0 e 1) consegue trabalhar nessa velocidade. O problema é que o Monitor serial do PC (vou também deixar PC como um termo genérico aqui, mas que meu Mac não me ouça…..), também usa esse mesmo port serial. A solução no caso do UNO é usar a biblioteca “SoftwareSerial” para designar outros 2 pinos genéricos (GPIOs) para serem usados como uma porta serial (por SW). Isso funciona OK desde que a velocidade de transmissão seja inferior a 19.200 bauds. Perfeito! Mas como fazer no caso do ESP8266 vir programado em uma velocidade maior? O jeito é reprogramar-lo, claro! BUT, nem todos os Firmwares que vem carregados no módulo aceitam reprogramação. Então, o negócio é atualizar o FW (Ufa!!!) . Em outro post eu vou explicar como. Aqui, para não esquentar a cabeça com esse negócio de velocidade, firmware, etc, vou sar o Arduino MEGA, que na falta de 1, tem 4 ports seriais por HW!!!!!!!! Viva a abundância! ops! Afinal sou brasileiro, né 😉

Os ports do MEGA:

  • TX0/RX0 ==> Pin 1,0 (mesmo que o UNO) ==> “Serial 0”
  • TX1/RX1 ==> Pin 18,19 ==> “Serial1”
  • TX2/RX2 ==> Pin 16,17 ==> “Serial2”
  • TX3/RX3 ==> Pin 14,15 ==> “Serial3”

Para meus testes, vou usar a Serial 2 (pinos 16 e 17)

Mega TxRx

Bueno, chegou a hora de olhar a menina mais de pertinho …

  • ALIMENTAÇAO: 3.3V. Isto é muito importante, pois o módulo não funciona com 5V e pode queimar se voce teimar (rimou!). Os pinos de entrada também não suportam 5V e ao receber um sinal do Arduino, é importante usar um “conversor de nível de tensão” (nome bonito para o bom e velho divisor de tensão por resistores). Outro ponto importante, é bom ter uma fonte de 3.3V independente. Nem sempre o Arduino consegue suprir a corrente necessária para a operação do módulo.

O módulo tem 6 pinos:

esp8266-pinout-800x379

  • TX: que vai ser conectado ao RX2 do MEGA (pode ser conectado direto, pois o MEGA não tem problema em entender 3.3V como HIGH).
  • RX: conectado ao TX2 do MEGA via um conversor de nível
  •  VCC: 3.3V
  • GND: Ground. Nunca é demais lembrar que é necessário conectar o GND do ESP8266 ao GND do MEGA.
  • CH_PD (*): conectado ao pin 4 do MEGA para reset de SW para iniciar comunicação
  • RST: RESET em geral, conecta em VCC
  • GPIO0: aberto
  • GPIO2: aberto

(*) Em vários sites na internet, esse pino é conectado direto a VCC. No meu caso, sem o “reset” por SW (coloca o pino momentaneamente em LOW), o ESP8266 não funcionou.

Existem no mercado adaptadores para inserir o modulo no protoboard, pois a distancia fisica entre os pinos do ESP8266 não são compatíveis). Eu usei um cabinho com fios “Macho/Fêmea” tipo FTDI (veja abaixo) para a conexão. As cores mostradas são compatíveis com o diagrama de conexão.

esp8266 cable color

 

 

 

 

O circuito então fica:

esp8266 test

Nada de especial no diagrama de HW. A plaquinha vermelha é uma fonte independente de 3.3V que se acopla ao protoboard. veja que o fio amarelo TX2 no arduino, passa pelo divisor de tensão (resistores de 1K e de 2.2K), para que quando o TX2 esteja em HIGH (5V), o ESP8266 receba aprox. 3.3V (HIGH para ele).

O Software:

A idéia dessa sketch é executar testes no module, fazendo cm que se possa entrar com comandos AT via o monitor serial e ver a resposta:

Na parte inicial de comentários, estão os comandos mais básicos. Ao carregar o programa, vai aparecer um monte de lixo, depois o nome no modulo e por fim a palavra “ready”. nesse momento se pode enviar os comandos AT.

Comece pelo AT simples, o modulo deve retornar OK, teste outros comandos e por aí vai.

Em seguida a sketch, há uma figura com o que aparece no Monitor serial, para diversos comandos.

/****************************************************************
* ESP8266
* Arduino Mega Using Serial2
* AT commands examples for test:
* AT =====> ESP8266 returns OK
* AT+RST =====> ESP8266 restart and returns OK
* AT+GMR =====> ESP8266 returns AT Version; SDK version; id; OK
* AT+CWMODE? => ESP8266 returns mode type
* AT+CWLAP ===> ESP8266 returs close access points
* AT+CIFSR ===> ESP8266 returs designided IP
* AT+CIPMUX=1 ==>Set ESP8266 for multoples conections 
* AT+CIOBAUD=9600 ==>Change Baudrate ==> ESP8266 returs OK
* AT+CIPSERVER=1,80 ==> set modo SERVER port: 4040
* AT+CWMODE=3 ==> Conect ESP8266 ascombined mode (Access Point (2) and Server (1))
* AT+CWSAP="Acc_Point_name","password",wifi_Channel,cript# ==> ej. AT+CWSAP="ESP_8266_AP,"1234",3,0
* AT+CWJAP="SSID","password" ==> Connect to WiFi network
* AT+CWJAP="ROVAI TIMECAP","mjr747@1"
*
* Marcelo Jose Rovai 18Jan16
******************************************************************/
#define esp8266 Serial2
#define CH_PD 4 
#define speed8266 9600 // This is the speed that worked with my ESP8266
void setup() 
{
 esp8266.begin (speed8266); 
 Serial.begin(9600);
 reset8266(); // Pin CH_PD need a reset before start communication
}
void loop() 
{
 while(esp8266.available())
 {
 Serial.write(esp8266.read());
 }
 while(Serial.available())
 {
 esp8266.write(Serial.read());
 }
}
/*************************************************/
// Reset funtion to accept communication
void reset8266 ()
{
 pinMode(CH_PD, OUTPUT);
 digitalWrite(CH_PD, LOW);
 delay(300);
 digitalWrite(CH_PD, HIGH);
}

O Monitor Serial:

Serial Monitor test

Deixo abaixo um link com meu Dropbox, onde estão os documentos referente aos testes: sketch do Arduino, o Fritzing e dois documentos em PDF bem legais. Um com a lista completa de comandos e outro com um guia para fazer o set-up do módulo em varias configurações (web server, Access point, etc.). Já antecipo que a única maneira de aprender é colocar a mão na massa e ver o que acontece. Faça as ligações, entre com o programa e mande bala!!!!!

Link para a documentação do ESP8266

Conclusão

Bom, é isso aí.É isso aí. Nos próximos posts mostrarei como configurar o ESP8266 como um servidor web. Agora é por a mão na massa e boa sorte!

Como sempre, espero que este projeto ajude outras pessoas a encontrar seu caminho no apaixonante mundo da eletrônica e do IoT!

Não deixe de visitar e seguir minha página: MJRoBot.org no Facebook

“Saludos desde el sur del mundo!” 😉

Um abraço e até o próximo post!

Obrigado

Marcelo

Cursos de eletrônica online (foco: IoT)

No meu último post, comentei que o curso que fiz através da plataforma EDX me ajudou a re-descobrir o mundo da eletrônica. De lá para cá, tenho nas horas vagas procurado fazer alguns cursos tanto do EDX quanto do COURSERA. Essas plataformas são a ponta de lança para que grandes universidades ou empresas possam propiciar cursos on-line. Em geral a qualidade é muito boa e a profundidade depende da instituição ou do tema. Como regra geral, eu diria que os cursos do EDX são mais complexos, profundos e necessitam bastante dedicação e tempo. Já os do COURSERA, são mais superficiais e rápidos. Esses cursos são conhecidos como MOOC (Massive Open Online Course) e seguramente vão transformar a educação como a conhecemos hoje.

Existem tanto cursos “isolados” sobre um determinado tema  como outros que são “Especializações”, ou seja um conjunto de cursos (em geral 5 + um projeto final) que também podem ser feitos individualmente. Todos os cursos podem ser feitos sem certificado final (gratuitos) ou com direito a certificado (em média, uns USD50/curso).

Aqui vão algumas sugestões de cursos que estão abertos no momento, outros que já fecharam, mas ainda disponibilizam conteúdos e alguns que ainda estão por vir:

O legal é explorar as plataformas (no primeiro parágrafo estão os links) e encontrar o curso que te apetece. Tem para todos os gostos!

Boa sorte, arregasse as mangas e mande bala!

Saludos!

File 1-12-16, 19 31 04

File 1-12-16, 19 27 12

File 1-12-16, 19 26 44

 

 

MJRoBot I – O Robot de Berkeley

Passos para a construção de um robot autônomo.

Fazem alguns meses, terminei meu primeiro curso on-line. Foi uma experiência nova mas que despertou em mim uma paixão antiga a muito adormecida, a eletrônica! De lá para cá, fiz vários outros cursos, mas como o primeiro a gente nunca esquece……..

O curso foi: EE40LX: Electronic Interfaces, através da plataforma EDX e ministrado pela Berkeley University, da California. A idéia foi uma revisão geral de eletrônica básica através de exercícios e experimentos, culminando em um Robot que obedecesse alguns requisitos básicos:

  • O robot deveria no mínimo:
    • Responder a luz
    • Produzir som
    • Responder ao som
    • Mover motores
  • Adicionalmente, incorporei ao projeto:
    • Produzir luz
    • Responder remotamente a comandos IR

O monstrengo final…..

MJRoBot I

Para ser aprovado, entreguei o vídeo abaixo aonde demonstro que o robot cumpria as especificações do curso:

Para a construção do robot, utilizei a lista de componentes abaixo:

Photo 1-11-16, 18 47 23

Para o coração (ou melhor, o cerebro….) do robot, utilizei o Arduino UNO. abaixo o diagrama de blocos com as respectivas pinagens. Para um projeto mais elaborado é fundamental desenvolver este tipo de diagrama. Ele vai sempre ser a guia a que se tem que recorrer durante a codificação do SW.

Photo 1-11-16, 18 46 08

O Hardware:

“Resposta a luz”

A base da “reação a luz”, foram as fotocélulas. As fotocélulas (que são resistores que variam com a luz), foram conectados na configuração “ponte de Whitestone”. Isso fazia que uma variação na intensidade de luz provocasse um desequilíbrio da ponte resistiva, o que levava a saturação de um amplificador operacional. Meio enrolado, mas muito inteligente (não eu, mas os caras de Berkley que sugeriram a solução 😉

Photo 1-11-16, 18 48 11

Outra sacada muito legal, foi o uso de um “Power Block”, ou seja, ao invés de deixar a ponte constantemente alimentada (importante lembrar que em um robot autônomo, bateria é vida!), se alimenta a mesma via um pino de saída do Arduino. Assim, somente quando se necessita verificar se o sensor tem luz ou não, 5V é produzido pelo Arduino, alimentando momentaneamente a ponte durante a leitura (no caso, o pino 8).

Foram utilizadas duas fotocelulas, uma frontal e uma traseira. A ação é simples, quando o robot de desloca para a frente e a luz é interrompida, os motores dão “marcha-ré”. E obviamente, vice-e-versa.

 

“Geração e resposta a som”

Para que o robot pudesse “ouvir”, um velho e bom microfone de PC foi o escolhido. Como o sinal do microfone é muito baixo, um Amplificador Operacional inversor foi utilizado para amplificação do sinal. Também antes de ser amplificado, o sinal de som passou por um filtro passa altas, eliminando-se assim a componente DC.

Para “falar”, foi utilizado um simples “buzzer”.

Photo 1-11-16, 18 48 00

“Mover motores”

Para o movimento dos motores uma Ponte H, a velha e boa L293D foi a escolhida. Importante não esquecer de adicionar uns capacitores cerâmicos nos terminais do motor. Isto ajudará a diminuir eventuais ruídos elétricos produzidos pelas “escovas” dos motores DC (10pF está bem). Ah! falando em ruído, nunca é demais lembrar que sempre é bom alimentar os motores com uma batería separada da usada pelo Arduíno (não se esquecendo de conectar os “terras”).Photo 1-11-16, 18 48 21

Para sinalização, utilizei um LED RGB catodo comum. Com isso, podia acompanhar algumas ações do robot através dos LEDs.

Para receber comandos via um controle remoto IR (Infra vermelho), utilizei um  VS1838b. É um sensor con tres terminais, VCC, GND e Signal. Um sensor simples e bem confiável.

Juntando tudo fica uma massaroca mais ou menos assim:

Photo 9-13-15, 21 05 28

O Software:

A idéia do SW foi bem simples. Ao ser ligado,  o robot gerava 4 bips, ficando a espera do sinal “ON” proveniente do controle remoto. Ao receber-lo, soavam 2 bips, o LED ficava azul e o robot estava pronto para receber um comando de voz. No caso um simples ruído mais pronunciado como um assovio ou uma palma (o ganho do Amp Op, deve ser testado para gerar um sinal coerente). Também é importante que durante a faze de “set-up”, se “escute” o nível de ruído do ambiente, assim consegue-se uma melhor precisão e o robot não parte com qualquer barulhinho.

Com o comando de som, o robot começava a mover-se para a frente (LED ficava verde) até que o sensor de luz frontal fosse bloqueado. Nesse momento, o LED ficava vermelho e o robot passava a mover-se de “marcha-ré”, até que o sensor de luz traseiro fosse bloqueado, invertendo-se assim o movimento.  O robot ficava nesse zigue-zague até receber um comando para parar (controle remoto), ou até que o “piloto” dormisse de tédio fazendo o monstrengo se arrebentar no chão (é, o teste foi em cima de uma mesa…..).

Abaixo, o fluxo do programa (dá para entender melhor que o meu Bla-bla-bla anterior 😉

Photo 1-11-16, 18 46 31

O codigo final do robot pode ser baixado de meu Dropbox público:

https://www.dropbox.com/sh/246l6yksl6fj0uw/AACsVcKSg5yIOohXSj6yuL63a?dl=0

That’s all Folks! Apenas um minuto de silencio para o velho e bom MJRoBot I, que hoje descansa em paz em minha gaveta de componentes e serve de partes para seu irmão mais novo (ou filho?), o MJR0Bot II!!!!!!! que aparecerá em uma nova entrada deste Blog.

Para matar a saudade fica umas fotinhos para lembrar a construção do rapaz!

Photo 1-11-16, 18 49 06

Ciao, bello! Hora de tomar um vinhozinho!

CONCLUSÃO

Como sempre, espero que este projeto ajude outras pessoas a encontrar seu caminho no apaixonante mundo da eletrônica, robótica e do IoT!

Não deixe de visitar e seguir minha página: MJRoBot.org no Facebook

“Saludos desde el sur del mundo!” 😉

Um abraço e até o próximo post!

Obrigado

Marcelo