Construir um Módulo de Luminosidade com AtHome: 7 Passos

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

AtHome é um projeto de estudante totalmente open source e openhardware feito pelo grupo AtHome da Epitech, com o objetivo de desenvolver uma solução conectada de vários módulos de sensores individuais se comunicando com um banco de dados auto-hospedado, expondo uma API usada para alimentar um aplicativo de smartphone e um aplicativo da web. Os módulos monitoram o ambiente interno de uma casa e são capazes de dar um feedback visual ao usuário, passando do verde (bom) ao vermelho (ruim) e os dados transmitidos são visíveis pelo usuário através da comunicação serial de um módulo ou no nossos aplicativos, se você usá-los.

Embora este projeto ainda esteja em desenvolvimento ativo, as funcionalidades básicas de nossos módulos já estão prontas e supostamente fáceis de usar para desenvolver módulos personalizados. Então, é por isso que estou propondo que você veja como construir seu próprio módulo simples com este exemplo de módulo de luminosidade.

Esses módulos são basicamente construídos com uma placa compatível com Arduino (um núcleo parcial do Arduino deve ser suficiente, desde que tenha Stream, Wire e suporte para stream UART), um LED (vermelho ou RGB) que fica vermelho em caso de problema, um sensor, uma fonte de alimentação (fonte de alimentação de parede ou bateria) e uma caixa de corte a laser.

Sim, definitivamente não é novo, há muitos projetos de sensores, mas esperamos que outros recursos, como detecção de problemas de saúde, comunicação e armazenamento de informações em um servidor auto-hospedado e aplicativo de visualização ajudem você. Ou se você quer apenas monitorar sua casa, projetos simples ou não menos interessantes:)

Etapa 1: reunir componentes

Para este projeto, você precisará de alguns componentes para construir seu módulo AtHome:

• 1x placa compatível com Arduino: aqui vou usar um Arduino UNO (mas também funciona com outras placas, como TI Launchpads e placas ESP8266)
• 1x sensor: usarei um sensor de luminosidade TSL2561 (a lista de sensores compatíveis está disponível na documentação de nossa biblioteca)
• 1x led: Vou usar um LED RGB Chainable Grove aqui (mas também pode ser um led vermelho simples ou um NeoPixel)
• Dupont Wires

A lista de componentes compatíveis está disponível na documentação do nosso projeto.

Etapa 2: Instalando nossa biblioteca

Para instalar nossa biblioteca, você precisará fazer o download de nosso repositório (vamos publicá-lo mais tarde na lista de IDE do Arduino e PlatformIO) com este link:

gitlab.com/Woodbox/Framework/-/jobs/artifacts/master/download?job=deploy

Em seguida, vá no IDE do Arduino e escolha "Sketch> Incluir biblioteca> Adicionar biblioteca. ZIP…". Em seguida, selecione o arquivo zip denominado "artifacts.zip" e clique em "OK".

Etapa 3: instalando as bibliotecas necessárias

Para funcionar, nossa biblioteca precisa que algumas outras bibliotecas sejam instaladas em seu computador:

• Biblioteca Arkhipenko TaskScheduler
• Biblioteca de sensores de luz digital SEEED Studio Grove
• Biblioteca LED RGB Chainable SEEED Studio Grove
• Biblioteca Adafruit NeoPixel

Você pode instalá-los através do gerenciador de bibliotecas do IDE Arduino, indo em "Sketch"> "Incluir Biblioteca"> "Gerenciar bibliotecas …".

Na nova janela que se abre, escreva na barra de pesquisa branca o nome da biblioteca que deseja instalar e clique em seu bloco. Um botão "Instalar" aparecerá, você só precisa clicar nele e o IDE irá baixá-lo e instalá-lo para você.

Etapa 4: montagem do módulo

Começaremos com o sensor. Conecte através de um fio o pino VCC do TSL2561 ao pino 5V do Arduino, o pino GND do sensor a um dos pinos GND do Arduino e os pinos SDA e SCL do sensor aos pinos SDA e SCL do Arduino. Agora você está pronto!

Agora, conecte o pino VCC do LED Grove Chainable RGB ao pino 5V do Arduino e o pino GND do LED ao segundo GND do Arduino. Se você for um Arduino com apenas um pino de 5 V, pode usar uma placa de ensaio para conectar o 5v do Arduino a uma linha + da placa de ensaio e conectar todos os seus componentes de pinos de 5 V nele, ou soldá-los juntos em um pedaço de stripboard ou use conectores wago ou o que preferir. Agora, conecte o pino CI do seu LED ao pino 7 do seu Arduino e o pino DI do seu LED ao pino 8 do seu Arduino. Se você não tem esse LED, não se preocupe, é possível usar o LED embutido em sua placa Arduino ou um clássico com apenas uma pequena alteração no código.

Etapa 5: Escrevendo o esboço do módulo de luminosidade

Vamos criar um novo esboço e escrever o código para nosso módulo.

Se não estiver interessado na explicação do esboço, você pode simplesmente copiar e colar em seu IDE Arduino:

#incluir

usando LightModule = AtHomeModule; Stream * streams = {& Serial, nullptr}; GroveChainableLED:: Pins grovePins = {7, 8}; LED GroveChainableLED (& grovePins); LightModule * module = LightModule:: getInstance (); void setup () {// coloque seu código de configuração aqui, para ser executado uma vez: Serial.begin (9600); módulo-> setStreams (streams); GroveDigitalLightSensor * lightSensor = novo GroveDigitalLightSensor (); módulo-> setSensor (lightSensor); módulo-> setDisplay (& led); módulo-> configuração (); } void loop () {// coloque seu código principal aqui, para executar repetidamente: module-> run (); }

Se quiser entender tudo o que esse código está fazendo, você pode ler o seguinte ou, se não estiver interessado, pule diretamente para a próxima etapa.

Para começar, precisamos incluir nossa biblioteca em nosso esboço, escrevendo esta linha no topo do esboço:

#incluir

Agora, precisamos criar um alias para o objeto de módulo que usaremos. Você pode vê-lo como uma caixa com vários botões usados para alterar seus componentes, iniciá-lo, interrompê-lo, etc. Como é uma caixa construída por um modelo (como o modelo usual que usamos para projetos como humanos, ele tem uma base inicial e o compilador do Arduino constrói o código final com base nos parâmetros que fornecemos a ele) definindo o tipo que representa um valor de sensor e o número de valores de sensor que queremos manter na memória, é especificado em seu nome e normalmente deve ser repetido toda vez que quisermos usá-lo. O que é um pouco chato, é por isso que associaremos um novo nome, um alias, ao nome completo desta caixa.

Digamos, por exemplo, que eu queira que essa caixa seja chamada de "LightModule", pois ela será usada para implementar um módulo de monitoramento de luminosidade e quero manter apenas 1 valor por vez. A luminosidade é representada em lux como um tipo integral por nosso sensor TSL2561, que é representado como um uint16_t por computadores. Nosso alias será assim:

usando LightModule = AtHomeModule;

a palavra-chave "usando" significa que estamos criando um alias e o nome que damos a ele corresponde à sequência após o caractere "=".

"AtHomeModule" é o nome real desta caixa que estamos dando um novo nome, e os parâmetros que definem a representação do valor e o número de valores mantidos na memória estão listados entre "".

Agora, quando usaremos mais tarde o nome "AtHomeModule", o Arduino saberá que ele se refere ao nome completo "AtHomeModule".

Se você quiser que sua caixa seja capaz de manter 5 valores na memória ao invés de 1, você só precisa substituir o "1" por "5" e o Arduino irá gerar para você um tipo diferente de caixa capaz de fazer o que você quiser. Observe, no entanto, que se o módulo estiver programado para enviar seus valores antes de ter tempo de medir efetivamente 5 valores do sensor, você nunca verá 5 deles sendo enviados, pois ele envia apenas os novos valores desde o último upload.

Em seguida, precisamos criar um array de ponteiros contendo ponteiros em fluxos Arduino usados pelo módulo para se comunicar, sempre terminado pelo keyworkd "nullptr". Aqui, estou usando apenas o stream "Serial" do Arduino que se comunica com o computador pela porta USB, então o array fica assim:

Stream * streams = {& Serial, nullptr};

O caractere "*" significa que o tipo é um ponteiro (a localização do elemento, não o próprio elemento) e os colchetes "" significam no Arduino que é um array, portanto, podemos colocar vários valores.

Em seguida, precisamos criar nosso LED. Para fazer isso, precisamos escrever as duas linhas a seguir;

GroveChainableLED:: Pins grovePins = {7, 8};

LED GroveChainableLED (& grovePins);

Se você não tem um LED Grove RGB, mas ainda deseja um feedback visual, pode fazê-lo com uma simples mudança no esboço. Substitua as duas linhas anteriores por esta linha:

LedLED monocromático (LED_BUILTIN);

Nesta configuração, o LED verde embutido acenderá enquanto o valor monitorado estiver bom para a integridade e desligará quando estiver fora de vinculação. Se você preferir que ele seja ligado quando estiver fora de união (porque você está usando, por exemplo, um LED vermelho em vez do verde no pino 13), você pode usar esta linha:

LedLED monocromático (LED_BUILTIN, verdadeiro);

A próxima etapa é criar nosso próprio módulo. Isso é feito na primeira vez que obtemos sua localização na memória chamando o método "getInstance", assim:

LightModule * module = LightModule:: getInstance ();

Em seguida, precisamos definir os parâmetros na função "setup ()" do Arduino, começando pela inicialização da porta "Serial" como de costume nos esboços do Arduino:

Serial.begin (9600);

Criamos o sensor de luz escrevendo esta linha:

GroveDigitalLightSensor * lightSensor = novo GroveDigitalLightSensor ();

Em seguida, dizemos ao nosso módulo para usar nosso array de ponteiros no Arduino Stream para se comunicar por meio deles:

módulo-> setStreams (streams);

Também pedimos ao nosso módulo para usar nosso sensor de luz para monitorar a intensidade da luz onde o módulo está:

módulo-> setSensor (lightSensor);

Dizemos ao nosso módulo para usar nosso LED para nos dar um feedback visual:

módulo-> setDisplay (& led);

Por fim, informamos ao nosso módulo que ele está pronto para fazer qualquer configuração interna necessária, chamando sua própria função de "configuração":

módulo-> configuração ();

Nossa última etapa agora é chamar a função "run ()" do nosso módulo, que é projetada para ser chamada a cada iteração da função "loop" do Arduino escrevendo esta linha dentro da função "loop":

módulo-> run ();

Agora, nosso esboço está finalmente pronto para ser carregado no Arduino e testar nosso módulo!

Etapa 6: Testando Nosso Módulo AtHome

Para fazer o upload do esboço para o Arduino, escolha sua placa Arduino UNO em "Ferramentas"> "Porta"> "[COMx ou / dev / x] (Arduino / Genuino UNO)".

Por último, basta clicar no botão "Upload" (o botão do círculo com uma seta apontando para a direita, o segundo ícone da barra de ferramentas) para fazer o upload do sketch no seu quadro.

Está feito! Agora seu módulo deve estar funcionando e enviando valores para o seu computador visíveis no Serial Monitor do Arduino. Você pode verificar abrindo o "Monitor Serial" do Arduino no menu "Ferramentas" e você deve ter uma saída parecida com a segunda imagem do título desta etapa:)

Etapa 7: Construindo um Caso para o Módulo

Você pode construir uma caixa simples para o seu módulo cortando-a a laser em uma placa de madeira compensada de 3 mm.

Para fazer nossos estojos de caixa, usamos makercase para preparar um modelo nas dimensões desejadas que personalizamos mais tarde. Você encontrará o arquivo svg do módulo de luminosidade anexado a esta etapa.

Em seguida, basta colar as faces, exceto uma para que você possa abri-la mais tarde, coloque seu circuito dentro e prenda o LED no orifício da caixa (usamos fita transparente para preencher o orifício e difundir a luz além de colar o LED na frente disso).

Agora é só adicionar uma bateria para alimentar seu Arduino, fechar o gabinete e seu módulo está pronto e deve estar com boa aparência:)