Arduino: Ethernet: mudanças entre as edições

De Wiki Cursos IFPR Foz
Ir para navegaçãoIr para pesquisar
 
(50 revisões intermediárias pelo mesmo usuário não estão sendo mostradas)
Linha 1: Linha 1:
=Arduíno: Comunicação e Rede=
=Arduíno: Ethernet=
 
==Comunicação Serial==
 
===Conceitos sobre comunicação serial e paralela===
;[[Comunicação serial e paralela]]
 
===Comunicação Serial no Arduíno===
 
O '''Arduíno UNO''' possui uma '''porta serial''' ([https://www.arduino.cc/reference/en/language/functions/communication/serial/ '''Serial''']) (também referida como UART) e se comunica através dos pinos 0 ('''RX''') e 1 ('''TX'''), assim como com o computador via USB. Se você utiliza a comunicação serial não pode utilizar os pinos 0 e 1 como entradas e saídas.
 
Também é possível utilizar o '''monitor serial''', disponível na IDE do Arduíno, para comunicação bidirecional com uma placa Arduíno conectada em uma porta USB.
 
Não é possível utilizar as '''portas seriais''' do '''Arduíno''' diretamente em uma comunicação com uma '''interface RS232''', pois esta usa tensões de -12 V e 12 V.
 
;Outras placas Arduíno:
*O '''Arduíno Leonardo''' usa a '''Serial''' exclusivamente para comunicação com a '''porta USB'''. Para '''comunicação serial''' nos pinos 0 (RX) and 1 (TX) deve-se utilizar a '''Serial1'''.
*O '''Arduíno Mega''' tem três portas de '''comunicação serial''' adicionais: '''Serial1''',  '''Serial3''' e  '''Serial3'''.
 
===Laboratório 1: Comunicação serial entre dois Arduínos===
 
;Monitor Serial: O '''monitor serial''' permite enviar dados do '''computador''' ao '''Arduíno''' pela '''interface serial USB'''.
*Carregar programa exemplo '''[http://www.arduino.cc/en/Tutorial/PhysicalPixel Arquivo/Exemplos/Communication/PhysicalPixel]''' e '''acionar''' o '''led''' do '''pino 13''' a partir de comandos '''H''' e '''L''' enviados pelo '''monitor serial'''.
 
;Comunicação entre dois Arduínos:
:[[Arquivo:SerialArduino.jpg | 300px]]
*Conectar com um par de fios os dois Arduínos através das '''portas seriais''' de ambos os microcontroladores: TX->RX e RX<-TX;
*Carregar no '''receptor''' o programa exemplo '''[http://www.arduino.cc/en/Tutorial/PhysicalPixel Arquivo/Exemplos/Communication/PhysicalPixel]''';
*Carregar no '''emissor''' o código abaixo:
<syntaxhighlight lang="c">
//emissor 
int num = 0;
void setup(){
  Serial.begin(9600);
}
void loop(){
  Serial.write('H');
  delay(2000);
  Serial.write('L');
  delay(2000);
}
}
</syntaxhighlight>
*Observar a comunicação serial a partir do led piscando no receptor e também monitorar a troca de mensagens a partir do monitor serial.
 
===Configuração do SimulIDE para comunicação serial com Arduíno===
É possível realizar '''comunicação serial''' entre um '''Arduíno''' rodando no '''SinulIDE''' e um '''Arduíno''' conectado a porta '''USB''' do computador.
*No Arduíno conectado a '''USB''', verificar a partir da IDE a porta de comunicação que está sendo utilizada: '''ttyACM0''' (p.ex.);
*No Arduíno no '''SimulIDE''', clicar com o botão direito do mouse sobre a placa e selecionar '''Open Serial Port''';
*No bloco '''Uart''' que vai abrir, clicar com o botão direito do mouse e selecionar '''properties''';
*Escrever em '''port name''' o nome da porta serial;
*Clicar em '''Open''' para ativar a porta (deve indicar sucesso com o botão vermelho).


==Comunicação usando módulo Ethernet==
==Comunicação usando módulo Ethernet==
Linha 62: Linha 11:
Para uso do módulo Ethernet há uma serie de exemplos prontos ([https://www.arduino.cc/en/Tutorial/LibraryExamples Examples from Libraries]).
Para uso do módulo Ethernet há uma serie de exemplos prontos ([https://www.arduino.cc/en/Tutorial/LibraryExamples Examples from Libraries]).


===Labortório 2: Web Server===
===Laboratório 1: Web Server===
Este laboratório mostra como utilizar um '''Ethernet ''Shield''''' juntamente com o '''Arduíno''' para criar um '''Web Server''' que forneça informações sobre sensores conectados a entradas analógicas  <ref>https://www.arduino.cc/en/Tutorial/LibraryExamples/WebServer</ref>.
Este laboratório mostra como utilizar um '''Ethernet ''Shield''''' juntamente com o '''Arduíno''' para criar um '''Web Server''' que forneça informações sobre sensores conectados a entradas analógicas  <ref>https://www.arduino.cc/en/Tutorial/LibraryExamples/WebServer</ref>.


;Procedimentos:
;Procedimentos:
*Conectar o '''Shield Ethernet''' a placa Arduíno e a '''rede local''' (usando cabos de rede CAT 5/6 e conector RJ45);
#Conectar o '''Shield Ethernet''' a placa Arduíno e a '''rede local''' (usando cabos de rede CAT 5/6 e conector RJ45);
*Carregar o '''programa exemplo''': [https://www.arduino.cc/en/Tutorial/LibraryExamples/WebServer '''Arquivo/Exemplos/Ethernet/WebServer'''];
#Conectar alguns '''sensores''' as '''entradas analógicas''' do Arduíno para monitorar via Web (Pode Modificar o programa exemplo em função dos sensores que utilizar);
*Conectar alguns '''sensores''' as '''entradas analógicas''' do Arduíno para monitorar via Web (Pode Modificar o programa exemplo em função dos sensores que utilizar);
#Carregar o '''programa exemplo''': [https://www.arduino.cc/en/Tutorial/LibraryExamples/WebServer '''Arquivo/Exemplos/Ethernet/WebServer'''];
*Testar o acesso ao '''servidor Web''' a partir de um '''navegador'''.
#*'''Atenção''':
#**Configurar '''IP''' de acordo com a '''[[Rede Academica do Campus|Rede Acadêmica do Campus]]''';
#**Configurar '''MAC''' único para a rede local.
#*'''Sugestão''': Configurar último byte '''MAC''' com o número do Kit utilizado e o '''IP''' com 2xx, onde xx é o número do Kit utilizado.
#Testar a conectividade com o '''servidor Web''' com o aplicativo de rede '''ping''';
#Testar o acesso ao '''servidor Web''' a partir de um '''navegador'''.


====Análise do funcionamento do programa====
====Análise do funcionamento do programa Web Server====
;Código exemplo: <ref>https://www.arduino.cc/en/Tutorial/LibraryExamples</ref> Comentários traduzidos.
<syntaxhighlight lang="c">
<syntaxhighlight lang="c">
/*
/*
  Web Server<ref>https://www.arduino.cc/en/Tutorial/LibraryExamples</ref>
  Web Server
  Servidor Web simples que mostra os valores das entradas analógicas.
  Servidor Web simples que mostra os valores das entradas analógicas.
*/
*/
#include <SPI.h>
#include <SPI.h>
#include <Ethernet.h>
#include <Ethernet.h>
// Enter a MAC address and IP address for your controller below.
// Definição do endereço MAC:
// The IP address will be dependent on your local network:
// São 6 bytes em hexadecimal e deve ser único para a rede local.
byte mac[] = {
byte mac[] = {
   0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED
   0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED
};
};
IPAddress ip(192, 168, 1, 30);
// Definição do endereço IP fixo:
// Initialize the Ethernet server library
IPAddress ip(192, 168, 71, 2xx);
// with the IP address and port you want to use
// Inicialização do servidor e definição da porta para escuta
// (port 80 is default for HTTP):
// (porta 80 é default para HTTP):
EthernetServer server(80);
EthernetServer server(80);
void setup() {
void setup() {
   // Open serial communications and wait for port to open:
   // Inicialização da serial
   Serial.begin(9600);
   Serial.begin(9600);
   while (!Serial) {
   while (!Serial) {
     ; // wait for serial port to connect. Needed for native USB port only
     ; // Espera serial conectar.  
   }
   }
   Serial.println("Ethernet WebServer Example");
   Serial.println("Ethernet WebServer Example");
   // start the Ethernet connection and the server:
   // Inicialização da conexão Ethernet e do servidor:
   Ethernet.begin(mac, ip);
   Ethernet.begin(mac, ip);
   // Check for Ethernet hardware present
   // Checa se o hardware Ethernet está presente:
   if (Ethernet.hardwareStatus() == EthernetNoHardware) {
   if (Ethernet.hardwareStatus() == EthernetNoHardware) {
     Serial.println("Ethernet shield was not found.  Sorry, can't run without hardware. :(");
     Serial.println("Ethernet shield was not found:(");
     while (true) {
     while (true) {
       delay(1); // do nothing, no point running without Ethernet hardware
       delay(1); // Nada a fazer sem hardware Ethernet
     }
     }
   }
   }
Linha 108: Linha 63:
     Serial.println("Ethernet cable is not connected.");
     Serial.println("Ethernet cable is not connected.");
   }
   }
   // start the server
   // Inicialização do servidor
   server.begin();
   server.begin();
   Serial.print("server is at ");
   Serial.print("server is at ");
Linha 114: Linha 69:
}
}
void loop() {
void loop() {
   // listen for incoming clients
   // Escuta por clientes
   EthernetClient client = server.available();
   EthernetClient client = server.available();
   if (client) {
   if (client) {
     Serial.println("new client");
     Serial.println("new client");
     // an http request ends with a blank line
     // Requisições HTTP terminam com uma linha em branco
     boolean currentLineIsBlank = true;
     boolean currentLineIsBlank = true;
     while (client.connected()) {
     while (client.connected()) {
Linha 124: Linha 79:
         char c = client.read();
         char c = client.read();
         Serial.write(c);
         Serial.write(c);
         // if you've gotten to the end of the line (received a newline
         // Se chegou no final da linha (recebeu caractere: newline)
         // character) and the line is blank, the http request has ended,
         // e a linha é vazia, a requisição HTTP terminou,
         // so you can send a reply
         // portando, envia resposta:
         if (c == '\n' && currentLineIsBlank) {
         if (c == '\n' && currentLineIsBlank) {
           // send a standard http response header
           // Envia cabeçalho da resposta HTTP
           client.println("HTTP/1.1 200 OK");
           client.println("HTTP/1.1 200 OK");
           client.println("Content-Type: text/html");
           client.println("Content-Type: text/html");
           client.println("Connection: close");  // the connection will be closed after completion of the response
           client.println("Connection: close");  // fecha a conexão após resposta
           client.println("Refresh: 5");  // refresh the page automatically every 5 sec
           client.println("Refresh: 5");  // atualiza página a cada 5 s
           client.println();
           client.println();
           client.println("<!DOCTYPE HTML>");
           client.println("<!DOCTYPE HTML>");
           client.println("<html>");
           client.println("<html>");
           // output the value of each analog input pin
           // Imprime a saída de cada porta analógica
           for (int analogChannel = 0; analogChannel < 6; analogChannel++) {
           for (int analogChannel = 0; analogChannel < 6; analogChannel++) {
             int sensorReading = analogRead(analogChannel);
             int sensorReading = analogRead(analogChannel);
Linha 149: Linha 104:
         }
         }
         if (c == '\n') {
         if (c == '\n') {
           // you're starting a new line
           // Se está iniciando nova linha
           currentLineIsBlank = true;
           currentLineIsBlank = true;
         } else if (c != '\r') {
         } else if (c != '\r') {
           // you've gotten a character on the current line
           // Se recebeu novo caractere na nova linha
           currentLineIsBlank = false;
           currentLineIsBlank = false;
         }
         }
       }
       }
     }
     }
     // give the web browser time to receive the data
     // Tempo para processar o dado
     delay(1);
     delay(1);
     // close the connection:
     // Fecha a conexão:
     client.stop();
     client.stop();
     Serial.println("client disconnected");
     Serial.println("client disconnected");
Linha 166: Linha 121:
</syntaxhighlight>
</syntaxhighlight>


===Labortório 3: DHCP Address Print===
;Comentários e complementos sobre a requisição HTTP:
*'''[[Protocolo HTTP]]''': Veja formato da mensagem de requisição HTTP;
*O programa não faz checagem do '''método''' (GET, PUT, POST, ... ) recebido na mensagem de requisição (aceita qualquer coisa, mesmo mensagem vazia).
 
===Laboratório 2: Análise do Web Server com Wireshark===
Ativar análise de pacotes com '''Wireshark''' utilizando filtro para IP e TCP porta 80:
ip.addr == 192.168.71.2xx and tcp.port == 80
Obs: Fechar outras janelas de navegador que estejam ativas no computador;
 
;Análise de interação com navegador:
Utilizar '''navegador''' para acessar '''servidor Web''' rodando no '''Arduíno''' e analisar pacotes com '''Wireshark'''.
 
Procedimentos:
#Abrir navegador a acessar IP do Servidor Web;
#Acompanhar mensagens no monitor serial do Arduíno;
#Acompanhar dados recebidos pelo no navegador;
#Identificar no Wireshark as mensagens de abertura e fechamento de conexão TCP;
#Identificar no Wireshark as mensagens HTTP com troca de informações e os reconhecimentos enviados pelo TCP.
 
;Análise de interação com telnet:
Iniciar uma nova captura de pacotes com o Wiewshark.
 
Acessar '''servidor Web''' rodando no '''Arduíno''' com '''telnet''' na '''porta 80''' e analisar pacotes com '''Wireshark''':
telnet 192.168.71.2xx 80
 
Procedimentos:
#Acompanhar mensagens no monitor serial do Arduíno;
#Acompanhar dados recebidos pelo terminal telnet;
#Identificar no Wireshark as mensagens de abertura de conexão TCP;
#Digitar uma sequência de caracteres: GET (ou outra qualquer);
#*Acompanhar mensagens no monitor serial do Arduíno;
#*Acompanhar dados recebidos pelo telnet;
#*Identificar no Wireshark as mensagens trocadas;
#Enviar linha vazia CRLF (Enter):
#*Acompanhar mensagens no monitor serial do Arduíno;
#*Acompanhar dados recebidos pelo telnet;
#*Identificar no Wireshark as mensagens trocadas e o encerramento da conexão TCP.
 
;Análise de interação com curl:
Repetir procedimentos acessando '''servidor Web''' rodando no '''Arduíno''' com '''curl''' e analisar pacotes com '''Wireshark''':
curl 192.168.71.2xx
 
===Laboratório 3: DHCP Address Print===
Este laboratório mostra como configurar o arduíno para obter endereço IP dinamicamente com DHCP. O endereço obtido é impresso no monitor serial.  <ref>https://www.arduino.cc/en/Tutorial/LibraryExamples/DhcpAddressPrinter</ref>.
Este laboratório mostra como configurar o arduíno para obter endereço IP dinamicamente com DHCP. O endereço obtido é impresso no monitor serial.  <ref>https://www.arduino.cc/en/Tutorial/LibraryExamples/DhcpAddressPrinter</ref>.


;Procedimentos:
;Procedimentos:
*Conectar o '''Shield Ethernet''' a placa Arduíno e a '''rede local''' (usando cabos de rede CAT 5/6 e conector RJ45);
#Conectar o '''Shield Ethernet''' a placa Arduíno e a '''rede local''' (usando cabos de rede CAT 5/6 e conector RJ45);
*Carregar o '''programa exemplo''': [https://www.arduino.cc/en/Tutorial/LibraryExamples/DhcpAddressPrinter '''Arquivo/Exemplos/Ethernet/DhcpAddressPrinter'''];
#Carregar o '''programa exemplo''': [https://www.arduino.cc/en/Tutorial/LibraryExamples/DhcpAddressPrinter '''Arquivo/Exemplos/Ethernet/DhcpAddressPrinter'''];
*Rodar o programa e observar no '''monitor serial''' o endereço IP obtido por '''DCHP'''.
#Rodar o programa e observar no '''monitor serial''' o endereço IP obtido por '''DCHP''';
#Testar a conectividade com o aplicativo de rede '''ping'''.


===Labortório 4: Consulta a Servidor de Data/Hora===
===Laboratório 4: Consulta a Servidor de Data/Hora===
Este laboratório mostra como utilizar um '''Ethernet ''Shield''''' para o '''Arduíno''' obter. por meio de uma requisição '''UDP''', a '''dada e hora''' de um servidor da Internet por meio do '''protocolo NTP''' (''Network Time Protocol'') <ref>https://www.arduino.cc/en/Tutorial/LibraryExamples/WebServer</ref>. Neste exemplo o Arduíno recebe endereço IP dinamicamente de um servidor '''DHCP'''.
Este laboratório mostra como utilizar um '''Ethernet ''Shield''''' para o '''Arduíno''' obter. por meio de uma requisição '''UDP''', a '''dada e hora''' de um servidor da Internet por meio do '''protocolo NTP''' (''Network Time Protocol'') <ref>https://www.arduino.cc/en/Tutorial/LibraryExamples/WebServer</ref>. Neste exemplo o Arduíno recebe endereço IP dinamicamente de um servidor '''DHCP'''.


;Procedimentos:
;Procedimentos:
*Conectar o '''Shield Ethernet''' a placa Arduíno e a '''rede local''' (usando cabos de rede CAT 5/6 e conector RJ45);
#Conectar o '''Shield Ethernet''' a placa Arduíno e a '''rede local''' (usando cabos de rede CAT 5/6 e conector RJ45);
*Carregar o '''programa exemplo''': [https://www.arduino.cc/en/Tutorial/LibraryExamples/UdpNtpClient '''Arquivo/Exemplos/Ethernet/UdpNtpClient'''];
#Carregar o '''programa exemplo''': [https://www.arduino.cc/en/Tutorial/LibraryExamples/UdpNtpClient '''Arquivo/Exemplos/Ethernet/UdpNtpClient'''];
*Testar o programa e acompanhar pelo '''monitor serial''' a data e hora obtida.
#Testar o programa e acompanhar pelo '''monitor serial''' a data e hora obtida.
*Pesquisar e testar consulta a servidores NTP no Brasil.
#Pesquisar e testar consulta a servidores NTP no Brasil.


==Cartão SD do módulo Ethernet==
==Cartão SD do módulo Ethernet==
Linha 189: Linha 187:
A comunicação entre o microcontrolador e o cartão SD  usa o barramento SPI, que faz uso dos pinos 10, 11, 12 e 13 do Arduíno. O pino 4 é usado também para controlar a seleção do cartão SD.
A comunicação entre o microcontrolador e o cartão SD  usa o barramento SPI, que faz uso dos pinos 10, 11, 12 e 13 do Arduíno. O pino 4 é usado também para controlar a seleção do cartão SD.


===Labortório 5: Escrita e litura no cartão SD===
===Laboratório 5: Escrita e leitura no cartão SD===
Este laboratório mostra como utilizar o '''cartão SD''' para escrita e leitura de dados em um arquivo.
Este laboratório mostra como utilizar o '''cartão SD''' para escrita e leitura de dados em um arquivo.


;Procedimentos:
;Procedimentos:
*Conectar o '''Shield Ethernet''' a placa Arduíno e inserir um '''cartão SD''' no módulo;
#Conectar o '''Shield Ethernet''' a placa Arduíno e inserir um '''cartão SD''' no módulo;
*Carregar o '''programa exemplo''': [https://www.arduino.cc/en/Tutorial/LibraryExamples/ReadWrite '''Arquivo/Exemplos/SD/ReadWrite'''];
#Carregar o '''programa exemplo''': [https://www.arduino.cc/en/Tutorial/LibraryExamples/ReadWrite '''Arquivo/Exemplos/SD/ReadWrite'''];
*Testar o programa e acompanhar pelo '''monitor serial''' o processo de escrita e leitura.
#Testar o programa e acompanhar pelo '''monitor serial''' o processo de escrita e leitura.


===Labortório 6: Armazenamento de dados de sensores em cartão SD===
===Laboratório 6: Armazenamento de dados de sensores em cartão SD===
Este laboratório mostra como utilizar o '''cartão SD''' para armazenamento de dados de sensores em um arquivo.
Este laboratório mostra como utilizar o '''cartão SD''' para armazenamento de dados de sensores em um arquivo.


;Procedimentos:
;Procedimentos:
*Conectar o '''Shield Ethernet''' a placa Arduíno e inserir um '''cartão SD''' no módulo;
#Conectar o '''Shield Ethernet''' a placa Arduíno e inserir um '''cartão SD''' no módulo;
*Conectar ao Arduíno três '''sensores''' para leitura pelas entradas '''analógicas''';
#Conectar ao Arduíno três '''sensores''' para leitura pelas entradas '''analógicas''';
*Carregar o '''programa exemplo''': [https://www.arduino.cc/en/Tutorial/LibraryExamples/Datalogger '''Arquivo/Exemplos/SD/Datalogger'''];
#Carregar o '''programa exemplo''': [https://www.arduino.cc/en/Tutorial/LibraryExamples/Datalogger '''Arquivo/Exemplos/SD/Datalogger'''];
*Adaptar o programa exemplo para os sensores conectados.
#Adaptar o programa exemplo para os sensores conectados.


==Projeto: Servidor Web com armazenamento de dados em cartão SD==
==Projeto: Servidor Web com armazenamento de dados em cartão SD==
Linha 210: Linha 208:
Construa um '''servidor Web''' rodando em um '''Arduíno''', capaz de ler periodicamente um '''sensor de temperatura''' e, a cada leitura, armazenar os dados como uma linha de um arquivo em '''cartão SD'''. Os dados de cada leitura do sensor devem ser acompanhados da '''data e hora''' consultadas em um '''servidor NTP'''.  
Construa um '''servidor Web''' rodando em um '''Arduíno''', capaz de ler periodicamente um '''sensor de temperatura''' e, a cada leitura, armazenar os dados como uma linha de um arquivo em '''cartão SD'''. Os dados de cada leitura do sensor devem ser acompanhados da '''data e hora''' consultadas em um '''servidor NTP'''.  


A cada acesso ao '''servidor Web''' através de um '''navegador''', o servidor deve fornecer as '''cinco últimas leituras''' dos dados do '''sensor de temperatura'''.
A cada acesso ao '''servidor Web''' através de um '''navegador''', o servidor deve fornecer as '''leituras''' dos dados do '''sensor de temperatura'''.


Obs:  
Obs:  
*O programa para o servidor Web pode combinar vários dos exemplos vistos nos laboratórios.
*O programa para o servidor Web pode combinar vários dos exemplos vistos nos laboratórios.
*Consulte outros programas exemplos das bibliotecas '''Ethernet''' e '''SD'''.
*Consulte outros programas exemplos das bibliotecas '''Ethernet''' e '''SD'''.
==Comunicação com Módulo Bluetooth==
O '''módulo Bluetooth''' permite interagir com o Arduíno, por exemplo, utilizando um aplicativo em um smartphone.
Um módulo Bluetooth bastante utilizado é o HC06:
[[Arquivo:Bleutooth-HC06.png|300px]]
===Pinagem e conexão com o Arduíno===
Este módulo apresenta 6 pinos, mas com apenas 4 pinos é possível colocar o mesmo para funcionar e fazer o Arduíno interagir dispositivos Bluetooth.
            _________
            |        |
            |        |
            |        |
            |Bleutooth|
            |        |
            |  HC06  |
            |        |
            |        |
            |_________|
              | | | |
      Vcc ----+ | | +---- Txd
      Gnd ------+ +------ Rxd
;Cuidados com a conexão do módulo Bluetooth HC06 com o Arduíno:
*O HC06 funciona com alimentação '''Vcc=3,3V''', a qual também é fornecida pelo Arduino ao lado da alimentação de 5V;
*Na comunicação serial, como o Arduíno fornece 5V, é necessário utilizar um '''[http://200.17.101.9/wiki/index.php/Resistores#Divisor_de_Tens.C3.A3o divisor de tensão]''' na entrada Rxd do HC06, conforme exemplo abaixo:
[[Arquivo:DivisorTensao-Bleutooth.png]]
V<sub>Rxd</sub> = R2/(R1 + R2).5
:Exemplo:
R1=470 &Omega;, R2=1 K&Omega; -> V<sub>Rxd</sub> = 3,4 V
===Laboratório 7: Comunicação serial entre Arduíno com módulo Bluetooth e Android===
Permite acender e apagar led a partir de aplicativo '''Android''' pareado com módulo '''Bluetooth''' rodando em um Arduíno:
;Procedimentos:
*Carregar programa exemplo '''[http://www.arduino.cc/en/Tutorial/PhysicalPixel Arquivo/Exemplos/Communication/PhysicalPixel]''';
*Instalar em um dispositivo Android o aplicativo '''Bluetooth Terminal''';
*Abrir aplicativo '''Bluetooth Terminal''' e '''parear''' com módulo Bluetooth;
*Enviar a partir do '''Bluetooth Terminal''' os caracteres '''H''' e '''L''' para acender a apagar o led 13 do Arduíno.
===Laboratório 8: Comunicação serial entre Arduíno com módulo Bluetooth e Android===
Permite enviar uma string ao '''Arduíno''' via Bluetooth e receber de volta a mesma      string no '''monitor serial''' <ref>http://www.instructables.com/id/Add-bluetooth-to-your-Arduino-project-ArduinoHC-06</ref>.
;Procedimentos:
*Carregarno Arduíno o programa exemplo:
<syntaxhighlight lang="c">
String message; //string that stores the incoming message
void setup()
{
  Serial.begin(9600); //set baud rate
}
void loop()
{
  while(Serial.available())
  {//while there is data available on the serial monitor
    message+=char(Serial.read());//store string from serial command
  }
  if(!Serial.available())
  {
    if(message!="")
    {//if data is available
      Serial.println(message); //show the data
      message=""; //clear the data
    }
  }
  delay(1000); //delay
}
</syntaxhighlight>
*Enviar strings pelo '''Bluetooth Terminal''' no Android e visualizar o retorno do dado no monitor do terminal.
===''Smartphone'' Android===
Para enviar caracteres de um '''''Smartphone'' Android''' para o módulo '''Bluetooth''' pode-se utilizar aplicativos como o [https://play.google.com/store/apps/details?id=com.ucconnect.ucbtadapter_hex&hl=pt-BR Bluetooth Serial Port Terminal] ou [https://play.google.com/store/apps/details?id=project.bluetoothterminal&hl=pt-BR Bluetooth V2.1 SPP Terminal]


==Referências==
==Referências==
Linha 296: Linha 218:


----
----
[[Usuário:Evandro.cantu|Evandro.cantu]] ([[Usuário Discussão:Evandro.cantu|discussão]]) 19h13min de 29 de outubro de 2021 (-03)
[[Usuário:Evandro.cantu|Evandro.cantu]] ([[Usuário Discussão:Evandro.cantu|discussão]]) 16h26min de 20 de junho de 2023 (-03)
----
----


[[Categoria:Arduíno]] [[Categoria:IoT]]
[[Categoria:Arduíno]] [[Categoria:IoT]]

Edição atual tal como às 00h50min de 21 de junho de 2023

Arduíno: Ethernet

Comunicação usando módulo Ethernet

O módulo Ethernet (Ethernet Shield), juntamente com a biblioteca Ethernet.h, permite que um Arduíno se conecte a Internet. Esta biblioteca provê funcionalidades tanto para cliente quanto par servidor, além de permitir a conexão com a rede local tanto usando IP fixo, DHCP e também usando DNS.

O Ethernet Shield 2 permite conectar o Arduíno a rede local e a Internet com conector RJ45 e velocidade de 10/100 Mbps. A conexão do shield com o Arduíno é realizada pelo barramento SPI (Serial Peripheral Interface), que faz uso dos pinos 10, 11, 12 e 13 do Arduíno para comunicação e necessita da biblioteca SPI.h. O SPI é uma interface de comunicação serial síncrona usada para comunicação em distâncias curtas. O Ethernet Shield possui ainda um slot para cartão SD e usa o pino 4 para controlar o pino de seleção do cartão SD.

Para uso do módulo Ethernet há uma serie de exemplos prontos (Examples from Libraries).

Laboratório 1: Web Server

Este laboratório mostra como utilizar um Ethernet Shield juntamente com o Arduíno para criar um Web Server que forneça informações sobre sensores conectados a entradas analógicas [1].

Procedimentos
  1. Conectar o Shield Ethernet a placa Arduíno e a rede local (usando cabos de rede CAT 5/6 e conector RJ45);
  2. Conectar alguns sensores as entradas analógicas do Arduíno para monitorar via Web (Pode Modificar o programa exemplo em função dos sensores que utilizar);
  3. Carregar o programa exemplo: Arquivo/Exemplos/Ethernet/WebServer;
    • Atenção:
    • Sugestão: Configurar último byte MAC com o número do Kit utilizado e o IP com 2xx, onde xx é o número do Kit utilizado.
  4. Testar a conectividade com o servidor Web com o aplicativo de rede ping;
  5. Testar o acesso ao servidor Web a partir de um navegador.

Análise do funcionamento do programa Web Server

Código exemplo
[2] Comentários traduzidos.
/*
 Web Server
 Servidor Web simples que mostra os valores das entradas analógicas.
*/
#include <SPI.h>
#include <Ethernet.h>
// Definição do endereço MAC:
// São 6 bytes em hexadecimal e deve ser único para a rede local.
byte mac[] = {
  0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED
};
// Definição do endereço IP fixo:
IPAddress ip(192, 168, 71, 2xx);
// Inicialização do servidor e definição da porta para escuta 
// (porta 80 é default para HTTP):
EthernetServer server(80);
void setup() {
  // Inicialização da serial
  Serial.begin(9600);
  while (!Serial) {
    ; // Espera serial conectar. 
  }
  Serial.println("Ethernet WebServer Example");
  // Inicialização da conexão Ethernet e do servidor:
  Ethernet.begin(mac, ip);
  // Checa se o hardware Ethernet está presente:
  if (Ethernet.hardwareStatus() == EthernetNoHardware) {
    Serial.println("Ethernet shield was not found:(");
    while (true) {
      delay(1); // Nada a fazer sem hardware Ethernet
    }
  }
  if (Ethernet.linkStatus() == LinkOFF) {
    Serial.println("Ethernet cable is not connected.");
  }
  // Inicialização do servidor
  server.begin();
  Serial.print("server is at ");
  Serial.println(Ethernet.localIP());
}
void loop() {
  // Escuta por clientes
  EthernetClient client = server.available();
  if (client) {
    Serial.println("new client");
    // Requisições HTTP terminam com uma linha em branco
    boolean currentLineIsBlank = true;
    while (client.connected()) {
      if (client.available()) {
        char c = client.read();
        Serial.write(c);
        // Se chegou no final da linha (recebeu caractere: newline)
        // e a linha é vazia, a requisição HTTP terminou,
        // portando, envia resposta:
        if (c == '\n' && currentLineIsBlank) {
          // Envia cabeçalho da resposta HTTP 
          client.println("HTTP/1.1 200 OK");
          client.println("Content-Type: text/html");
          client.println("Connection: close");  // fecha a conexão após resposta
          client.println("Refresh: 5");  // atualiza página a cada 5 s
          client.println();
          client.println("<!DOCTYPE HTML>");
          client.println("<html>");
          // Imprime a saída de cada porta analógica
          for (int analogChannel = 0; analogChannel < 6; analogChannel++) {
            int sensorReading = analogRead(analogChannel);
            client.print("analog input ");
            client.print(analogChannel);
            client.print(" is ");
            client.print(sensorReading);
            client.println("<br />");
          }
          client.println("</html>");
          break;
        }
        if (c == '\n') {
          // Se está iniciando nova linha
          currentLineIsBlank = true;
        } else if (c != '\r') {
          // Se recebeu novo caractere na nova linha
          currentLineIsBlank = false;
        }
      }
    }
    // Tempo para processar o dado
    delay(1);
    // Fecha a conexão:
    client.stop();
    Serial.println("client disconnected");
  }
}
Comentários e complementos sobre a requisição HTTP
  • Protocolo HTTP: Veja formato da mensagem de requisição HTTP;
  • O programa não faz checagem do método (GET, PUT, POST, ... ) recebido na mensagem de requisição (aceita qualquer coisa, mesmo mensagem vazia).

Laboratório 2: Análise do Web Server com Wireshark

Ativar análise de pacotes com Wireshark utilizando filtro para IP e TCP porta 80: 

ip.addr == 192.168.71.2xx and tcp.port == 80

Obs: Fechar outras janelas de navegador que estejam ativas no computador;

Análise de interação com navegador

Utilizar navegador para acessar servidor Web rodando no Arduíno e analisar pacotes com Wireshark.

Procedimentos:

  1. Abrir navegador a acessar IP do Servidor Web;
  2. Acompanhar mensagens no monitor serial do Arduíno;
  3. Acompanhar dados recebidos pelo no navegador;
  4. Identificar no Wireshark as mensagens de abertura e fechamento de conexão TCP;
  5. Identificar no Wireshark as mensagens HTTP com troca de informações e os reconhecimentos enviados pelo TCP.
Análise de interação com telnet

Iniciar uma nova captura de pacotes com o Wiewshark.

Acessar servidor Web rodando no Arduíno com telnet na porta 80 e analisar pacotes com Wireshark: 

telnet 192.168.71.2xx 80

Procedimentos:

  1. Acompanhar mensagens no monitor serial do Arduíno;
  2. Acompanhar dados recebidos pelo terminal telnet;
  3. Identificar no Wireshark as mensagens de abertura de conexão TCP;
  4. Digitar uma sequência de caracteres: GET (ou outra qualquer);
    • Acompanhar mensagens no monitor serial do Arduíno;
    • Acompanhar dados recebidos pelo telnet;
    • Identificar no Wireshark as mensagens trocadas;
  5. Enviar linha vazia CRLF (Enter):
    • Acompanhar mensagens no monitor serial do Arduíno;
    • Acompanhar dados recebidos pelo telnet;
    • Identificar no Wireshark as mensagens trocadas e o encerramento da conexão TCP.
Análise de interação com curl

Repetir procedimentos acessando servidor Web rodando no Arduíno com curl e analisar pacotes com Wireshark: 

curl 192.168.71.2xx

Laboratório 3: DHCP Address Print

Este laboratório mostra como configurar o arduíno para obter endereço IP dinamicamente com DHCP. O endereço obtido é impresso no monitor serial. [3].

Procedimentos
  1. Conectar o Shield Ethernet a placa Arduíno e a rede local (usando cabos de rede CAT 5/6 e conector RJ45);
  2. Carregar o programa exemplo: Arquivo/Exemplos/Ethernet/DhcpAddressPrinter;
  3. Rodar o programa e observar no monitor serial o endereço IP obtido por DCHP;
  4. Testar a conectividade com o aplicativo de rede ping.

Laboratório 4: Consulta a Servidor de Data/Hora

Este laboratório mostra como utilizar um Ethernet Shield para o Arduíno obter. por meio de uma requisição UDP, a dada e hora de um servidor da Internet por meio do protocolo NTP (Network Time Protocol) [4]. Neste exemplo o Arduíno recebe endereço IP dinamicamente de um servidor DHCP.

Procedimentos
  1. Conectar o Shield Ethernet a placa Arduíno e a rede local (usando cabos de rede CAT 5/6 e conector RJ45);
  2. Carregar o programa exemplo: Arquivo/Exemplos/Ethernet/UdpNtpClient;
  3. Testar o programa e acompanhar pelo monitor serial a data e hora obtida.
  4. Pesquisar e testar consulta a servidores NTP no Brasil.

Cartão SD do módulo Ethernet

O Ethernet Shield 2 possui um slot para cartão SD que pode ser utilizado para gravação e leitura de dados com ajuda da biblioteca SD. A biblioteca usa nomes curtos 8.3 para arquivos (8 caracteres para o nome do arquivo e 3 para extensão) e o diretório de trabalho é sempre a raiz do cartão SD.

A comunicação entre o microcontrolador e o cartão SD usa o barramento SPI, que faz uso dos pinos 10, 11, 12 e 13 do Arduíno. O pino 4 é usado também para controlar a seleção do cartão SD.

Laboratório 5: Escrita e leitura no cartão SD

Este laboratório mostra como utilizar o cartão SD para escrita e leitura de dados em um arquivo.

Procedimentos
  1. Conectar o Shield Ethernet a placa Arduíno e inserir um cartão SD no módulo;
  2. Carregar o programa exemplo: Arquivo/Exemplos/SD/ReadWrite;
  3. Testar o programa e acompanhar pelo monitor serial o processo de escrita e leitura.

Laboratório 6: Armazenamento de dados de sensores em cartão SD

Este laboratório mostra como utilizar o cartão SD para armazenamento de dados de sensores em um arquivo.

Procedimentos
  1. Conectar o Shield Ethernet a placa Arduíno e inserir um cartão SD no módulo;
  2. Conectar ao Arduíno três sensores para leitura pelas entradas analógicas;
  3. Carregar o programa exemplo: Arquivo/Exemplos/SD/Datalogger;
  4. Adaptar o programa exemplo para os sensores conectados.

Projeto: Servidor Web com armazenamento de dados em cartão SD

Construa um servidor Web rodando em um Arduíno, capaz de ler periodicamente um sensor de temperatura e, a cada leitura, armazenar os dados como uma linha de um arquivo em cartão SD. Os dados de cada leitura do sensor devem ser acompanhados da data e hora consultadas em um servidor NTP.

A cada acesso ao servidor Web através de um navegador, o servidor deve fornecer as leituras dos dados do sensor de temperatura.

Obs:

  • O programa para o servidor Web pode combinar vários dos exemplos vistos nos laboratórios.
  • Consulte outros programas exemplos das bibliotecas Ethernet e SD.

Referências

  1. ↑ https://www.arduino.cc/en/Tutorial/LibraryExamples/WebServer
  2. ↑ https://www.arduino.cc/en/Tutorial/LibraryExamples
  3. ↑ https://www.arduino.cc/en/Tutorial/LibraryExamples/DhcpAddressPrinter
  4. ↑ https://www.arduino.cc/en/Tutorial/LibraryExamples/WebServer

Evandro.cantu (discussão) 16h26min de 20 de junho de 2023 (-03)

Disponível em “http://wiki.foz.ifpr.edu.br/wiki/index.php?title=Arduino:_Ethernet&oldid=30519”