Como fazer um registrador de dados para temperatura, pH e oxigênio dissolvido: 11 etapas (com fotos)

2025 Autor: John Day | [email protected]. Última modificação: 2025-01-13 06:58

Objetivos

• Faça um registrador de dados por ≤ $ 500. Ele armazena dados de temperatura, pH e OD com um carimbo de data / hora e usando comunicação I2C.
• Por que I2C (circuito integrado)? É possível empilhar tantos sensores na mesma linha, já que cada um deles possui um endereço único.

Passo 1:

Etapa 2: Compre as peças abaixo:

1. Arduino MEGA 2560, $ 35,
2. Adaptador de energia para placa Arduino, $ 5,98,
3. Módulo LCD I2C (display), $ 8,99,
4. Rompimento do Real-Time Clock (RTC), US $ 7,5,
5. Placa de breakout de cartão MicroSD, $ 7,5,
6. Cartão SD de 4 GB, $ 6,98,
7. Sensor digital à prova d'água DS18B20, US $ 9,95,
8. Sonda de pH + Kits + buffers padrão, $ 149,15,
9. Sonda DO + Kits + buffers padrão, $ 247,45,
10. Placa de ensaio, cabo jumper, $ 7,98,
11. (Opcional) Isolador de tensão, $ 24,

Total: $ 510,48

* Certas peças (como a placa genérica) podem ser compradas de outros fornecedores (eBay, vendedor chinês) por um preço mais baixo. As sondas de pH e OD são recomendadas para obtê-los da Atlas Scientific.

* Recomenda-se um multímetro para verificar a condutividade e a tensão. Custa cerca de US $ 10-15 (https://goo.gl/iAMDJo)

Etapa 3: Fiação

• Use cabos jumper / DuPont para conectar as peças conforme mostrado no desenho abaixo.
• Use o multímetro para verificar a condução.
• Verifique a fonte de tensão positiva (VCC) e o aterramento (GND) (é fácil confundir se você não estiver familiarizado com o circuito)
• Conecte o adaptador de energia e verifique o indicador de energia em cada parte. Na dúvida, use o multímetro para verificar se a tensão entre VCC e GND deve ser (5V)

Etapa 4: preparar o PH, os circuitos DO e o cartão SD

1. Mudar para I2C para circuitos de pH e DO
2. Os breakouts de pH e DO são enviados com comunicação serial como o modo padrão Transmitir / Receber (TX / RX). Para usar o modo I2C linha de relógio (SCL) e linha de dados (SDA), alterne o modo por (1): desconecte os cabos VCC, TX, RX, (2): pule TX para o aterramento para a sonda, PGND (não GND), (3) conecte o VCC ao circuito, (4): espere que o LED mude de verde para azul. Mais detalhes verifique na página 39 (Folha de dados para circuito de pH,
3. Faça a mesma etapa com o circuito DO
4. (se você sabe como fazer o upload do código de amostra para a placa, pode fazê-lo por meio do monitor serial)
5. Formate o cartão SD para o formato FAT

Etapa 5: preparar o software

1. Baixe o Arduino Integrated Development Environment (IDE),
2. Instale a biblioteca no Arduino IDE:
3. A maioria deles vem com o software Arduino. LiquidCrystal_I2C.h está disponível via GitHub
4. Instale o driver para USB. Para Arduino genuíno, pode não ser necessário instalar um. Para um genérico, você precisa instalar o driver CH340 (GitHub:
5. Verifique se você conectou a placa corretamente executando um teste de LED piscando
6. Como encontrar o endereço MAC da temperatura digital 18B20. Usando o modelo de scanner I2C no Arduino IDE com a sonda conectada. Cada dispositivo tem um endereço MAC exclusivo, portanto, você pode usar quantas sondas de temperatura com uma linha compartilhada (# 9). 18B20 usa um I2C de um fio, portanto, é um caso especial de método de comunicação I2C. Abaixo está um método para encontrar o MAC - Medical Access Control (“ROM” quando você executa o procedimento abaixo).

Etapa 6: iniciar a codificação

• Copie e cole o código abaixo no IDE do Arduino:
• Ou baixe o código (.ino) e uma nova janela deve aparecer no IDE do Arduino.

/*

Tutoriais de referência:

1. Registrador de temperatura, ORP, pH:

2. Protetor Digital Secured (SD):

Este código irá gerar dados para o monitor serial do Arduino. Digite comandos no monitor serial Arduino para controlar o circuito de pH EZO no modo I2C.

Modificado a partir dos tutoriais mencionados acima, principalmente do código I2C da Atlas-Scientific

Última atualização: 26 de julho de 2017 por Binh Nguyen

*/

#include // habilita I2C.

# define pH_address 99 // número I2C ID padrão para o circuito EZO pH.

# define DO_address 97 // número I2C ID padrão para o circuito EZO DO.

#include "RTClib.h" // Funções de data e hora usando um DS1307 RTC conectado via I2C e Wire lib

RTC_DS1307 rtc;

#include // Para biblioteca SD

#include // cartão SD para armazenar dados

const int chipSelect = 53; // precisa descobrir para o intervalo do Adafruit SD //

// DO = MISO, DI = MOSI, no pino ATmega nº: 50 (MISO), 51 (MOSI), 52 (SCK), 53 (SS)

char logFileName = "dataLT.txt"; // modifique logFileName para identificar seu experimento, por exemplo PBR_01_02, datalog1

id longo = 1; // o número de id para inserir a ordem de log

#incluir

LiquidCrystal_I2C lcd (0x27, 20, 4);

#incluir

#incluir

#define ONE_WIRE_BUS 9 // define o pino # para a sonda de temperatura

OneWire oneWire (ONE_WIRE_BUS);

Sensores de temperatura Dallas (& oneWire);

DeviceAddress ProbeP = {0x28, 0xC2, 0xE8, 0x37, 0x07, 0x00, 0x00, 0xBF}; // endereço MAC, exclusivo para cada sonda

String dataString; // a variante principal para armazenar todos os dados

String dataString2; // uma variante temporária para armazenar Temperatura / pH / DO para impressão

char computerdata [20]; // instrução da Atlas Scientific: fazemos uma matriz de caracteres de 20 bytes para armazenar os dados de entrada de um pc / mac / outro.

byte recebido_de_computador = 0; // precisamos saber quantos caracteres foram recebidos.

byte serial_event = 0; // um sinalizador para sinalizar quando os dados foram recebidos do pc / mac / outro.

código de byte = 0; // usado para conter o código de resposta I2C.

char pH_data [20]; // fazemos uma matriz de caracteres de 20 bytes para conter os dados de entrada do circuito de pH.

byte in_char = 0; // usado como um buffer de 1 byte para armazenar bytes vinculados do circuito de pH.

byte i = 0; // contador usado para o array ph_data.

int time_ = 1800; // usado para alterar o atraso necessário dependendo do comando enviado para o circuito de pH Classe EZO.

float pH_float; // float var usado para manter o valor flutuante do pH.

char DO_data [20];

// float temp_C;

void setup () // inicialização do hardware.

{

Serial.begin (9600); // habilita a porta serial.

Wire.begin (pH_address); // habilita a porta I2C para a sonda de pH

Wire.begin (DO_address);

lcd.init ();

lcd.begin (20, 4);

lcd.backlight ();

lcd.home ();

lcd.print ("Olá PBR!");

lcd.setCursor (0, 1);

lcd.print ("Inicializando…");

Serial.print ("RTC é…");

if (! rtc.begin ())

{

Serial.println ("RTC: Relógio em tempo real … NÃO ENCONTRADO");

while (1); // (Serial.println ("RTC: Relógio em tempo real… ENCONTRADO"));

}

Serial.println ("RUNNING");

Serial.print ("Relógio em tempo real …");

if (! rtc.isrunning ())

{rtc.adjust (DateTime (F (_ DATE_), F (_ TIME_)));

}

Serial.println ("FUNCIONAMENTO");

lcd.setCursor (0, 0);

lcd.println ("RTC: OK");

Serial.print ("cartão SD …"); // veja se o cartão está presente e pode ser inicializado:

if (! SD.begin (chipSelect))

{Serial.println ("Falha"); // não faça mais nada:

Retorna;

}

Serial.println ("OK");

lcd.setCursor (0, 1);

lcd.println ("cartão SD: OK");

Serial.print ("Arquivo de log:");

Serial.print (logFileName);

Serial.print ("…");

Arquivo logFile = SD.open (logFileName, FILE_WRITE); // abre o arquivo. "datalog" e imprime o cabeçalho

if (logFile)

{

logFile.println (",,,"); // indica que havia dados na execução anterior

Cabeçalho da string = "Data -Hora, Temp (C), pH, DO";

logFile.println (cabeçalho);

logFile.close ();

Serial.println ("PRONTO");

//Serial.println(dataString); // imprime na porta serial também:

}

else {Serial.println ("erro ao abrir datalog"); } // se o arquivo não estiver aberto, aparecerá um erro:

lcd.setCursor (0, 2);

lcd.print ("Arquivo de log:");

lcd.println (logFileName);

atraso (1000);

sensores.begin ();

sensores.setResolution (ProbeP, 10); // 10 é a resolução (10 bits)

lcd.clear ();

id = 0;

}

void loop ()

{// o loop principal.

dataString = String (id);

dataString = String (',');

DateTime now = rtc.now ();

dataString = String (now.year (), DEC);

dataString + = String ('/');

dataString + = String (now.month (), DEC);

dataString + = String ('/');

dataString + = String (now.day (), DEC);

dataString + = String ('');

dataString + = String (now.hour (), DEC);

dataString + = String (':');

dataString + = String (now.minute (), DEC);

dataString + = String (':');

dataString + = String (agora.segundo (), DEC);

lcd.home ();

lcd.print (dataString);

sensores.requestTemperatures ();

displayTemperature (ProbeP);

Wire.beginTransmission (pH_address); // chame o circuito pelo seu número de ID

Wire.write ('r'); // código rígido r para ler continuamente

Wire.endTransmission (); // termina a transmissão de dados I2C.

tempo de atraso_); // aguarde o tempo correto para que o circuito conclua sua instrução.

Wire.requestFrom (pH_address, 20, 1); // chame o circuito e solicite 20 bytes (pode ser mais do que precisamos)

while (Wire.available ()) // há bytes para receber

{

in_char = Wire.read (); // recebe um byte.

if ((in_char> 31) && (in_char <127)) // verifique se o char é utilizável (imprimível)

{

pH_data = in_char; // carregue este byte em nosso array.

i + = 1;

}

if (in_char == 0) // se vemos que foi enviado um comando nulo.

{

i = 0; // redefine o contador i para 0.

Wire.endTransmission (); // termina a transmissão de dados I2C.

pausa; // sai do loop while.

}

}

serial_event = 0; // redefine o sinalizador de evento serial.

dataString2 + = ",";

dataString2 + = String (pH_data);

Wire.beginTransmission (DO_address); // chame o circuito pelo seu número de ID

Wire.write ('r');

Wire.endTransmission (); // terminar a transmissão de dados I2C

tempo de atraso_); // aguarde o tempo correto para o circuito completar suas instruções

Wire.requestFrom (DO_address, 20, 1); // chama o circuito e solicita 20 bytes

while (Wire.available ()) // há bytes para receber.

{

in_char = Wire.read (); // recebe um byte.

if ((in_char> 31) && (in_char <127)) // verifique se o char é utilizável (imprimível), caso contrário, o in_char contém um símbolo no início do arquivo.txt

{DO_data = in_char; // carregue este byte em nosso array

i + = 1; // incorre no contador para o elemento da matriz

}

if (in_char == 0)

{// se virmos que foi enviado um comando nulo

i = 0; // redefine o contador i para 0.

Wire.endTransmission (); // termina a transmissão de dados I2C.

pausa; // sai do loop while.

}

}

serial_event = 0; // redefine o sinalizador de evento serial

pH_float = atof (pH_data);

dataString2 + = ",";

dataString2 + = String (DO_data);

lcd.setCursor (0, 1);

lcd.print ("Temperatura / pH / DO");

lcd.setCursor (0, 2);

lcd.print (dataString2);

dataString + = ',';

dataString + = dataString2;

Arquivo dataFile = SD.open (logFileName, FILE_WRITE); // abre o arquivo. observe que apenas um arquivo pode ser aberto por vez, portanto, você deve fechar este antes de abrir outro.

if (dataFile) // se o arquivo estiver disponível, grave nele:

{

dataFile.println (dataString);

dataFile.close ();

Serial.println (dataString); // imprime na porta serial também:

}

else {Serial.println ("erro ao abrir arquivo datalog"); } // se o arquivo não estiver aberto, aparecerá um erro:

lcd.setCursor (0, 3);

lcd.print ("Executando (x5m):");

lcd.setCursor (15, 3);

lcd.print (id);

id ++; // aumenta um ID na próxima iteração

dataString = "";

atraso (300000); // atrasar 5 minutos = 5 * 60 * 1000 ms

lcd.clear ();

} // fim do loop principal

void displayTemperature (DeviceAddress deviceAddress)

{

float tempC = sensores.getTempC (deviceAddress);

if (tempC == -127,00) lcd.print ("Erro de temperatura");

else dataString2 = String (tempC);

} // o código termina aqui

• Escolha a porta COM correta via Arduino IDE em Ferramentas / Porta
• Escolha a placa Arduino certa. Usei o Mega 2560 porque tem mais memória interna. Arduino Nano ou Uno funciona bem com esta configuração.
• Verifique e codifique e faça upload do código

Etapa 7: Resultados na fiação (podem ser melhorados) e na tela LCD

• Aviso: Eu encontrei o ruído da sonda DO para a sonda de pH após 2-3 meses de operação contínua. De acordo com a Atlas Scientific, um isolador de tensão em linha é recomendado quando as sondas de pH e condutividade estão operando juntas. Mais detalhes estão na página 9 (https://goo.gl/d62Rqv)
• Os dados registrados (o primeiro possui caracteres não impressos antes dos dados de pH e DO). Eu filtrei para o código, permitindo apenas caracteres imprimíveis.

Etapa 8: importar dados e fazer um gráfico

1. Importar dados do texto na guia DADOS (Excel 2013)
2. Separe os dados com vírgulas (por isso é útil ter vírgulas após cada entrada de dados)
3. Trace os dados. Cada dado abaixo possui cerca de 1700 pontos. O intervalo de medição é de 5 minutos (ajustável). O mínimo para os circuitos DO e pH lerem os dados é de 1,8 segundos.

Etapa 9: Calibração

1. O sensor de temperatura digital (18B20) pode ser calibrado ajustando a diferença diretamente ao. Caso contrário, se a compensação e a inclinação exigirem calibração, você pode fazer alterando os valores na linha # 453, DallasTemperature.cpp na pasta / libraries / DallasTemperature.
2. Para sondas de pH e OD, você pode calibrar as sondas com as soluções que as acompanham. Você deve usar o código de amostra da Atlas Scientific e seguir as instruções deste arquivo.
3. Siga as páginas 26 e 50 para a sonda de pH (https://goo.gl/d62Rqv) para calibração e compensação de temperatura, e também as páginas, 7-8 e 50 para a sonda de OD (https://goo.gl/mA32mp). Primeiro, reenvie o código genérico fornecido pelo Atlas, abra o Monitor Serial e digite um comando adequado.

Etapa 10: Excesso de fiação?

1. Você pode eliminar o cartão SD e o módulo de relógio em tempo real usando o Dragino Yun Shield para placas Arduino (https://goo.gl/J9PBTH). O código precisava ser modificado para funcionar com o Yun Shield. Este é um bom lugar para começar (https://goo.gl/c1x8Dm)
2. Ainda muita fiação: a Atlas Scientific fez um guia para seus circuitos EZO (https://goo.gl/dGyb12) e placa sem solda (https://goo.gl/uWF51n). A integração da temperatura digital 18B20 está aqui (https://goo.gl/ATcnGd). Você precisa estar familiarizado com os comandos do Raspbian (uma versão do Debian Linux) em execução no Raspberry Pi (https://goo.gl/549xvk)

Etapa 11: Reconhecimento:

Este é meu projeto paralelo durante minha pesquisa de pós-doutorado, na qual trabalhei em um fotobiorreator avançado para cultivar microalgas. Então achei necessário creditar que as partes deram condições para que isso acontecesse. Em primeiro lugar, a concessão, DE-EE0007093: "Enriquecimento e entrega de CO2 atmosférico (ACED)", do Departamento de Energia dos EUA, Escritório de Eficiência Energética e Energia Renovável, Biocombustíveis e Bioprodutos de Algas Alvejados. Agradeço ao Dr. Bruce E. Rittmann, do Biodesign Swette Center for Environmental Biotechnology, Arizona State Univesity, por me dar a oportunidade de mexer na eletrônica e no Arduino. Fui formado em engenharia ambiental, principalmente química, um pouco de microbiologia.