Registrador de dados de código aberto (OPENSDL): 5 etapas (com imagens)

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:38

O objetivo deste projeto é projetar, construir e testar um sistema de medição de baixo custo para estudos de Avaliação de Desempenho de Edifícios que inclua pelo menos temperatura, umidade relativa, iluminância e seja extensível a sensores adicionais, e desenvolver o protótipo desses dispositivos.

Isso resulta em um sistema personalizado e acessível que permite que as partes interessadas conduzam as medições necessárias para a avaliação do desempenho da construção de uma maneira eficiente e acessível, registrando vários parâmetros ambientais de uma vez. O registrador de dados de código aberto (OPENSDL) desenvolvido foi comparado com um registrador de dados HOBO U12-012. Este sistema homólogo disponível comercialmente pode medir 3 parâmetros, a saber: temperatura, UR e iluminância, e um canal externo para outros tipos de sensores. Um dispositivo de detecção diferente seria necessário para a medição de qualquer outro parâmetro. As características dos parâmetros a serem medidos são limitadas ao hardware e software proprietários, o que restringe o sistema à medição de certos parâmetros com precisões específicas. Um HOBO U12-012 custa cerca de ₹ 13.000 (US $ 185), enquanto o OPENSDL custa ₹ 4.605 (US $ 66), o que é quase um terço da contrapartida comercial.

Um registrador de dados de código aberto para monitorar temperatura, UR e níveis de luz (iluminância) com a ajuda de um Arduino Uno. Este é um DIY para desenvolver o registrador de dados OPENSDL.

Tempo necessário: 2-3 horas para solda, 5 horas para embalagem (4 horas - impressão 3D e 1 hora para corte a laser) Habilidades necessárias: Solda, pouco ou nenhum conhecimento em programação e eletrônica

Peças necessárias:

1. Arduino Uno com cabo
2. Escudo do registrador de dados
3. Bateria de célula tipo moeda CR1220
4. BME280 temperatura umidade pressão sensor breakout board
5. Placa de fuga do sensor de luz TSL2561
6. Módulo ESP01-8266 Wi-Fi
7. Conector RJ-9 macho e fêmea
8. Proteger cabeçalhos de empilhamento para Arduino
9. Cartão de memória SD (qualquer capacidade)
10. Placa de vetor (26 x 18 orifícios)
11. 8 pilhas AA porta-pilhas

Ferramentas necessárias:

• Ferro de soldar (35W)
• Fio de solda
• Cortador de arame
• Ferramenta Crimper
• Multímetro

Software necessário: Arduino IDE (1.0.5 ou superior)

Bibliotecas do Arduino usadas:

• Biblioteca de fios
• Biblioteca SparkFun TSL2561
• Biblioteca multisensor Cactus BME280
• Biblioteca de cartões SD
• Biblioteca SPI
• Biblioteca RTC

Nota: O sensor BME280 é um sensor de temperatura, umidade relativa e pressão muito preciso da Bosch. Da mesma forma, o DS1307 é um relógio de tempo real preciso da Maxim e o TSL2561 é um sensor de luz preciso. Existem alternativas menos caras e menos precisas para esses produtos, mas este tutorial foi direcionado a pessoas que estavam interessadas em coletar dados para criar aplicativos de avaliação de desempenho e de monitoramento que requerem alta precisão e exatidão. Isso significa que qualquer configuração específica de hardware e software (bibliotecas, código de programa) destinava-se estritamente aos produtos especificados.

Etapa 1: Montagem

O escudo do registrador de dados pode ser facilmente empilhado no topo da placa Arduino Uno. Este escudo fornece os recursos de registro de dados (manutenção de tempo e armazenamento de dados). O escudo teve que ser empilhado. Uma bateria de célula tipo moeda CR1220 teve que ser inserida no slot redondo fornecido para manter o relógio funcionando mesmo quando o Arduino está desligado. O cartão de memória SD deve ser inserido no slot de cartão integrado fornecido. Uma blindagem personalizada exclusiva foi desenvolvida usando pinos fêmea do conector RJ-9 e cabeçalhos de empilhamento de blindagem Arduino. Os conectores apropriados foram soldados nos locais apropriados para que a blindagem se encaixasse perfeitamente na placa Arduino. O Arduino tem 18 pinos de um lado e 14 pinos do outro. Os cabeçalhos com o mesmo número de pinos foram usados no mesmo espaçamento (18 pinos separados) que no Arduino. O espaço extra restante adjacente aos cabeçalhos foi usado para colocar o conector RJ-9.

Os cabeçalhos eram a melhor maneira de usar os pinos necessários, ao mesmo tempo que os tornava disponíveis para uso por outros componentes. Os sensores utilizados seguem o protocolo de comunicação I2C, que requer 4 pinos do Arduino, a saber: SDA (também disponível como A4), SCL (também disponível como A5), 3,3V e GND. Os quatro fios que saem do conector RJ-9 foram soldados nesses quatro pinos do conector. O número de conectores RJ-9 necessários depende do número de sensores. Neste projeto, foram usados 3 conectores RJ-9 (dois para BME280 e um para TSL2561). Os quatro fios que saem do conector RJ-9 foram codificados por cores e cada fio de cor foi designado como um pino específico para todos os conectores RJ-9. Deve-se observar que o código de cores pode variar nas diferentes peças RJ-9. Nesse caso, a localização do fio no conector deve ser observada. O conector RJ-9, após a soldagem, foi feito para grudar na placa vetorial utilizando um Feviqwik, para que fique fixo na superfície. Essas conexões podem ser verificadas usando o modo de continuidade no multímetro. Quando em modo de continuidade, o multímetro deve mostrar resistência zero. Conecte uma das pontas de prova do multímetro ao pino soldado e outra ponta de prova ao pino dentro do conector RJ-9. O multímetro deve emitir um tom, o que significa que as juntas de solda estão corretas e as conexões foram feitas corretamente. Se o tom não for emitido, verifique as juntas de solda. Da mesma forma, solde o conector RJ-9 com os mesmos fios conectando-se aos mesmos orifícios nas placas de quebra do sensor, ou seja, A4, A5, 3,3 V e GND. O sensor BME280 suporta dois endereços I2C, o que significa que dois sensores BME280 podem ser conectados ao mesmo controlador ao mesmo tempo. Enquanto isso, o endereço de um dos sensores deve ser alterado ligando as almofadas de solda no sensor. Um chip de conexão sem fio ESP-01 exigia as seguintes conexões com o Arduino.

ESP-01 --------- Arduino Uno

10 -------------------- TX

11 -------------------- RX

Vcc ---------------- CH_PD

Vcc ------------------- Vcc

GND ----------------- GND

Nota: - Os vários LEDs no Arduino Uno foram removidos para aumentar a vida útil da bateria. O LED indicador de energia, LEDs RX e TX foram removidos aquecendo as juntas de solda e pressionando o LED com uma pinça.

Etapa 2: configurar IDEs e bibliotecas

Antes de fazer qualquer programação, o Arduino IDE (Integrated Development Environment) deve ser baixado. A programação foi feita nesta plataforma. Diferentes bibliotecas foram necessárias para interagir com diferentes componentes do OPENSDL. As seguintes bibliotecas foram usadas para os componentes fornecidos.

Componente ------------------------------------------------- --------------Biblioteca

Sensor de temperatura e UR BME280 --------------------------------- Cactus_io_BME280_I2C.h

Sensor de luz------------------------------------------------ ---------------- SparkFun TSL2561.h

Relógio de tempo real ----------------------------------------------- ------------- RTClib.h

Soquete do cartão SD ----------------------------------------------- ------------- SD.h

Conexão I2C ------------------------------------------------ ------------- Wire.h

Uma biblioteca separada para comunicação com o ESP01 não é necessária, pois o código carregado no Arduino tem comandos AT, que são enviados para o monitor serial, de onde o ESP-01 pega as instruções. Então, basicamente, os comandos AT pelos quais o ESP01 é executado são impressos no Monitor Serial, que são tomados como um comando de entrada pelo ESP-01. Para instalar essas bibliotecas, após baixá-las, abra o IDE do Arduino, vá para Sketch -> Incluir Biblioteca -> Adicionar biblioteca. Zip e selecione as bibliotecas baixadas.

Etapa 3: Programando o sistema

Antes de programar o OPENSDL, conecte o Arduino a um laptop. Após conectar, vá para Ferramentas -> Porta e selecione a porta COM na qual o OPENSDL está conectado. Além disso, certifique-se de que em Ferramentas -> Placas, Arduino Uno esteja selecionado.

O OPENSDL foi desenvolvido para funcionar em 2 modos. No primeiro modo, ele armazena os dados no cartão SD na proteção do registrador de dados. No segundo modo, ele envia os dados pela Internet para um site usando um chip de Wi-Fi ESP-01. O programa para ambos os modos é diferente. Essas linhas de código podem ser copiadas e coladas diretamente no editor do IDE do Arduino e usadas diretamente. Uma vez no código, precisamos fazer algumas personalizações de acordo com nossas necessidades:

1. Altere manualmente o valor do atraso (1000) no final do código para alterar o intervalo de registro. O valor 1000 representa o intervalo em milissegundos.
2. Edite a linha de código que diz mySensorData = SD.open ("Logged01.csv", FILE_WRITE); e substitua Logged01 pelo nome de arquivo do nome de arquivo desejado. A extensão do arquivo também pode ser alterada modificando a extensão.csv logo após o nome do arquivo.
3. A equação de calibração obtida ao encontrar a correlação entre o sensor Mestre / de referência e o BME280 varia com cada sensor. Substitua esta linha de código pela equação para calibração dos sensores: Serial.print ((1.0533 * t2) -2.2374) - para sensor com endereço padrão (0x77), onde t2 é o valor lido do sensor de temperatura.

Um programa separado foi fornecido para programar o segundo modo disponível de OPENSDL, que é o sistema sem fio. O ESP-01 deve ser conectado ao OPENSDL de acordo com as conexões explicadas na Etapa # 2. Após concluir as conexões, conecte o Arduino ao laptop e carregue um esboço em branco no Arduino. Coloque o ESP-01 no modo de atualização e atualize o firmware para a atualização mais recente disponível. Após a atualização, certifique-se de conectar o pino de reinicialização do Arduino com o pino de 3,3 V, que ignora o bootloader do Arduino

Etapa 4: Fabricação

Um gabinete para OPENSDL foi criado para proteção e para melhorar a estética. Os invólucros foram desenvolvidos por impressão 3D usando material PLA, e o invólucro do microcontrolador foi desenvolvido por corte a laser da folha de MDF e colagem das peças. Os modelos impressos em 3D foram desenvolvidos usando o software SketchUp, e os desenhos 2D dxf para corte a laser foram criados usando o AutoCAD.

Para impressão 3D, os arquivos STL produzidos com o SketchUp foram abertos e verificados no software Ultimaker Cura 3.2.1. Certifique-se de que o material PLA é usado e o bico da impressora usado é para impressão de 0,4 mm. A placa de impressão da impressora 3D pode exigir cola para colar o objeto impresso em 3D. Mas quando a impressão é concluída, a cola cria uma forte adesão entre o objeto impresso e a placa de impressão.

Etapa 5: Código

O código (arquivos.ino) é feito para funcionar no software Arduino IDE. Aqui está o link para minha página no Github para o código e outros detalhes.

github.com/arihant93/OPENSDL

Não hesite em fazer perguntas sobre o projeto.

Obrigado.