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

De Wiki Cursos IFPR Foz
Ir para navegaçãoIr para pesquisar
 
(111 revisões intermediárias pelo mesmo usuário não estão sendo mostradas)
Linha 1: Linha 1:
=Arduíno: Módulos de Comunicação=
=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]]


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


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


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


;Outras placas Arduíno:  
;Procedimentos:
*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'''.
#Conectar o '''Shield Ethernet''' a placa Arduíno e a '''rede local''' (usando cabos de rede CAT 5/6 e conector RJ45);
*O '''Arduíno Mega''' tem três portas de '''comunicação serial''' adicionais: '''Serial1''', '''Serial3''' e  '''Serial3'''.
#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'''.


===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.
;Emissor: Insere na porta serial os valores 0 e 1 de maneira alternada a cada dois segundos.
 
;Receptor: Faz a leitura dos valores escritos pelo emissor e controla o LED.
*0 -> LED apagado.
*1 -> LED aceso.
 
:[[Arquivo:SerialArduino.jpg | 400px]]
 
Código do Arduíno emissor
<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.
   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:(");
</syntaxhighlight>
    while (true) {
 
      delay(1); // Nada a fazer sem hardware Ethernet
Código do Arduíno receptor
    }
<syntaxhighlight lang="c">
  }
//receptor
  if (Ethernet.linkStatus() == LinkOFF) {
int recByte;
    Serial.println("Ethernet cable is not connected.");
int led = 13;
  }
void setup(){
  // Inicialização do servidor
   Serial.begin(9600);
  server.begin();
   pinMode(led,OUTPUT);
  Serial.print("server is at ");
}
  Serial.println(Ethernet.localIP());
void loop(){
}
  if (Serial.available ()> 0)
void loop() {
    {
   // Escuta por clientes
         recByte = Serial.parseInt();
  EthernetClient client = server.available();
         //parseInt() retorna o primeiro número inteiro válido do buffer serial.
   if (client) {
         //Caracteres e não inteiros são ignorados.
    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>
 
====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 porta de comunicação 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 com o Ethernet Shield==
 
Este exemplo 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  (Ver: https://www.arduino.cc/en/Tutorial/WebServer).
 
Usando a biblioteca '''Ethernet.h''', o Arduíno pode responder a requisições HTTP através do '''Ethernet Sheild'''.
 
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.
 
===Exemplo===
<syntaxhighlight lang="c">
/*
  Web Server para fornecer a temperatura usando sensor LM35
  O sensor de temperatura (LM35) é conectado a entrada analógica 0 do Arduino.
  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");   
  }
}
</syntaxhighlight>
 
==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 (ver: http://www.instructables.com/id/Add-bluetooth-to-your-Arduino-project-ArduinoHC-06):
 
[[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
 
===Teste do módulo bluetooth===
;PhysicalPixel: Permite acender e apagar led a partir de aplicativo '''Android''' pareado com módulo '''Bluetooth''':
:*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===
Fonte: http://www.instructables.com/id/Add-bluetooth-to-your-Arduino-project-ArduinoHC-06
 
;Echo Code: Permite enviar uma string ao '''Arduíno''' via Bluetooth e receber de volta a mesma      string no '''monitor serial'''.
 
<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>
 
;Led Code: Permite acender e apagar um '''led''' conectado ao '''Arduíno''' enviando caracteres via '''Bluetooth''' de um '''''smartphone''''' ou outro dispositivo Bluetooth.
 
<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>
</syntaxhighlight>


===''Smartphone'' Android===
;Comentários e complementos sobre a requisição HTTP:
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]
*'''[[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).


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


==Comunicação sem fio com Wireless Shield e Xbee==
;Análise de interação com navegador:
Utilizar '''navegador''' para acessar '''servidor Web''' rodando no '''Arduíno''' e analisar pacotes com '''Wireshark'''.


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


[[Arquivo:Arduino_WirelessSDShield.jpg|300px]]
;Análise de interação com telnet:
Iniciar uma nova captura de pacotes com o Wiewshark.


===Configuração do Wireless Shield===
Acessar '''servidor Web''' rodando no '''Arduíno''' com '''telnet''' na '''porta 80''' e analisar pacotes 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):
telnet 192.168.71.2xx 80


[[Arquivo:WirelessShield_SD_switchUSB.png|100px]]
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.


*'''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.
;Análise de interação com curl:
*'''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''':
Repetir procedimentos acessando '''servidor Web''' rodando no '''Arduíno''' com '''curl''' e analisar pacotes com '''Wireshark''':
  void setup() { }
  curl 192.168.71.2xx
void loop() { }


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


[[Arquivo:XbeeExplorerUSB.png|200px]]
;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'''.


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


*Para fazer a carga de programas no microcontrolador do Arduíno, colocar a '''chave''' do módulo wireless na '''posição USB'''.
;Procedimentos:
*Em um dos Arduínos com módulo Wireless carregar o programa
#Conectar o '''Shield Ethernet''' a placa Arduíno e a '''rede local''' (usando cabos de rede CAT 5/6 e conector RJ45);
Exemples->Communication->Physical Pixel
#Carregar o '''programa exemplo''': [https://www.arduino.cc/en/Tutorial/LibraryExamples/UdpNtpClient '''Arquivo/Exemplos/Ethernet/UdpNtpClient'''];
: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'''.
#Testar o programa e acompanhar pelo '''monitor serial''' a data e hora obtida.
#Pesquisar e testar consulta a servidores NTP no Brasil.


<syntaxhighlight lang="c">
==Cartão SD do módulo Ethernet==
//  Physical Pixel
const int ledPin = 13; // the pin that the LED is attached to
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);
    }
  }
}
</syntaxhighlight>
*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'''.


<syntaxhighlight lang="c">
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.
void setup()
{
  Serial.begin(9600);
}
void loop()
{
  Serial.print('H');
  delay(1000);
  Serial.print('L');
  delay(1000);
}
</syntaxhighlight>


*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.
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.
**Caso não haja comunicação, tente restabelecer a '''configuração padrão''' ('''''default''''') nos módulos '''Xbee''' (veja abaixo).


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


===Endereçamento dos módulos Xbee===
;Procedimentos:
Vários parâmetros precisam ser configurados para que os módulos Xbee possam se comunicar:
#Conectar o '''Shield Ethernet''' a placa Arduíno e inserir um '''cartão SD''' no módulo;
#Os dispositivos precisam estar na mesma '''rede''', definida pelo parâmetro '''ID''';
#Carregar o '''programa exemplo''': [https://www.arduino.cc/en/Tutorial/LibraryExamples/ReadWrite '''Arquivo/Exemplos/SD/ReadWrite'''];
#Os dispositivos precisam usar o mesmo '''canal''', definido pelo parâmetro '''CH''';
#Testar o programa e acompanhar pelo '''monitor serial''' o processo de escrita e leitura.
#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:
===Laboratório 6: Armazenamento de dados de sensores em cartão SD===
{| border=1
Este laboratório mostra como utilizar o '''cartão SD''' para armazenamento de dados de sensores em um arquivo.
|-
| '''Parâmetro''' || '''Descrição''' || '''Valor default'''
|-
| 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===
;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.


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.
==Projeto: Servidor Web com armazenamento de dados em 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''):
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'''.


*Na guia '''''Port Setup''''' é possível verificar a configuração da porta, clique em '''''Open Port''''' e verifique se o dispositivo foi detectado;
A cada acesso ao '''servidor Web''' através de um '''navegador''', o servidor deve fornecer as '''leituras''' dos dados do '''sensor de temperatura'''.
*Clique no dispositivo e verifique as informações do mesmo em '''''Current Device''''';
[[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)
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 386: Linha 218:


----
----
;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)
[[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”