30 agosto 2017

Data logger com Ethernet Shield W5500

Mais uma opção para você montar o seu projeto conectado na rede local ou até mesmo na internet, vamos conhecer o Ethernet Shield W5500 e montar um data logger para armazenar dados em um cartão SD instalado no shield.

Arduino Ethernet Shield W5500


O Ethernet Shield W5500 é uma placa parecida com o conhecidíssimo Ethernet Shield W5100, que já foi assunto de alguns posts aqui no Arduino e Cia, mas vamos ver que o W5500 tem algumas vantagens e características bem interessantes.

O Ethernet Shield W5500


A primeira diferença que notamos no Ethernet Shield W5500 e que agrada bastante, é o tamanho e o posicionamento do conector ethernet (RJ45). Ao contrário de outras placas, ele tem um tamanho reduzido e foi colocado de tal maneira que você consegue encaixar outro shield sobre ele, caso seja necessário:


W5500 - Detalhe conector RJ45

O shield conta também com dois conectores para módulos da linha Grove, que é um sistema que utiliza um cabo padrão de 4 pinos que facilita o processo de conexão, já que os cabos não podem ser ligados de forma invertida. O sistema Grove é indicado para iniciantes, estudantes e hobistas que precisam criar os seus projetos usando microcontroladores mas que não querem montar complicados circuitos eletrônicos. No W5500, você tem um conector para módulos que utilizam comunicação I2C e um para comunicação UART (serial).

W5500 - Detalhe conectores Grove

Temos ainda um botão de reset e também um slot para cartão SD (máximo de 2GB, FAT16 ou FAT32), que permite que você armazene dados da web em um cartão de memória ou até mesmo carregue uma página web à partir dele. 

Internamente, o W5500 tem melhorias com relação à estabilidade e performance e uma maior capacidade de conexão: 8 sockets, o que significa que você pode conectar o W5500, por exemplo, à 8 páginas web simultaneamente, ou criar um web server que aceite 8 conexões ao mesmo tempo. Para efeito de comparação, o W5100 suporta até 4 conexões.

Detalhe W5500

Outra detalhe muito importante do ethernet shield W5500 é que ele trabalha com 3.3V nos pinos de sinal, mas é tolerante à 5V, assim você pode usar o shield tanto com Arduino Uno e Mega, que trabalham com 5V, como com o Arduino Due, Intel Edison e Linkit One, que trabalham com 3.3V.

Abaixo, outras características do shield W5500:
  • Protocolos suportados: TCP, UDP, ICMP, IPv4, ARP, IGMP, PPPoE
  • Modo Power Down
  • Suporte à Wake on Lan (UDP)
  • Memória interna de 32K para buffers de recepção e transmissão (RX/TX)
  • 10BaseT/100BaseTX Ethernet PHY
  • Auto negociação: full e half duplex
  • Leds indicadores: Full/Halp Duples, Link, Velocidade e Ativo

E para finalizar, os pinos utilizados pelo shield para comunicação com o Arduino:
  • Pino Digital 4: CS (Chip Select) do cartão SD
  • Pino Digital 10: CS (Chip Select) do W5500
  • Pino Digital 11: Interface SPI - MOSI
  • Pino Digital 12: Interface SPI - MISO
  • Pino Digital 13: Interface SPI - SCK

Biblioteca arduino para W5500


Para usar o ethernet shield W5500 com Arduino vamos substituir a biblioteca ethernet que já vem instalada por padrão na IDE. Você pode simplesmente apagar a pasta ethernet que já existe ou movê-la para algum outro local no seu computador. 

Depois de fazer isso, baixe a biblioteca do W5500 neste link, descompacte o arquivo e coloque a nova pasta ethernet dentro da pasta libraries da IDE. Essa biblioteca que você instalou serve tanto para o W5500 como para o W5100, ok?

A biblioteca tem vários exemplos de uso. São 16 ao todo, com os mais comuns como WebClient e WebServer além de exemplos com FTP e DHCP, entre outras opções que valem a pena você explorar.

Data logger e Web Server com W5500


No nosso data logger vamos criar um web server e armazenar no cartão SD, à cada 10 segundos, o estado das portas analógicas A0, A1 e A2. Esse é um exemplo bem simples de utilização, que você pode usar como base para gravar informações de data e hora, dados de sensores, avisos e outras informações no cartão para posterior análise.

Insira no shield um cartão de memória formatado como FAT16 ou FAT32 e carregue o programa abaixo no Arduino:

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
//Programa: Datalogger com Ethernet Shield W5500
//Autor: Arduino e Cia

#include <SD.h>
#include <SPI.h>
#include <Ethernet.h>

const int chipSelect = 4;

//Define o MAC Address usando o endereco da placa ou
//atribuindo um MAC manualmente
#if defined(WIZ550io_WITH_MACADDRESS)
;
#else
byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
#endif

//Altere o IP abaixo de acordo com o endereco IP da sua rede
IPAddress ip(192, 168, 15, 100);

//Inicializa o servidor Web na porta 80
EthernetServer server(80);

void setup()
{
  Serial.begin(9600);

  //Inicializa a conexao ethernet
#if defined(WIZ550io_WITH_MACADDRESS)
  Ethernet.begin(ip);
#else
  Ethernet.begin(mac, ip);
#endif
  server.begin();
  //Mostra no serial monitor o endereco IP
  Serial.print("Servidor no endereco IP: ");
  Serial.println(Ethernet.localIP());

  //Inicializa o cartao SD
  Serial.print("Inicializando cartao SD...");

  //Verifica se o cartao esta presente ou com erro
  if (!SD.begin(chipSelect)) {
    Serial.println("Erro no cartao ou cartao nao inserido!");
    // don't do anything more:
    return;
  }
  Serial.println(" Cartao inicializado.");
  Serial.println();
  Serial.println("Aguardando conexoes....");
}


void loop()
{
  //Aguarda conexoes
  EthernetClient client = server.available();
  if (client) {
    Serial.println("Nova conexao");
    boolean currentLineIsBlank = true;
    while (client.connected()) {
      if (client.available()) {
        char c = client.read();
        Serial.write(c);
        if (c == '\n' && currentLineIsBlank) {
          //Envia uma resposta padrao HTTP
          client.println("HTTP/1.1 200 OK");
          client.println("Content-Type: text/html");
          client.println("Connection: close");
          //Recarrega a pagina a cada 10 segundos
          client.println("Refresh: 10");
          client.println();
          client.println("<!DOCTYPE HTML>");
          client.println("<html>");

          //Efetua a leitura das portas analogicas
          int valor_porta0 = analogRead(0);
          int valor_porta1 = analogRead(1);
          int valor_porta2 = analogRead(2);
          //Mostra os valores no browser
          client.print("Porta analogica 0: ");
          client.print(valor_porta0);
          client.print("<br/>");
          client.print("Porta analogica 1: ");
          client.print(valor_porta1);
          client.print("<br/>");
          client.print("Porta analogica 2: ");
          client.print(valor_porta2);
          client.print("<br/>");

          //Grava os valores lidos no cartao SD
          //Abre o arquivo arquivo.txt
          File datafile = SD.open("datalogger.txt", FILE_WRITE);
          //Se arquivo.txt estiver disponivel, grava os dados
          if (datafile)
          {
            datafile.print("Porta analogica 0: ");
            datafile.println(valor_porta0);
            datafile.print("Porta analogica 1: ");
            datafile.println(valor_porta1);
            datafile.print("Porta analogica 2: ");
            datafile.println(valor_porta2);
            datafile.println();
            datafile.close();
            //Mensagem de aviso no serial monitor
            Serial.println("Dados gravados no cartao SD");
          }
          //Mensagem de erro caso datalogger.txt nao
          //estiver disponivel
          else {
            Serial.println("Erro ao abrir datalogger.txt");
          }
          break;
        }
        if (c == '\n') {
          currentLineIsBlank = true;
        }
        else if (c != '\r') {
          currentLineIsBlank = false;
        }
      }
    }
    delay(1);
    client.stop();
    Serial.println("client disconnected");
  }
}

O programa realiza a definição das configurações de IP do Ethernet Shield (endereço IP, máscara, gateway, etc),  e também verifica se o cartão SD foi corretamente inserido. Caso tudo esteja ok, mostra essas informações no Serial Monitor e aguarda a conexão ao web server:

Serial Monitor - Informações iniciais

No browser de sua preferência, digite o endereço IP que foi mostrado no serial monitor. As informações relativas às portas analógicas serão mostradas na tela:

Browser - Acesso ao Web Server

A página é recarregada à cada 10 segundos, e nesse intervalo também são gravadas as informações no cartão SD, em um arquivo chamado datalogger.txt. Você pode abrir esse arquivo em um editor de textos comuns para verificar o processo de gravação e também importar esses dados em uma planilha, gerar gráficos, etc.

Nenhum comentário:

Postar um comentário