Banco de dados MySQL com Arduino e Shield Ethernet W5100 – Registrando temperatura em um banco de dados

Sabemos que a utilização de placas Arduino é bastante difundida nos dias atuais, de modo que, o seu uso está presente em uma grande diversidade de aplicações, que vão desde trabalhos acadêmicos até projetos comerciais e industriais, no entanto, um grande problema surge em todas estas vertentes quando nos deparamos com a necessidade de armazenar informações inerentes a um determinado processo. Sendo assim, neste tutorial iremos aprender como fazer o registro de informações, mais especificamente, de temperatura em um banco de dados MySQL com o auxilio do shield ethernet W5100.

[toc]

O que são bancos de dados?

De uma maneira bem simples, pode-se entender um banco de dados como sendo um local onde podemos armazenar uma série de informações de maneira estruturada, organizada, que por sua vez, estejam à disposição para serem utilizadas tanto por softwares quanto por usuários diferentes. Podemos, por exemplo, armazenar os valores de temperatura coletados ao longo de um dia por uma placa Arduino e armazenar os mesmos numa tabela juntamente com a hora da medição.

Pense em uma industria com centenas de sensores que fazem medições de dados do processo a todo instante. É necessário que os dados estejam organizados de forma adequada e que os mesmos estejam acessíveis sempre que necessário, pois, caso contrario, estes seriam uma gama de informações sem utilidade prática.

Sendo assim, podemos perceber que os bancos de dados são recursos muito importantes e essenciais para o funcionamento dos mais variados tipos de estabelecimentos, desde os menores até as grandes indústrias, hospitais e etc, pois, através dos dados presentes nos mesmos, realiza-se o controle, por exemplo, de funcionários, de material, de custos e além disso, é possível até mesmo auxiliar nas tomadas de decisão em virtude de uma análise estatística feita sobre os mesmos.

Para realizarmos este tutorial deve-se ter em mente que os bancos de dados ficam armazenados em um servidor, portanto, antes de acessarmos um banco de dados, devemos acessar primeiramente o servidor onde estes estão inseridos. Em contrapartida, as estruturas intrínsecas a um banco de dados são as tabelas (estas são, de fato, tabelas, dotadas de linhas e colunas).

O MySQL, nosso Banco de dados

Quando realizamos algumas pesquisas sobre o que é o MySQL encontramos algumas fontes dizendo que o mesmo se trata de um banco de dados, enquanto outras, classificam o mesmo como um sistema gerenciador de banco de dados (SGBD) que utiliza a linguagem SQL como interface para realizar manipulação dos dados armazenados. Neste tutorial, como não estamos focados em toda parte teórica por trás deste assunto, basta encararmos o MySQL como um banco de dados, que não teremos maiores problemas.

 

Para utilizamos o MySQL, é necessário instalarmos um servidor, responsável por entre outras coisas, armazenar os dados e responder às requisições feitas por um cliente conectado com mesmo (conforme falando anteriormente, tanto softwares quanto usuários podem interagir com um servidor). O MySQL possui uma versão gratuita para a comunidade, que por sua vez, inclui diversos elementos, entre eles, o servidor e uma interface gráfica para ser utilizada como cliente.

A nossa sugestão é que você realize o download do instalador completo e instale o mesmo no seu computador.

---

Mãos à obra – Registrando informações no banco de dados

Neste momento, iremos demonstrar todos os passos para que você consiga realizar o objetivo que estamos propondo neste tutorial.

Componentes utilizados:

• 1 x Arduino UNO Rev 3
• 1 x Shield Ethernet Wiznet W5100
• 1 x Sensor de temperatura LM35
• Jumpers

Montando o projeto

Programando

Antes de adentrarmos na apresentação do código, disponibilizamos uma seção para ajudar aqueles que são iniciantes no assunto. Sinta-se livre para prosseguir caso você já tem domínio da IDE do Arduino.

– Biblioteca

Para desenvolver o projeto proposto  utilizou-se uma biblioteca capaz de atuar sobre um servidor MySQL fazendo com que o Arduino possa manipular dados existentes nas tabelas dos bancos de dados MySQL. Esta biblioteca pode ser encontrada aqui.

– Preparação (VOCÊ DEVE LER ESTA PARTE)

Antes de partir para o código desta aplicação, devemos entender uma coisa: A placa Arduino utilizada não é capaz de criar bancos de dados e tabelas, conforme será visto adiante, portanto, para que seja possível registrarmos valores de temperatura em um banco de dados MySQL, devemos criar manualmente o banco de dados no servidor MySQL e também a tabela na qual serão efetuados os registros.

Além disso, devemos também realizar a criação de um usuário para ser utilizado neste nosso projeto.

– Código do projeto

Segue o código a ser utilizado no Arduino para registrar valores de temperatura em um banco de dados MySQL

#include <Ethernet.h>
#include <MySQL_Connection.h>
#include <MySQL_Cursor.h>
#include <SPI.h>

#define LM35 A0

int leitura;
float leituraconvertida
char sentenca[128];
char valortemp[10];

byte mac_addr[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };

IPAddress server_addr(192,168,25,5);  
char user[] = "arduino";              
char password[] = "arduino";        

char INSERIR_TEMP[] = "INSERT INTO registrotemp (temperatura) VALUES (%s)";
char BANCODEDADOS[] = "USE banco_arduino";

EthernetClient client;
MySQL_Connection conn((Client *)&client);

void setup() 
{ 
   Serial.begin(115200);
   while (!Serial); 
   Ethernet.begin(mac_addr);
   Serial.println("Conectando...");
   if (conn.connect(server_addr, 3306, user, password)) 
   {
      delay(1000);
      
      MySQL_Cursor *cur_mem = new MySQL_Cursor(&conn);
      cur_mem->execute(BANCODEDADOS);
      delete cur_mem;
   }
   else
   {
      Serial.println("A conexão falhou");
      conn.close();
   }
}


void loop() 
{
   Serial.println("Executando sentença");

   leitura = analogRead(LM35);
   leituraconvertida = (float(analogRead(LM35))*5/(1023))/0.01;

   dtostrf(leituraconvertida, 4, 1, valortemp);
   sprintf(sentenca, INSERIR_TEMP, valortemp);
   
   MySQL_Cursor *cur_mem = new MySQL_Cursor(&conn);
   cur_mem->execute(sentenca);
   delete cur_mem;

   delay(2000);
}

---

Entendendo a fundo

Software

Neste momento, iremos explicar o funcionamento do código apresentado, porém, de maneira bastante detalhada.

– Incluindo as bibliotecas a serem utilizadas no projeto

Primeiramente, para desenvolvermos uma aplicação como esta, devemos incluir todas as bibliotecas que serão utilizadas no código, para que assim, o mesmo possa funcionar de maneira adequada. A biblioteca Ethernet.h é responsável pela comunicação que será estabelecida entre o Arduino UNO e a rede através do Shield ethernet wiznet w5100. Já a biblioteca SPI.h  tem como função coordenar a integração do shield citado com o Arduino UNO por meio do protocolo de comunicação SPI.

As bibliotecas MySQL_Connection e MySQL_Cursor têm como função promover a conexão Arduino UNO/servidor MySQL e executar as sentenças de manipulação de informações em um banco de dados.

#include <Ethernet.h>
#include <MySQL_Connection.h>
#include <MySQL_Cursor.h>
#include <SPI.h>

– Nomeando o pino de entrada analógica através da diretiva #define

Em seguida, utilizamos a diretiva #define para associar o pino de entrada analógica A0 ao nome LM35 (vale ressaltar que isso é apenas um recurso para facilitar a didática da programação, portanto, não obrigatório).

#define LM35 A0

– Declarando as variáveis a serem utilizadas no projeto

Posteriormente, temos um bloco onde ocorre a declaração das variáveis que serão utilizadas no decorrer do programa. As variáveis leitura (tipo inteiro) e leituraconvertida (tipo float) são responsáveis por armazenar o valor obtido da porta de entrada analógica A0 (através da função analogRead(), portanto, contido no intervalo de 0 a 1023) e o valor já convertido em temperatura, respectivamente.

int leitura;
float leituraconvertida;

Observe que também foram criados dois vetores do tipo char, estes são: sentenca e valortemp. Os elementos citados servirão para conter as frases (lembre-se que um vetor de elementos do tipo char é um vetor de caracteres) necessárias para a construção das sentenças que serão utilizadas para manipular os dados no servidor MySQL.

O tamanho dos vetores deve ser tal que os mesmos consigam armazenar as mensagens que serão utilizadas, sendo assim, não existe um valor certo para os mesmos, mas sim, um valor que atenda as necessidades conforme será visto mais adiante. Note que também é possível não declarar um valor para o tamanho, deixando que o programa calcule automaticamente a dimensão do mesmo.

char sentenca[128];
char valortemp[10];

– Definindo o endereço MAC do Arduino UNO

O próximo passo consiste em definir o endereço MAC que será atribuído ao Arduino UNO para que a conexão entre o mesmo e a rede possa ser estabelecida. No desenvolvimento deste projeto, conectamos o Shield Ethernet em nosso modem.

Na prática, este endereço pode ser qualquer um, desde que seja único na rede.

byte mac_addr[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };

– Definindo os parâmetros para a conexão com o servidor MySQL

Após a realização dos procedimentos listados anteriormente, deve-se definir os parâmetros necessários para que o Arduino UNO consiga ser conectado ao servidor MySQL existente. A primeira informação essencial é IP do servidor MySQL (caso o servidor esteja rodando, por exemplo, no seu laptop, o IP a ser inserido neste campo será justamente o IP do seu computador na rede local e para consulta-lo basta abrir o prompt de comando, digitar ipconfig e copiar o Endereço IPV4 (se estiver em inglês, IPV4 Address)).

IPAddress server_addr(192.168.25.5);

Veja como esta informação pode ser obtida:

Em seguida, escolhe-se um dos usuários cadastrados e a senha do mesmo, para que o Arduino UNO entre no servidor MySQL através destas informações. Neste caso, utilizamos o usuário chamado arduino cuja senha atribuída ao mesmo é arduino.

char user[] = "arduino";             
char password[] = "arduino";

– Criando as sentenças para manipulação de dados

Agora, devemos criar as sentenças que serão utilizadas pelo Arduino UNO para registrar as informações no banco de dados existente no servidor MySQL. 

A primeira sentença informa ao Arduino UNO qual dos bancos de dados existentes no servidor MySQL será manipulado, neste caso, o banco chamado banco_arduino.

Quando estamos interagindo diretamente com um servidor MySQL através do seu terminal, utilizamos a sentença “USE <nome do banco de dados>;” para selecionar um determinado banco de dados existente no servidor em questão. Sendo assim, declaramos um vetor de variáveis do tipo char, sem tamanho definido, para que este armazene a sentença citada anteriormente, de modo que, quando necessário, o Arduino UNO seja capaz de utilizá-la.

char BANCODEDADOS[] = "USE banco_arduino";

A segunda sentença é responsável por preencher uma linha de uma determinada tabela existente dentro de um banco de dados, neste caso, a tabela chamada registro.

Quando manipulamos uma tabela de um banco de dados através do terminal de um servidor MySQL, utilizamos a sentença “INSERT INTO <nome da tabela> <coluna a ser preenchida da tabela> VALUES <valor a ser colocado na interseção da coluna definida anteriormente com próxima linha vazia não preenchida>;” para preencher uma determinada linha da mesma. Desta maneira, assim como no item anterior, declaramos um vetor de variáveis do tipo char para que seja possível armazenar a sentença adequada para o propósito citado.

char INSERIR_TEMP[] = "INSERT INTO registrotemp (temperatura) VALUES (%s)";

– Declarando os objetos client e conn

Neste momento, cria-se dois objetos que serão utilizados posteriormente, de modo que, um destes é do tipo EthernetClient, chamado client (que representará o elemento responsável pela comunicação via ethernet no código) e outro do tipo MySQL_Connection, chamado conn (que será responsável pela conexão com o servidor MySQL).

Lembre-se: client e conn são apenas nomes, sendo assim, é importante ressaltar que, os objetos identificados por client e conn poderiam ser chamados de quaisquer outros nomes, como por exemplo, conexaoethernet e conexaomysql, respectivamente.

EthernetClient client;
MySQL_Connection conn((Client *)&client);

– Estabelecendo a conexão com o servidor MySQL

Primeiramente, utilizamos a função Serial.begin() para inicializar a comunicação serial. Neste caso, determinamos como parâmetro da função uma taxa de 115200 baud/s em virtude deste valor ter sido utilizado pelo desenvolvedor da biblioteca presente neste tutorial. Em seguida, recorremos à função while() com o argumento !Serial, para que o programa só continue sendo executado após a comunicação serial ter sido estabelecida.

Não só estes procedimentos, como todos os outros que envolvem a manipulação da porta serial, servem apenas para testes, isto é, para que você possa verificar se o programa está com algum tipo de erro ou se está funcionando perfeitamente, portanto, as linhas referentes aos mesmos podem ser comentadas caso o programa esteja funcionando da maneira desejada.

 Serial.begin(115200);
 while (!Serial); // wait for serial port to connect

Em seguida, utilizamos a função Ethernet.begin() para iniciar a comunicação com a rede via Ethernet. Observe que o parâmetro desta função é o endereço MAC definido anteriormente.

Ethernet.begin(mac_addr);

Para facilitar na visualização da execução do programa, imprimimos na porta serial a seguinte informação: “Conectando…”

Serial.println("Conectando...");

A próxima linha de código conta com uma função if(), cujo argumento é uma outra função, responsável pela conexão do Arduino com o servidor MySQL, de modo que, nesta função são passados como parâmetros o endereço IP da máquina onde está o servidor, a porta para o acesso do mesmo (geralmente, na instalação do servidor, a porta que vem definida como padrão é a 3306), o usuário e a senha do mesmo. Caso esta função consiga ser executada com exito, isto é, caso a conexão com o servidor ocorra sem problemas, o argumento testado na função if() será verdadeiro e o seu conteúdo será executado.

if (conn.connect(server_addr, 3306, user, password)) 
{
    ****** Conteúdo da função if() ******
}

O conteúdo da função if() começa com a utilização de uma função delay() para estabelecer um atraso na execução do programa e garantir o estabelecimento da conexão com o servidor MySQL.

delay(1000);

Em seguida, criamos um objeto do tipo MySQL_Cursor, chamado cur_mem. Este cursor será responsável por executar as sentenças que serão utilizadas para manipular as informações do banco de dados.

MySQL_Cursor *cur_mem = new MySQL_Cursor(&conn);

Posteriormente, utilizamos a função execute(), de modo que, o parâmetro da mesma é justamente a variável do tipo char BANCODEDADOS. Lembre-se que o conteúdo desta variável é a frase “USE banco_arduino”, que por sua vez, é o comando responsável por selecionar o banco de dados banco_arduino, entre os outros eventuais bancos existentes no servidor.

cur_mem->execute(BANCODEDADOS);

Por recomendação do desenvolvedor da biblioteca, após a execução da sentença desejada, apagamos o cursor criado anteriormente, em virtude do uso de memória.

delete cur_mem;

Confira o conteúdo completo da função if()

if (conn.connect(server_addr, 3306, user, password)) 
{ 
    delay(1000);
  
    MySQL_Cursor *cur_mem = new MySQL_Cursor(&conn);
    cur_mem->execute(BANCODEDADOS);
    delete cur_mem;
}

Caso a condição da função if() não seja satisfeita, isto é, se a conexão com o servidor não tiver ocorrido com sucesso, executa-se o conteúdo da função else, que por sua vez, consiste nas funções Serial.println() para imprimir uma mensagem de falha na conexão e a função close(), responsável por encerrar a tentativa de conexão.

{
     Serial.println("A conexão falhou");
     conn.close();
}

Observe como está a nossa função setup():

void setup() {
 
  Serial.begin(115200);
  while (!Serial); 
  Ethernet.begin(mac_addr);
  Serial.println("Conectando...");
  if (conn.connect(server_addr, 3306, user, password)) 
  {
     delay(1000);
   
     MySQL_Cursor *cur_mem = new MySQL_Cursor(&conn);
     cur_mem->execute(BANCODEDADOS);
     delete cur_mem;
  }
  else
  {
     Serial.println("A conexão falhou");
     conn.close();
  }
}

– Registrando a temperatura em banco de dados MySQL

O primeiro procedimento a ser executado na função loop() é o envio de uma mensagem através da porta serial avisando ao usuário que algum tipo de manipulação no banco de dados está sendo executada.

Serial.println("Executando sentença");

Em seguida, realiza-se a leitura da porta de entrada analógica (através da função analogRead()) na qual está conectado o sensor e armazena-se o resultado na variável leitura.

leitura = analogRead(LM35);

Posteriormente, realizamos a conversão do valor inteiro adquirido para valores de temperatura. O cálculo apresentado e toda explicação sobre o sensor de temperatura LM35 estão presentes no nosso tutorial LM35 – Medindo a temperatura com Arduino.

leituraconvertida = (float(analogRead(LM35))*5/(1023))/0.01;

O próximo passo consiste na conversão do valor de temperatura de float para string. Isso deve ser feito para que este valor possa ser inserido em uma sentença (lembre que elas são montadas sobre um vetor de char) e assim, possa ser utilizado para manipular as informações do banco de dados.

A função utilizada para cumprir este propósito é a dtostrf(). Nesta função, existem quatro parâmetros, onde estes são: a variável do tipo float que queremos converter, o número de algarismos que o resultado da conversão deve ter (incluindo a vírgula), o número de casas após a vírgula e o vetor de char em que será armazenada a informação retornada por esta função.

dtostrf(leituraconvertida, 4, 1, valortemp);

Veja com mais detalhes o funcionamento desta função:

Após a conversão do valor citado, utilizamos a função sprintf() construir a sentença contendo a instrução que será utilizada na manipulação do banco de dados. O primeiro parâmetro desta função consiste na variável do tipo char na qual será armazenada a sentença após ser construída, o segundo, deve conter a variável que armazenou a parte textual da frase e o local onde será inserida a variável (%s) e o terceiro parâmetro é justamente a variável que será inserida no local especificado no segundo parâmetro.

sprintf(sentenca, INSERIR_TEMP, valortemp);

Veja um esquema detalhado do funcionamento da função:

Em seguida, realizamos o mesmo procedimento apresentado anteriormente para manipular o banco de dados, onde, primeiramente criamos o cursor, executamos uma sentença (deste vez é a sentença para incluir uma linha na tabela) e por fim, deletamos o cursor criado.

MySQL_Cursor *cur_mem = new MySQL_Cursor(&conn);
cur_mem->execute(sentenca)
delete cur_mem;

Por fim, utilizamos a função delay() para fazer com que o banco de dados seja preenchido apenas a cada 2 segundos

delay(2000);

Veja como ficou a nossa função loop()

void loop() {
 
  Serial.println("Recording data.");

  leitura = analogRead(LM35);
  conversao = (float(analogRead(LM35))*5/(1023))/0.01;

  dtostrf(conversao, 1, 1, temperatura);
  sprintf(sentenca, INSERIR _TEMP, temperatura);
  
  // Initiate the query class instance
  MySQL_Cursor *cur_mem = new MySQL_Cursor(&conn);
  // Execute the query
  cur_mem->execute(query);
  // Note: since there are no results, we do not need to read any data
  // Deleting the cursor also frees up memory used
  delete cur_mem;
delay(2000);
}

---

Considerações finais

Neste tutorial demonstramos um conteúdo novo e muito interessante para aqueles que gostam de desenvolver aplicações com uma placa Arduino mas não sabem como, por exemplo, registrar informações para uso posterior. Aqui, apresentamos os procedimentos necessários para fazer com que seja possível elaborar um projeto integrando o processo de aquisição de dados com o Arduino UNO e o armazenamento dos mesmos em um banco de dados de um servidor MySQL. Esperamos que você tenha gostado deste conteúdo e sinta-se à vontade para nos dar sugestões, críticas ou elogios. Lembre-se de deixar suas dúvidas nos comentários abaixo.