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

De Wiki Cursos IFPR Foz
Ir para navegaçãoIr para pesquisar
 
(105 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]]


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);
#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'''.


;Outras placas Arduíno:
====Análise do funcionamento do programa Web Server====
*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'''.
;Código exemplo: <ref>https://www.arduino.cc/en/Tutorial/LibraryExamples</ref> Comentários traduzidos.
*O '''Arduíno Mega''' tem três portas de '''comunicação serial''' adicionais: '''Serial1''',  '''Serial3''' e  '''Serial3'''.
 
===Laboratório 1: Comunicação serial entre dois Arduínos===
 
;Monitor Serial: O '''monitor serial''' permite enviar dados do '''computador''' ao '''Arduíno''' pela '''interface serial USB'''.
*Carregar programa exemplo '''[http://www.arduino.cc/en/Tutorial/PhysicalPixel Arquivo/Exemplos/Communication/PhysicalPixel]''' e '''acionar''' o '''led''' do '''pino 13''' a partir de comandos '''H''' e '''L''' enviados pelo terminal serial.
 
;Comunicação entre dois Arduínos:
:[[Arquivo:SerialArduino.jpg | 300px]]
*Conectar os dois Arduínos através das '''portas seriais''': 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) {
</syntaxhighlight>
    Serial.println("Ethernet shield was not found:(");
 
    while (true) {
====Configuração do SimulIDE para comunicação serial com Arduíno====
      delay(1); // Nada a fazer sem hardware Ethernet
É 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''';
  if (Ethernet.linkStatus() == LinkOFF) {
*No bloco '''Uart''' que vai abrir, clicar com o botão direito do mouse e selecionar '''properties''';
     Serial.println("Ethernet cable is not connected.");
*Escrever em '''port name''' o nome da porta serial;
  }
*Clicar em '''Open''' para ativar a porta (deve indicar sucesso com o botão vermelho).
  // Inicialização do servidor
 
  server.begin();
==Comunicação com o Ethernet Shield==
  Serial.print("server is at ");
 
  Serial.println(Ethernet.localIP());
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).
}
 
void loop() {
Usando a biblioteca '''Ethernet.h''', o Arduíno pode responder a requisições HTTP através do '''Ethernet Sheild'''.
  // Escuta por clientes
 
  EthernetClient client = server.available();
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.
  if (client) {
 
    Serial.println("new client");
===Exemplo===
    // Requisições HTTP terminam com uma linha em branco
<syntaxhighlight lang="c">
    boolean currentLineIsBlank = true;
/*
    while (client.connected()) {
  Web Server para fornecer a temperatura usando sensor LM35
      if (client.available()) {
  O sensor de temperatura (LM35) é conectado a entrada analógica 0 do Arduino.
        char c = client.read();
  Based in Sketche: Arduino -> Ethernet -> BarometricPressureWebServer
        Serial.write(c);
  by Tom Igoe (2010)
        // Se chegou no final da linha (recebeu caractere: newline)
*/
        // e a linha é vazia, a requisição HTTP terminou,
#include <Ethernet.h>
        // portando, envia resposta:
#include <SPI.h>
        if (c == '\n' && currentLineIsBlank) {
// assign a MAC address for the ethernet controller.
          // Envia cabeçalho da resposta HTTP
byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
          client.println("HTTP/1.1 200 OK");
// assign an IP address for the controller:
          client.println("Content-Type: text/html");
IPAddress ip(192,168,1,20);
          client.println("Connection: close");  // fecha a conexão após resposta
IPAddress gateway(192,168,1,1);
          client.println("Refresh: 5"); // atualiza página a cada 5 s
IPAddress subnet(255, 255, 255, 0);  
          client.println();
// Initialize the Ethernet server library
          client.println("<!DOCTYPE HTML>");
EthernetServer server(80);
          client.println("<html>");
//Sensor de temperatura LM35
          // Imprime a saída de cada porta analógica
//ConversaoGrausCelcius = 5 / 1023 * 100 = 0,488758553
          for (int analogChannel = 0; analogChannel < 6; analogChannel++) {
const float ConversaoGrausCelcius = 0.488758553;
            int sensorReading = analogRead(analogChannel);
float  SensorLM35;
            client.print("analog input ");
void setup() {
            client.print(analogChannel);
     Serial.begin(9600);
            client.print(" is ");
  // start the Ethernet connection and the server:
            client.print(sensorReading);
  Ethernet.begin(mac, ip);
            client.println("<br />");
  server.begin();
          }
  delay(1000);
          client.println("</html>");
  Serial.print("server is at ");
          break;
  Serial.println(Ethernet.localIP());
        }
}
        if (c == '\n') {
void loop() {  
          // Se está iniciando nova linha
  // Faz a leitura do sensor periodicamente.
          currentLineIsBlank = true;
  Serial.print('.');
        } else if (c != '\r') {
  SensorLM35 = analogRead(A0) * ConversaoGrausCelcius;
          // Se recebeu novo caractere na nova linha
  // listen for incoming Ethernet connections:
          currentLineIsBlank = false;
  listenForEthernetClients();
        }
  delay(1000);
      }
}
    }
void listenForEthernetClients() {
    // Tempo para processar o dado
  // listen for incoming clients
    delay(1);
  EthernetClient client = server.available();
    // Fecha a conexão:
  if (client) {
    client.stop();
    Serial.println("Got a client");
    Serial.println("client disconnected");
    // 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>
</syntaxhighlight>


;Led Code: Permite acender e apagar um '''led''' conectado ao '''Arduíno''' enviando caracteres via '''Bluetooth''' de um '''''smartphone''''' ou outro dispositivo Bluetooth.
;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).


<syntaxhighlight lang="c">
===Laboratório 2: Análise do Web Server com Wireshark===
char blueToothVal;          //value sent over via bluetooth
Ativar análise de pacotes com '''Wireshark''' utilizando filtro para IP e TCP porta 80:
char lastValue;              //stores last state of device (on/off)
ip.addr == 192.168.71.2xx and tcp.port == 80
void setup()
Obs: Fechar outras janelas de navegador que estejam ativas no computador;
{
  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===
;Análise de interação com navegador:
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]
Utilizar '''navegador''' para acessar '''servidor Web''' rodando no '''Arduíno''' e analisar pacotes com '''Wireshark'''.


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


==Comunicação sem fio com Wireless Shield e Xbee==
;Análise de interação com telnet:
Iniciar uma nova captura de pacotes com o Wiewshark.


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.
Acessar '''servidor Web''' rodando no '''Arduíno''' com '''telnet''' na '''porta 80''' e analisar pacotes com '''Wireshark''':
telnet 192.168.71.2xx 80


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


===Configuração do Wireless Shield===
;Análise de interação com curl:
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):
Repetir procedimentos acessando '''servidor Web''' rodando no '''Arduíno''' com '''curl''' e analisar pacotes com '''Wireshark''':
curl 192.168.71.2xx


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


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


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


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


===Exemplo de utilização===
==Cartão SD do módulo Ethernet==
Exemplo de comunicação usando a '''configuração padrão''' dos módulos '''Xbee''', apresentado em https://www.arduino.cc/en/Guide/ArduinoWirelessShield:


*Para fazer a carga de programas no microcontrolador do Arduíno, colocar a '''chave''' do módulo wireless na '''posição USB'''.
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.
*Em um dos Arduínos com módulo Wireless carregar o programa
Exemples->Communication->Physical Pixel
: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'''.


<syntaxhighlight lang="c">
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.
  //  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">
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.
===Laboratório 5: Escrita e leitura no cartão SD===
**Caso não haja comunicação, tente restabelecer a '''configuração padrão''' ('''''default''''') nos módulos '''Xbee''' (veja abaixo).
Este laboratório mostra como utilizar o '''cartão SD''' para escrita e leitura de dados em um arquivo.


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


===Endereçamento dos módulos Xbee===
===Laboratório 6: Armazenamento de dados de sensores em cartão SD===
Vários parâmetros precisam ser configurados para que os módulos Xbee possam se comunicar:
Este laboratório mostra como utilizar o '''cartão SD''' para armazenamento de dados de sensores em um arquivo.
#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 inserir um '''cartão SD''' no módulo;
|-
#Conectar ao Arduíno três '''sensores''' para leitura pelas entradas '''analógicas''';
| '''Parâmetro''' || '''Descrição''' || '''Valor default'''
#Carregar o '''programa exemplo''': [https://www.arduino.cc/en/Tutorial/LibraryExamples/Datalogger '''Arquivo/Exemplos/SD/Datalogger'''];
|-
#Adaptar o programa exemplo para os sensores conectados.
| 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===
==Projeto: Servidor Web com armazenamento de dados em cartão SD==


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.
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 de configuração com o software moltosenso Network Manager: Baixar e instalar o software '''moltosenso Network Manager IRON 1.0''' (''Free''):
A cada acesso ao '''servidor Web''' através de um '''navegador''', o servidor deve fornecer as '''leituras''' dos dados do '''sensor de temperatura'''.


*Na guia '''''Port Setup''''' é possível verificar a configuração da porta, clique em '''''Open Port''''' e verifique se o dispositivo foi detectado;
Obs:  
*Clique no dispositivo e verifique as informações do mesmo em '''''Current Device''''';
*O programa para o servidor Web pode combinar vários dos exemplos vistos nos laboratórios.
[[Arquivo:moltosenso.png|400px]]
*Consulte outros programas exemplos das bibliotecas '''Ethernet''' e '''SD'''.
*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''''';


==Referências==
==Referências==
Linha 360: 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”