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:
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.
Conectando o Arduino ao computador
Primeiramente, conecte seu Arduino ao computador e abra a IDE Arduino. Em seguida, é necessário selecionar a porta COM na qual o Arduino está conectado (este procedimento pode ser feito clicando no menu Ferramentas (tools) e em seguida escolhendo-se a porta correspondente no submenu Porta (port). Neste caso, a porta na qual está o Arduino é apresentada da seguinte maneira: COM3 (Arduino UNO).
Por fim, garanta também que o tipo de placa apropriado esteja selecionado (isso pode ser feito acessando o menu Ferramentas (tools) e o submenu Placa (board)).
– 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.
Adquirindo e instalando a biblioteca que será utilizada
Para adquirir a biblioteca em questão, basta acessar o link apresentado anteriormente, clicar no botão clone or Download e por fim, no botão Download ZIP, conforme a figura abaixo.
Após a realização do download dos arquivos compactados no formato ZIP, abra a IDE do Arduino, selecione o menu Sketch, o submenu Incluir Bilioteca e por fim, basta clicar na opção Adicionar biblioteca .ZIP (Add ZIP Library) e encontrar o arquivo que acabou de ser baixado.
Uma outra forma de fazer isso é extrair o conteúdo do arquivo ZIP dentro da pasta Libraries (onde foi instalada a IDE do Arduino).
– 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.
O primeiro passo para que seja possível realizar a integração do Arduino com um banco de dados MySQL consiste em criar um usuário para acessar o servidor, bem como, a sua senha de acesso.
Quando nós instalamos um servidor MySQL em um computador, um usuário padrão chamado root (juntamente com uma senha definida pelo usuário) é criado no momento da instalação, porém, recomenda-se que criemos um novo usuário para entrar no servidor através do mesmo. Este procedimento deve ser realizado por dois motivos, onde o primeiro é que o próprio desenvolvedor da biblioteca recomenda que isto seja feito e segundo por que existem vários relatos de que o Arduino não consegue se conectar ao servidor através do usuário root.
Para realizar este procedimento, basta entrar no terminal do servidor MySQL. Isto pode ser feito, primeiramente, acessando o Prompt de comando e percorrendo o caminho até a pasta onde o servidor foi instalado e em seguida, utilizando o comando apresentado na figura a seguir:
Após a realização do passo anterior, você deverá digitar a senha do usuário root (definida na instalação do servidor) e então será possível acessar diretamente o terminal.
Na figura anterior, criamos um usuário chamado arduino, o qual, está atrelado a uma senha também nomeada arduino. O símbolo % determina que qualquer IP pode entrar no servidor MySQL através deste usuário. Obviamente, em termos de segurança, este não é o procedimento mais adequado, no entanto, para nossa demonstração, é suficiente.
Agora que já criamos o usuário, devemos criar um banco de dados dentro do servidor, chamado banco_arduino. Este procedimento é bastante simples e pode ser realizado da seguinte maneira:
Por fim, devemos criar uma tabela (que será preenchida pelo Arduino UNO), que por sua vez, será o local onde serão inseridas as informações referentes aos valores de temperatura provenientes do sensor de temperatura LM35. Queremos uma tabela com o seguinte formato:
Para isto, devemos proceder conforme a figura abaixo:
Veja como ficou a tabela criada
Neste momento, temos todos os pré-requisitos necessários para começarmos a realizar a aplicação proposta neste tutorial.
– 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.
53 Comments
Deixe uma pergunta, sugestão ou elogio! Estamos ansiosos para ter ouvir!Cancelar resposta
Esse site utiliza o Akismet para reduzir spam. Aprenda como seus dados de comentários são processados.
Blz Daniel!
Muito obrigado pelo post, foi de muita valia!
Só fiz uma pequena alteração na linha 52 do seu código: 0.1 para converter a leitura corretamente.
Bom dia galera, estou tendo um probelma de Exception (28), e quando vai conectar ao banco de dados, alguem teria uma ideia de como resolver este problema?
Boa tarde, gostaria de saber como enviar 2 valores para o banco. Estou coletando corrente elétrica com um sensor SCT e pretendo acrescentar um sensor de temperatura! Desde já obrigado!
Boa noite,
Estou utilizando o DHT11 e fiz as adaptações que acho que seja correta, porem da o seguinte erro: ERROR: Class requires connected server.
ERROR: Class requires connected server.
Alguém consegue me ajudar?
#include
#include
#include
#include
#include
#define DHTPIN A1 //Pino de conexão
#define DHTTYPE DHT11 // DHT11
DHT dht (DHTPIN, DHTTYPE);
char sentenca[128];
char valortemp[10];
char valorumid[10];
byte mac_addr[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
IPAddress server_addr(192, 168,15,1); //ip do Arduino
char user[] = “arduino”;
char password[] = “arduino”;
char BANCODEDADOS[] = “USE banco_arduino”;
char INSERIR_TEMP[] = “INSERT INTO registrotemp (temperatura) VALUES (%s)”;
char INSERIR_UMID[] = “INSERT INTO registrotemp (umidade) VALUES (%s)”;
EthernetClient client;
MySQL_Connection conn((Client *)&client);
void setup()
{
Serial.begin(115200);
while (!Serial);
Serial.println (“DHT11 teste!”); // teste com sensor
dht.begin();
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;
}
}
void loop()
{
// A leitura da temperatura e umidade pode levar 250ms!
// O atraso do sensor pode chegar a 2 segundos.
float h = dht.readHumidity();
float t = dht.readTemperature();
// testa se retorno é valido, caso contrário algo está errado.
if (isnan(t) || isnan(h))
{
Serial.println(“Falha na leitura DHT”);
}
else
{
Serial.print(“Umidade: “);
Serial.print(h);
Serial.print(” %t”);
Serial.print(“Temperatura: “);
Serial.print(t);
Serial.println(” *C”);
}
Serial.println(“Executando sentença”);
dtostrf(t, 4, 1, valortemp);
sprintf(sentenca, INSERIR_TEMP, valortemp);
dtostrf(h, 4, 1, valorumid);
sprintf(sentenca, INSERIR_UMID, valorumid);
MySQL_Cursor *cur_mem = new MySQL_Cursor(&conn);
cur_mem->execute(sentenca);
cur_mem->execute(sentenca);
delete cur_mem;
delay(2000);
}
1. Banco de dados MySQL com Arduino e Shield Ethernet W5100 – Registrando temperatura em um banco de dados
2. Como posso usar o código para o Módulo Ethernet – Enc28j60?
3. Obrigado pelo trabalho Eu estava precisando para fazer um desenvolvimento de comunicação e armazenamento de dados do meu Protótipo, Projeto integrador da Faculdade. Que DEUS continue te abençoando.
Preciso gravar mais de um valor no banco de dados, como posso fazer isso???
preciso gravar 3 temperaturas
Depois de muitas tentativas, não funcionou.
MySQL_Connection.h
MySQL_Cursor.h
Não encontre esta duas bibliotecas onde posso encontrar ?
Boa noite, Nao consigo conectar o Arduino ao Mysql, me dá erro. Poderia me ajudar?
Cade o codigo do tutorial acima?, nao acho em lugar algum
Olá, esse código funciona com a shield w5500? porque nao consigo de forma alguma.
Olá, Daniel!
Primeiramente indicarei o que estou utilizando:
Placa Arduino Mega
Banco de Dados MySQL 8.0 Community
Não consigo comunicar meu Arduino ao meu banco de dados nem utilizando os exemplos. Passos realizados:
1) Criei o usuário no MySQL;
2) Conferi acesso total a todos os bancos e tabelas ao user Arduino com senha;
3) Criei o banco de dados conforme nome dos exemplos.
Com relação aos testes da placa e no prompt:
1) Apliquei um exemplo da biblioteca Ethernet para ver se havia problema na placa, mas não. Consegui ver as informações no HTML;
2) Apliquei o ping em um IP que conferi a placa e deu 4 envios com 4 respostas OK;
3) Apliquei no prompt netstat para ver o que estava ativo e mostrou o IP que conferi à placa, logo OK também.
Possibilidades negativas que vi na documentação oficial:
1) Um antivirus ou firewall estar bloqueando o acesso do Arduino ao Banco de Dados. Desliguei todas as ações do meu anti-vírus. Não deu certo.
Tentei todos os exemplos da biblioteca dando ao server_addr o IPv4 da minha máquina onde está o MySQL. Tentei até colocando outros IPs pra ver se dava uma sorte e funcionava, mas não deu certo também.
Não sei mais o que fazer, mas gostaria de fazer uma pergunta: será que eu devo baixar uma versão mais antiga do MySQL, uma vez que a última revisão da biblioteca para a parte de Ethernet Shield foi há 4 anos atrás? Vi na documentação oficial que eles o autor não garante a biblioteca para versões superiores a 5 do MySQL.
Olá Daniel! Excelente post. Agradeço em nome de muitaaaaa gente!
Teria algum post com o SIM800L ou similar em que o mesmo enviaria os dados para o MySQL sem usar a rede, ou seja diretamente por GPRS? Muito obrigado!
Existe alguma biblioteca para oracle data base?
Excelente tutorial!!! Estou usando no meu TCC…
Preciso só de uma ajuda: Não consigo visualizar os valores que foram preenchidos na tabela (select *from registros…)…
Sou informado que está (empty).
Fiz até a escrita de uma linha de forma manual (insert into…)…
A tabela é vista corretamente montada mas novos valores não são escritos pelo arduino.
A conexão está ok, adicionei até um printf pra ver que entrou no if que pergunta o usuário e senha…
Enfim, minhas ideias já se esgotaram e o google já não me ajuda mais rsrs…
Acho que só você agora.
Att. Seu conterrâneo e cliente.
Bom dia eu necessito de um recurso que programe em arduíno para um projeto, alguém pode indicar
Bom dia Daniel.
Fiz o procedimento, mas não consigo comunicação entre o arduino e o servidor.
A rotina do arduino funciona normalmente pois estou fazendo testes via serial, isso só deveria acontecer uma vez a conexão estivesse feita. Porém não recebo dados e não identifico a placa pelo mac na rede.
O que posso fazer? ALguma ideia?
Obrigado e parabéns pelo tutorial!
o meu aparece isso no serial:
Conectando…
A conexão falhou
Executando sentença
Executando sentença
Executando sentença
Executando sentença
Executando sentença
…
e nao preenche a tabela no banco de dados. O que eu faço?
É normal a biblioteca deixar o arduino lento? Estou utilizando um Mega.
Como eu faço para subir isso em um servidor na net? no lugar do IP posso colocar o endereço completo do Banco de dados?
Olá, parabéns pelo trabalho!
Fiquei com dúvidas sobre a inserção de novos sensores em conjunto com o LM35. Dupliquei todas as partes para inserir um sensor DHT11 no código, porém não entendi muito bem como funciona a parte da variável sentenca, o que ela faz exatamente e qual seu conteúdo? segue o código abaixo:
#include “DHT.h”
#include
#include
#include
#include
#define LM35 A0
#define DHTPIN A1 // pino do leitor de temperatura e humidade DHT11, conectado no A1
#define DHTTYPE DHT11
DHT dht (DHTPIN, DHTTYPE);
int leitura;
float leituraconvertida;
float umidadeDHT; // variavel da umidade do sensor DHT11
char sentenca[128];
char valortemp[10];
char valorumi [10];
byte mac_addr[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
IPAddress server_addr(192, 168, 1, 35);
char user[] = “arduino”;
char password[] = “arduino”;
char INSERIR_TEMP[] = “INSERT INTO registrotemp (temperatura) VALUES (%s)”;
char INSERIR_UMI [] = “INSERT INTO registrotemp (umidade) VALUES (%s)”;
char BANCODEDADOS[] = “USE banco_arduino”;
EthernetClient client;
MySQL_Connection conn((Client *)&client);
void setup()
{
Serial.begin(9600);
dht.begin();
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;
umidadeDHT = dht.readHumidity(); // recebe a umidade do sensor DHT
dtostrf(leituraconvertida, 4, 1, valortemp);
dtostrf(umidadeDHT, 4, 1, valorumi);
sprintf(sentenca, INSERIR_TEMP, valortemp);
sprintf(sentenca, INSERIR_UMI, valorumi);
MySQL_Cursor *cur_mem = new MySQL_Cursor(&conn);
cur_mem->execute(sentenca);
cur_mem->execute(sentenca);
delete cur_mem;
delay(2000);
}
muito bom o material, segue um pergunta no código:
if (conn.connect(server_addr, 3306, user, password))
{
delay(1000); execute(BANCODEDADOS);
delete cur_mem;
}
obrigado!
O site apagou minha pergunta.
Eu perguntei se o delay era realmente necessário neste trecho de código?
Boa noite Daniel. Eu tenho uma duvida. Vejo alguns exemplos que é utilizado um srvidor web php intermediando. Seria a melhor opção? Qual a diferença de persistir direto do Arduino no banco ou usando php? Obrigado
Boa tarde Daniel ,
parabéns pelo tutorial, muito bem explicado e detalhado, realmente muita gente precisa de um artigo como este, muito bom mesmo.
Já sou programador a tempos de php e mysql.
Mas estou com um problema,o sketch não consegue nem conectar no mysql, realmente já tentei varias coisas.
1-)Quanto ao usuário e senha, creio que não esta errado, pois tenho no servidor local alguns programa em php e gravo os registros nas tabelas do mysql.
2-) quanto ao IP do server_addr já peguei utilizando o ipconfig, DHCP AdrePrinter, ate o ip localhost ( 127.0..) utilizei, mas continua com “A conexão falhou”.
Estou utilizando: arduino uno e o shield ethernet W5100, onde já fiz outros programas e testes e funcionou.
Baixei as bibliotecas do MySQL do site recomendado neste tutorial
Par a testar utilizo o Monitor Serial – Velocidade 115200
Tem como listar o erro (Serial.println ) para verificar o que esta acontecendo ? pois somente mostra a mensagem de erro pré-definida “A conexão falhou”.
Preciso de ajuda, alguém pode me ajudar ?
Muito obrigado
Bruno
Boa Tarde!!!
por que será que o meu está dando esse erro “⸮⸮⸮~{⸮M⸮^⸮J⸮_⸮⸮⸮_⸮⸮⸮^⸮^⸮L⸮L⸮L⸮M⸮k⸮_⸮x⸮_⸮J”
Grato Pela Atenção!!!
Meu querido, tem como fazer uma consulta no banco de dados do ultimo valor inserido?
Fábio Barros,
Boa tarde Daniel, eu encontrei uma dificuldade em fazer a conexão com o banco de dados. Eu estou utilizando o DHT22, para o teste, porém não tive sucesso. Poderia me dar uma orientação?
Gostaria de sabor como transferir os dados armazenados no BD para uma pequena tela…
Daniel, gostei muito da sua explicação, porém fiquei com dúvida em um ponto: Seria apenas possível a conexão com o BD utilizando esse shield? Existem outros que também fazem essa conexão?
Amigo, você teve algum progresso?
Daniel boa tarde e Parabéns pelo excelente trabalho. Tenho uma dúvida, fiz tudo conforme o seu exemplo é na hora de gravar no BD ele diz que gravou e não grava nada. Sei que estou acessando corretamente, pois se troco a senha do usuário, da erro e não abre o banco.
Criei uma tabela com o ID do esp8266, campo de texto com 20 de tamanho.
O que pode ser ? Tem alguma ideia, desde ja agradeço sua atenção.
Boa tarde
eu gostaria de saber se tem uma forma de fazer com que os dados fiquem sendo coletados quando cair a internet, e quando voltar a conexão, os dados subam para o BD. Agradeço desde ja.
Abraço
Vinicius, certamente isto é possível, entretanto, não tenho como te ajudar de prontidão, vou pesquisar e entro em contato com você, pode ser?
Muito BOM, muito bem explicado. OK
Muito obrigado Daniel!
Funciona com o Ethernet ENC28J60? Estou em duvida pois parece ter a mesma função(sem a entrada sd) e é mais barato.
Certamente!
Estou desenvolvendo um projeto com Arduíno e isso me serviu muito! Muito bem explicado, porém, algo que não entendi muito, como eu faço pros dados adquiridos do Arduíno irem pro banco de dados?
Mariana, basicamente o que o código faz é criar uma string com as informações que você deseja e em seguida enviar para a linha de comando do MySQL (obviamente, este mecanismo ocorre por trás).
bom dia Daniel, ótimas dicas você teria algum exemplo de codigo cartão SD do arduino.
Muito obrigado pelo elogio Mizael! Infelizmente ainda não tenho o código que você deseja!
Po manw, tu salvou o TCC de um aluno de CC, muito Obrigado
Eu que agradeço Vinicius!
Daniel, sensacional seu tutorial, consegui resolver vários problemas do meu código estudando ele. Estou com outro problema: preciso fazer com que o arduino leia uma informação de determinada coluna diretamente no banco mysql e armazene em uma variável. Tem como fazer isso? Parabéns, e obrigado!
Sim, meu amigo, é possível! Irei fazer um tutorial abordando este assunto, no entanto, caso você tenha curiosidade em como proceder, dê uma olhadinha em um dos exemplos da biblioteca, pois, certamente tem um que faz este caminho inverso!
Voce ja fez este tutorial? pode mandar o link?
Oi, quando vou executar o arquivo ele me dá o erro
expected initializer before ‘char’
Como posso corrigir isso?
Abraços.
Você copiou o código certinho? Creio que possa ter ocorrido algum erro de sintaxe simples, como a falta de um “;” ou {}.
Daniel muito bom este tutorial publicado neste portal. Conteúdo muito bem explicado. Estava procurando entender exatamente sobre este assunto. Parabéns.
Muito obrigado pelo elogio Ubiratan!
Estamos trabalhando para ser referência e estamos muito contentes com o seu retorno.
Gostei muito da explicação, mas saberia informar como inserir mais de um valor na sentença, exemplo: 3 valores de temperatura.
char INSERIR_TEMP[] = “INSERT INTO registrotemp (temp,temp2,temp3) VALUES (%s,%s,%s)”;
sprintf(sentenca, INSERIR_TEMP, valortemp,valortemp2,valortemp3);
Já tentei mas não consegui.
George, vc teve uma solução para a sua pergunta, tenho o mesmo problema