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

De Wiki Cursos IFPR Foz
Ir para navegaçãoIr para pesquisar
 
(85 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==
==Comunicação usando módulo Ethernet==


;Conceitos sobre comunicação serial e paralela:  
O módulo '''Ethernet''' ('''Ethernet ''Shield'''''), juntamente com a '''[https://www.arduino.cc/reference/en/libraries/ethernet/ 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'''.
*'''[[Comunicação serial e paralela]]'''


===Comunicação Serial no Arduíno===
[[Arquivo:Arduino_Ethernet_Shield.jpg|300px]]


Veja referência sobre comunicação [https://www.arduino.cc/reference/en/language/functions/communication/serial/ '''Serial'''] no Arduíno.
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.


O '''Arduíno UNO''' possui uma '''porta 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.
Para uso do módulo Ethernet há uma serie de exemplos prontos ([https://www.arduino.cc/en/Tutorial/LibraryExamples Examples from Libraries]).


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.
===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>.


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.
;Procedimentos:
 
#Conectar o '''Shield Ethernet''' a placa Arduíno e a '''rede local''' (usando cabos de rede CAT 5/6 e conector RJ45);
;Outras placas Arduíno:  
#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);
*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'''.
#Carregar o '''programa exemplo''': [https://www.arduino.cc/en/Tutorial/LibraryExamples/WebServer '''Arquivo/Exemplos/Ethernet/WebServer'''];
*O '''Arduíno Mega''' tem três portas de '''comunicação serial''' adicionais: '''Serial1''',  '''Serial3''' e  '''Serial3'''.
#*'''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'''.


===Laboratório 1: Comunicação serial entre dois Arduínos===
====Análise do funcionamento do programa Web Server====
 
;Código exemplo: <ref>https://www.arduino.cc/en/Tutorial/LibraryExamples</ref> Comentários traduzidos.
;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">
<syntaxhighlight lang="c">
  //emissor 
/*
int num = 0;
  Web Server
void setup(){
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);
   Serial.begin(9600);
}
  while (!Serial) {
void loop(){
    ; // Espera serial conectar.
   Serial.write('H');
  }
  delay(2000);
  Serial.println("Ethernet WebServer Example");
  Serial.write('L');
  // Inicialização da conexão Ethernet e do servidor:
  delay(2000);
  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");
  }
}
</syntaxhighlight>
</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====
;Comentários e complementos sobre a requisição HTTP:
É possível realizar '''comunicação serial''' entre um '''Arduíno''' rodando no '''SinulIDE''' e um '''Arduíno''' conectado a porta '''USB''' do computador.
*'''[[Protocolo HTTP]]''': Veja formato da mensagem de requisição HTTP;
*No Arduíno conectado a '''USB''', verificar a partir da IDE a porta de comunicação que está sendo utilizada: '''ttyACM0''' (p.ex.);
*O programa não faz checagem do '''método''' (GET, PUT, POST, ... ) recebido na mensagem de requisição (aceita qualquer coisa, mesmo mensagem vazia).
*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==
===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;


O módulo '''Ethernet''' ('''Ethernet ''Shield'''''), juntamente com a '''biblioteca Ethernet''' <ref>https://www.arduino.cc/reference/en/libraries/ethernet/</ref>, 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'''.
;Análise de interação com navegador:
Utilizar '''navegador''' para acessar '''servidor Web''' rodando no '''Arduíno''' e analisar pacotes com '''Wireshark'''.


[[Arquivo:Arduino_Ethernet_Shield.jpg|300px]]
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.


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.
;Análise de interação com telnet:
Iniciar uma nova captura de pacotes com o Wiewshark.


Para uso do módulo Ethernet há uma serie de exemplos prontos ([https://www.arduino.cc/en/Tutorial/LibraryExamples Examples from Libraries]).
Acessar '''servidor Web''' rodando no '''Arduíno''' com '''telnet''' na '''porta 80''' e analisar pacotes com '''Wireshark''':
telnet 192.168.71.2xx 80


===Labortório 2: Web Server===
Procedimentos:
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>.
#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.


;Procedimentos:
;Análise de interação com curl:
*Conectar o '''Shield Ethernet''' a placa Arduíno e a '''rede local''' (usando cabos de rede CAT 5/6 e conector RJ45);
Repetir procedimentos acessando '''servidor Web''' rodando no '''Arduíno''' com '''curl''' e analisar pacotes com '''Wireshark''':
*Carregar o '''programa exemplo''':[https://www.arduino.cc/en/Tutorial/LibraryExamples/WebServer Arquivo/Exemplos/Ethernet/Web Server];
curl 192.168.71.2xx
*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);
*Testar o acesso ao '''servidor Web''' a partir de um '''navegador'''.


==Cartão SD do módulo Ethernet==
===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>.


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.
;Procedimentos:
#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'''];
#Rodar o programa e observar no '''monitor serial''' o endereço IP obtido por '''DCHP''';
#Testar a conectividade com o aplicativo de rede '''ping'''.


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.
===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'''.


==Comunicação com Módulo Bluetooth==
;Procedimentos:
#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'''];
#Testar o programa e acompanhar pelo '''monitor serial''' a data e hora obtida.
#Pesquisar e testar consulta a servidores NTP no Brasil.


O '''módulo Bluetooth''' permite interagir com o Arduíno, por exemplo, utilizando um aplicativo em um smartphone.
==Cartão SD do módulo Ethernet==


Um módulo Bluetooth bastante utilizado é o HC06 (ver: http://www.instructables.com/id/Add-bluetooth-to-your-Arduino-project-ArduinoHC-06):
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.


[[Arquivo:Bleutooth-HC06.png|300px]]
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.


===Pinagem e conexão com o Arduíno===
===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 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.
;Procedimentos:
            _________
#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'''];
            |        |
#Testar o programa e acompanhar pelo '''monitor serial''' o processo de escrita e leitura.
            |        |
            |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


===Teste do módulo bluetooth===
===Laboratório 6: Armazenamento de dados de sensores em cartão SD===
;PhysicalPixel: Permite acender e apagar led a partir de aplicativo '''Android''' pareado com módulo '''Bluetooth''':
Este laboratório mostra como utilizar o '''cartão SD''' para armazenamento de dados de sensores em um arquivo.
:*Carregar no Arduíno o programa exemplo '''Arquivo/Exemplos/Communication/PhysicalPixel''';
:*Abrir aplicativo '''Bluetooth Terminal''' e '''parear''' com módulo Bluetooth;
:*Acender a apagar led 13 com caracteres '''H''' e '''L'''.


===Exemplos de programas de aplicação===
;Procedimentos:
Fonte: http://www.instructables.com/id/Add-bluetooth-to-your-Arduino-project-ArduinoHC-06
#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''';
;Echo Code: Permite enviar uma string ao '''Arduíno''' via Bluetooth e receber de volta a mesma      string no '''monitor serial'''.
#Carregar o '''programa exemplo''': [https://www.arduino.cc/en/Tutorial/LibraryExamples/Datalogger '''Arquivo/Exemplos/SD/Datalogger'''];
#Adaptar o programa exemplo para os sensores conectados.


<syntaxhighlight lang="c">
==Projeto: Servidor Web com armazenamento de dados em cartão SD==
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>


;Led Code: Permite acender e apagar um '''led''' conectado ao '''Arduíno''' enviando caracteres via '''Bluetooth''' de um '''''smartphone''''' ou outro dispositivo Bluetooth.
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'''.  
 
<syntaxhighlight lang="c">
char blueToothVal;          //value sent over via bluetooth
char lastValue;              //stores last state of device (on/off)
void setup()
{
  Serial.begin(9600);
  pinMode(13,OUTPUT);
}
void loop()
{
  if(Serial.available())
  {//if there is data being recieved
    blueToothVal=Serial.read(); //read it
  }
  if (blueToothVal=='n')
  {//if value from bluetooth serial is n
    digitalWrite(13,HIGH);            //switch on LED
    if (lastValue!='n')
      Serial.println(F("LED is on")); //print LED is on
    lastValue=blueToothVal;
  }
  else if (blueToothVal=='f')
  {//if value from bluetooth serial is n
    digitalWrite(13,LOW);            //turn off LED
    if (lastValue!='f')
      Serial.println(F("LED is off")); //print LED is on
    lastValue=blueToothVal;
  }
  delay(1000);
}
</syntaxhighlight>


===''Smartphone'' Android===
A cada acesso ao '''servidor Web''' através de um '''navegador''', o servidor deve fornecer as '''leituras''' dos dados do '''sensor de temperatura'''.
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]


;Arduíno Leonardo: O '''Arduíno Leonardo''' usa a '''Serial''' exclusivamente para comunicação com a '''porta USB'''. Para comunicação serial TTL (5V) nos pinos 0 (RX) and 1 (TX) deve-se utilizar a '''Serial1'''.
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==
==Referências==
Linha 189: 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”