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

De Wiki Cursos IFPR Foz
Ir para navegaçãoIr para pesquisar
 
(137 revisões intermediárias por 2 usuários não estão sendo mostradas)
Linha 1: Linha 1:
=Comunicação e Shields para Arduíno=
=Arduíno: Ethernet=


==Controlando Leds pelo Monitor Serial==
==Comunicação usando módulo Ethernet==


;Componentes necessários
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'''.
*Placa Arduino;
*Conector Arduino
*Protoboard;
*5 fios com conectores macho;
*2 resistores de 220 ohm(Vermelho, vermelho, marrom);
*2 Leds.


;Montagem: Primeiramente, faça as ligações como mostra a imagem abaixo:
[[Arquivo:Arduino_Ethernet_Shield.jpg|300px]]


[[Arquivo:SerialMonitorligadesliga1.png | 250px]]
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.


:Agora, abra a IDE do Arduino e passe a seguinte programação
Para uso do módulo Ethernet há uma serie de exemplos prontos ([https://www.arduino.cc/en/Tutorial/LibraryExamples Examples from Libraries]).


char c;
===Laboratório 1: Web Server===
void setup(){
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>.
pinMode(2,OUTPUT);
pinMode(3,OUTPUT);
Serial.begin(9600);
}
void loop()
{
    if (Serial.available() > 0)
    {
    c = Serial.read() - '0';
    Serial.flush();
    digitalWrite(c,!digitalRead(c));
    }
}
 
;Instruções: Conecte o Arduino no PC, selecione a versão do seu Arduino e a porta e clique em UPLOAD. Abra o Serial Monitor,  ao digitar o número 2 no Serial Monitor, irá acender o LED conectado na porta digital 2 do Arduino, e ao digitar novamente o número 2, o LED apagará. Agora se digitar o número 3, irá acender o LED da porta digital 3 e se digitar novamente o número 3, o LED apagará.
 
;Autoria: '''Igor Matheus B. Quintana''' / CST Análise e Desenvolvimento de Sistemas - IFPR - Câmpus Foz do Iguaçu.
 
==Comunicação Serial==
;Informações sobre comunicação serial e paralela:
*[[Comunicação serial e paralela]]
*[http://www.embarcados.com.br/arduino-comunicacao-serial Comunicação serial com Arduíno]/


;Comunicação Serial entre dois Arduínos:
;Procedimentos:
#Conectar o '''Shield Ethernet''' a placa Arduíno e a '''rede local''' (usando cabos de rede CAT 5/6 e conector RJ45);
#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'''];
#*'''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'''.


;:Emissor
====Análise do funcionamento do programa Web Server====
:Insere na porta serial os valores 0 e 1 de maneira alternada a cada dois segundos.
;Código exemplo: <ref>https://www.arduino.cc/en/Tutorial/LibraryExamples</ref> Comentários traduzidos.
 
<syntaxhighlight lang="c">
;:Receptor
/*
:Faz a leitura dos valores escritos pelo emissor e controla o LED.
Web Server
:0 -> LED apagado.
Servidor Web simples que mostra os valores das entradas analógicas.
:1 -> LED aceso.
*/
 
#include <SPI.h>
:[[Arquivo:SerialArduino.jpg | 400px]]
#include <Ethernet.h>
 
// Definição do endereço MAC:
Código do Arduíno emissor
// São 6 bytes em hexadecimal e deve ser único para a rede local.
//emissor 
byte mac[] = {
int num = 0;
  0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED
void setup(){
};
// 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.
   num = 0;
   }
   Serial.write(num);
   Serial.println("Ethernet WebServer Example");
   delay(2000);
   // Inicialização da conexão Ethernet e do servidor:
   num = 1;
  Ethernet.begin(mac, ip);
  Serial.write(num);
   // Checa se o hardware Ethernet está presente:
  delay(2000);
  if (Ethernet.hardwareStatus() == EthernetNoHardware) {
}
    Serial.println("Ethernet shield was not found:(");
 
    while (true) {
Código do Arduíno receptor
      delay(1); // Nada a fazer sem hardware Ethernet
//receptor
    }
int recByte;
  }
int led = 13;
  if (Ethernet.linkStatus() == LinkOFF) {
void setup(){
    Serial.println("Ethernet cable is not connected.");
   Serial.begin(9600);
  }
   pinMode(led,OUTPUT);
  // Inicialização do servidor
}
  server.begin();
void loop(){
  Serial.print("server is at ");
  if (Serial.available ()> 0)
  Serial.println(Ethernet.localIP());
    {
}
         recByte = Serial.parseInt();
void loop() {
         //parseInt() retorna o primeiro número inteiro válido do buffer serial.
   // Escuta por clientes
         //Caracteres e não inteiros são ignorados.
  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;
        }
      }
     }
     }
  if(recByte == 0){
    // Tempo para processar o dado
     digitalWrite(led,LOW);
     delay(1);
  }else if(recByte == 1){
    // Fecha a conexão:
     digitalWrite(led,HIGH);
    client.stop();
     Serial.println("client disconnected");
   }
   }
}
}
 
</syntaxhighlight>
===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'''.
 
;Autoria: '''Matheus Marques''' / CST Análise e Desenvolvimento de Sistemas - IFPR - Câmpus Foz do Iguaçu
 
==Comunicação sem fio com Wireless Shield e Xbee==
 
O '''[https://www.arduino.cc/en/Main/ArduinoWirelessShield Wireless Shield]''' permite a '''comunicação serial sem fio''' baseado no módulo '''[http://www.digi.com/products/wireless-wired-embedded-solutions/zigbee-rf-modules/zigbee-mesh-module/xbee-zigbee Xbee]''' da Digi.


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


===Configuração do Wireless Shield===
===Laboratório 2: Análise do Web Server com Wireshark===
A placa '''Wireless Shield''' possui uma '''chave de configuração''' da comunicação serial entre o módulo '''Xbee''' e o '''microcontrolador do Arduino''' e o '''conversor serial USB''' (ver: https://www.arduino.cc/en/Main/ArduinoWirelessShield):
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;


[[Arquivo:WirelessShield_SD_switchUSB.png|100px]]
;Análise de interação com navegador:
Utilizar '''navegador''' para acessar '''servidor Web''' rodando no '''Arduíno''' e analisar pacotes com '''Wireshark'''.


*'''Posição micro''': O pino Dout do módulo Wireless é conectado ao pino RX do microcontrolador do Arduino e o pino Din ao pino TX do microcontrolador. '''O módulo sem fio se comunica de forma serial com o microcontrolador do Arduino.''' Destaca-se que os pinos TX e RX do microcontrolador também continuam conectados aos pinos RX e TX do conversor serial USB. Desta forma, dados transmitidos pelo microcontrolador serão enviados simultaneamente ao módulo sem fio e a serial USB. Neste modo o microcontrolador do Arduino não pode ser programado via USB.
Procedimentos:
*'''Posição USB''': O pino Dout do módulo Wireless é conectado ao pino RX do conversor serial USB e o pino Din ao pino TX  do conversor serial USB. '''O módulo sem fio se comunica diretamente com o computador.''' Para usar este modo o microcontrolador do Arduíno deve ser programado com um '''sketch vazio''':
#Abrir navegador a acessar IP do Servidor Web;
void setup() { }
#Acompanhar mensagens no monitor serial do Arduíno;
void loop() { }
#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.


;Xbee Explorer USB: A placa '''Wireless Shield''' com a chave na '''posição USB''' e o '''microcontrolador do Arduíno''' programado com '''sketch vazio''' se comporta como um módulo '''Xbee Explorer USB''', com o Xbee se comunicando diretamente com o computador.
;Análise de interação com telnet:
Iniciar uma nova captura de pacotes com o Wiewshark.


[[Arquivo:XbeeExplorerUSB.png|200px]]
Acessar '''servidor Web''' rodando no '''Arduíno''' com '''telnet''' na '''porta 80''' e analisar pacotes com '''Wireshark''':
telnet 192.168.71.2xx 80


===Exemplo de utilização===
Procedimentos:
Exemplo de comunicação usando a '''configuração padrão''' dos módulos '''Xbee''', apresentado em https://www.arduino.cc/en/Guide/ArduinoWirelessShield:
#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.


*Para fazer a carga de programas no microcontrolador do Arduíno, colocar a '''chave''' do módulo wireless na '''posição USB'''.
;Análise de interação com curl:
*Em um dos Arduínos com módulo Wireless carregar o programa
Repetir procedimentos acessando '''servidor Web''' rodando no '''Arduíno''' com '''curl''' e analisar pacotes com '''Wireshark''':
Exemples->Communication->Physical Pixel
curl 192.168.71.2xx
:Este programa faz o Arduíno acender ou apagar o led da porta 13 a partir do envio do caracter H ou L a partir do '''monitor serial'''. Testar o funcionamento do programa com a chave do módulo wireless na '''posição USB'''. Em seguida desconectar o Arduíno da interface USB e mudar a chave do módulo wireless para a '''posição micro'''.


//  Physical Pixel
===Laboratório 3: DHCP Address Print===
const int ledPin = 13; // the pin that the LED is attached to
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>.
int incomingByte;      // a variable to read incoming serial data into
void setup() {
  Serial.begin(9600);
  pinMode(ledPin, OUTPUT);
}
void loop() {
  if (Serial.available() > 0) {
    incomingByte = Serial.read();
    if (incomingByte == 'H') {
      digitalWrite(ledPin, HIGH);
    }
    if (incomingByte == 'L') {
      digitalWrite(ledPin, LOW);
    }
  }
}
*Em outro Arduíno com módulo wireless, carregar o programa abaixo com chave do módulo wireless na '''posição USB'''. Verificar o funcionamento do programa no '''monitor serial'''. Depois de carregado o programa mudar a chave do módulo wireless para a '''posição micro'''.  
  void setup()
{
  Serial.begin(9600);
}
void loop()
{
  Serial.print('H');
  delay(1000);
  Serial.print('L');
  delay(1000);
}
*Para '''testar a comunicação serial sem fio''', conectar o primeiro Arduíno na fonte de alimentação e verificar se a comunicação entre os Arduínos acontece, fazendo o led piscar.
**Caso não haja comunicação, tente restabelecer a '''configuração padrão''' ('''''default''''') nos módulos '''Xbee''' (veja abaixo).


====Arduíno Leonardo====
;Procedimentos:
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'''.
#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'''.


===Endereçamento dos módulos Xbee===
===Laboratório 4: Consulta a Servidor de Data/Hora===
Vários parâmetros precisam ser configurados para que os módulos Xbee possam se comunicar:
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'''.
#Os dispositivos precisam estar na mesma '''rede''', definida pelo parâmetro '''ID''';
#Os dispositivos precisam usar o mesmo '''canal''', definido pelo parâmetro '''CH''';
#O '''endereço destino''' (DH e DL) determina qual módulo da rede receberá os dados:
#*Se o '''DH = 0''' e o '''DL < 0xFFFF''' (i.e. 16 bits), o dado transmitido pelo módulo será recebido por qualquer módulo cujo '''endereço''' de 16-bit '''MY''' é igual a '''DL''';
#*Se o '''DH = 0''' e o '''DL = 0xFFFF''', o dado transmitido será recebido por '''todos''' os módulos (''broadcast'');
#*Se o '''DH &ne; 0''' e o '''DL > 0xFFFF''', o dado transmitido será recebido somente pelo módulo cujo '''número serial''' seja igual ao '''endereço destino''' (i.e. '''SH = DH''' e '''SL = DL''').


Síntese de alguns parâmetros:
;Procedimentos:
{| border=1
#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'''];
| '''Parâmetro''' || '''Descrição''' || '''Valor default'''
#Testar o programa e acompanhar pelo '''monitor serial''' a data e hora obtida.
|-
#Pesquisar e testar consulta a servidores NTP no Brasil.
| ID || Identificador de rede || 3332
|-
| CH || Canal || C
|-
| SH SL || Numero de série || Diferente para cada módulo
|-
| MY || Endereço do módulo || 0
|-
| DH DL || Endereço destino || 0
|-
| BD || Vazão da comunicação serial (bps) || 3 (9600 bps)
|}


===Configuração do módulo Xbee===
==Cartão SD do módulo Ethernet==


Para a configuração do módulo Xbee é interessante utilizar o software [http://www.digi.com/support/productdetail?pid=3352 XCTU] da Digi ou o [http://www.moltosenso.com/ moltosenso Network Manager], os quais apresentam facilidades para configuração e atualização dos módulos wireless.
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.


;Exemplo de configuração com o software moltosenso Network Manager: Baixar e instalar o software '''moltosenso Network Manager IRON 1.0''' (''Free''):
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.


*Na guia '''''Port Setup''''' é possível verificar a configuração da porta, clique em '''''Open Port''''' e verifique se o dispositivo foi detectado;
===Laboratório 5: Escrita e leitura no cartão SD===
*Clique no dispositivo e verifique as informações do mesmo em '''''Current Device''''';
Este laboratório mostra como utilizar o '''cartão SD''' para escrita e leitura de dados em um arquivo.
[[Arquivo:moltosenso.png|400px]]
*Na guia '''''Node Settings''''' é possível selecionar o módulo e verificar seus parâmetos de configuração;
[[Arquivo:moltosenso2.png|400px]]
*Para '''restaurar os parâmetros ''default''''' do dispositivo clique em '''''Restore All''''' e depois em '''''Write Permanently''''';


;Adaptação e autoria: --[[Usuário:Evandro.cantu|Evandro.cantu]] ([[Usuário Discussão:Evandro.cantu|discussão]]) 20h19min de 12 de julho de 2015 (BRT)
;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.


==Comunicação com o Ethernet Shield==
===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 exemplo mostra como utilizar o '''[https://www.arduino.cc/en/Main/ArduinoBoardEthernet Ethernet Shield]''' juntamente com o '''Arduíno''' para criar um '''Web Server''' que forneça informações sobre sensores conectados a entradas analógicas  (Ver: https://www.arduino.cc/en/Tutorial/WebServer).
;Procedimentos:
#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''';
#Carregar o '''programa exemplo''': [https://www.arduino.cc/en/Tutorial/LibraryExamples/Datalogger '''Arquivo/Exemplos/SD/Datalogger'''];
#Adaptar o programa exemplo para os sensores conectados.


Usando a biblioteca '''Ethernet.h''', o Arduíno pode responder a requisições HTTP através do '''Ethernet Sheild'''.
==Projeto: Servidor Web com armazenamento de dados em cartão SD==


O '''Ethernet Shield''' permite conectar o controlador '''Ethernet WizNet''' ao Arduíno usando o '''barramento SPI'''. O '''barramento SPI''' (''Serial Peripheral Interface'') é um interface de comunicação serial síncrona usada para comunicação em distâncias curtas, e usa a biblioteca '''SPI.h'''. O barramento SPI usa os pinos 10, 11, 12 e 13 do Arduíno para implementar a conexão SPI com o WizNet. 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.
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'''.  


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


/*
Obs:  
  Web Server para fornecer a temperatura usando sensor LM35
*O programa para o servidor Web pode combinar vários dos exemplos vistos nos laboratórios.
  O sensor de temperatura (LM35) é conectado a entrada analógica 0 do Arduino.
*Consulte outros programas exemplos das bibliotecas '''Ethernet''' e '''SD'''.
  Based in Sketche: Arduino -> Ethernet -> BarometricPressureWebServer
  by Tom Igoe (2010)
*/
#include <Ethernet.h>
#include <SPI.h>
// assign a MAC address for the ethernet controller.
byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
// assign an IP address for the controller:
IPAddress ip(192,168,1,20);
IPAddress gateway(192,168,1,1);
IPAddress subnet(255, 255, 255, 0);
// Initialize the Ethernet server library
EthernetServer server(80);
//Sensor de temperatura LM35
//ConversaoGrausCelcius = 5 / 1023 * 100 = 0,488758553
const float ConversaoGrausCelcius = 0.488758553;
float  SensorLM35;
void setup() {
    Serial.begin(9600);
  // start the Ethernet connection and the server:
  Ethernet.begin(mac, ip);
  server.begin();
  delay(1000);
  Serial.print("server is at ");
  Serial.println(Ethernet.localIP());
}
void loop() {
  // Faz a leitura do sensor periodicamente.
  Serial.print('.');
  SensorLM35 = analogRead(A0) * ConversaoGrausCelcius;
  // listen for incoming Ethernet connections:
  listenForEthernetClients();
  delay(1000);
}
void listenForEthernetClients() {
  // listen for incoming clients
  EthernetClient client = server.available();
  if (client) {
    Serial.println("Got a client");
    // an http request ends with a blank line
    boolean currentLineIsBlank = true;
    while (client.connected()) {
      if (client.available()) {
        char c = client.read();
        Serial.write(c); 
        if (c == '\n' && currentLineIsBlank) {
          // send a standard http response header
          client.println("HTTP/1.1 200 OK");
          client.println("Content-Type: text/html");
          client.println("Connection: close"); 
          client.println();
          client.println("<!DOCTYPE HTML>");
          client.println("<html>");       
          // output the value of temperature         
          client.print("Temperatura interna (oC) = ");
          client.print(SensorLM35);
          client.println("</html>");
          break;
        }
        if (c == '\n') {
          currentLineIsBlank = true;
        }
        else if (c != '\r') {
          currentLineIsBlank = false;
        }
      }
    }
    delay(1);
    client.stop();
    Serial.println("client disonnected");   
  }
}


==Comunicação Serial via Bluetooth==
==Referências==
 
<references />
;Pinagem e conexão com o Arduíno: Será utilizado o módulo '''Bluetooth HC06''' <ref>https://www.filipeflop.com/blog/tutorial-modulo-bluetooth-com-arduino/</ref>, que possui 4 pinos para conexão com o Arduíno, como mostrado na figura:
            _________
            |        |
            |        |
            |        |
            |Bleutooth|
            |        |
            |  HC06  |
            |        |
            |        |
            |_________|
              | | | |
      Vcc ----+ | | +---- Rxd
      Gnd ------+ +------ Txd
: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
 
===Arduíno Mega Multi Serial===
O '''Arduíno MEGA''' usa a '''Serial''' exclusivamente para comunicação com a '''porta USB'''. Para comunicação serial TTL (5V) nos pinos 0 (RX) and 1 (TX), como a que será utilizada com o módulo Bluetooth, deve-se utilizar a '''Serial1''', '''Serial2''' ou '''Serial3''' <ref>https://www.arduino.cc/en/Reference/Serial</ref>.


----
----
 
[[Usuário:Evandro.cantu|Evandro.cantu]] ([[Usuário Discussão:Evandro.cantu|discussão]]) 16h26min de 20 de junho de 2023 (-03)
;Adaptação e autoria: --[[Usuário:Evandro.cantu|Evandro.cantu]] ([[Usuário Discussão:Evandro.cantu|discussão]]) 19h00min de 12 de agosto de 2015 (BRT)
 
----
----


[[Categoria:Arduíno]]
[[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”