Construiți un modul de luminozitate cu AtHome: 7 pași

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:45

AtHome este un proiect de student complet open source și openhardware realizat de grupul AtHome de la Epitech, cu scopul de a dezvolta o soluție conectată a mai multor module de senzori individuali care comunică cu o bază de date auto-găzduită, expunând un API utilizat pentru a alimenta o aplicație pentru smartphone și o aplicație web. Modulele monitorizează mediul interior al unei case și pot oferi utilizatorului un feedback vizual, trecând de la verde (bun) la roșu (rău), iar datele transmise sunt vizibile de către utilizator prin comunicarea serială a unui modul sau pe aplicațiile noastre dacă le utilizați.

Chiar dacă acest proiect este încă în curs de dezvoltare activă, funcționalitățile de bază ale modulelor noastre sunt acum gata și se presupune că sunt ușor de utilizat pentru a dezvolta module personalizate. De aceea, vă propun să vedeți cum să vă construiți propriul modul simplu cu acest exemplu de modul de luminozitate.

Aceste module sunt construite practic cu o placă compatibilă Arduino (un nucleu parțial Arduino ar trebui să fie suficient atâta timp cât are Stream, Wire și un suport UART stream), un LED (unul roșu sau RGB) devine roșu în caz de problemă, un senzor, o sursă de alimentare (alimentare de perete sau baterie) și o carcasă tăiată cu laser.

Da, cu siguranță nu este nou, există o mulțime de proiecte de senzori, dar sperăm că alte caracteristici, cum ar fi detectarea problemelor de sănătate, comunicarea și stocarea informațiilor pe un server auto-găzduit și aplicația de vizualizare vă vor ajuta. Sau dacă doriți doar să vă monitorizați casa, proiecte simple sau nu mai puțin interesante:)

Pasul 1: Strângerea componentelor

Pentru acest proiect, veți avea nevoie de câteva componente pentru a vă construi modulul AtHome:

• 1x placă compatibilă Arduino: aici voi folosi un Arduino UNO (dar funcționează și cu alte plăci precum TI Launchpads și plăci ESP8266)
• 1x senzor: voi folosi un senzor de luminozitate TSL2561 (lista senzorilor acceptați este disponibilă în documentația bibliotecii noastre)
• 1x led: voi folosi aici un LED RGB Grove Chainable (dar poate fi și un led roșu simplu sau un NeoPixel)
• Firele Dupont

Lista componentelor compatibile este disponibilă în documentația proiectului nostru.

Pasul 2: Instalarea bibliotecii noastre

Pentru a instala biblioteca noastră, va trebui să descărcați din depozitul nostru (îl vom publica mai târziu în lista Arduino IDE și PlatformIO) cu acest link:

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

Apoi, accesați ID-ul Arduino și alegeți „Sketch> Include Library> Add. ZIP Library…”. Apoi selectați fișierul zip numit „artifacts.zip” și faceți clic pe „OK”.

Pasul 3: Instalarea bibliotecilor necesare

Pentru a funcționa, biblioteca noastră are nevoie de alte biblioteci pentru a fi instalate pe computerul dvs.:

• Biblioteca Arkhipenko TaskScheduler
• Biblioteca SEEED Studio Grove Digital Light Sensor
• Bibliotecă LED RGB cu lanț Studio SEEED Studio Grove
• Biblioteca Adafruit NeoPixel

Le puteți instala prin managerul de bibliotecă al IDE Arduino, accesând „Sketch”> „Include Library”> „Gestionați bibliotecile …”.

În noua fereastră care se va deschide, scrieți în bara albă de căutare numele bibliotecii pe care doriți să o instalați, apoi faceți clic pe blocul acesteia. Va apărea un buton „Instalare”, trebuie doar să faceți clic pe el și IDE îl va descărca și îl va instala.

Pasul 4: Asamblarea modulului

Vom începe cu senzorul. Conectați printr-un fir pinul VCC al TSL2561 la pinul 5V al Arduino, pinul GND al senzorului la unul dintre pinul GND al Arduino și pinii SDA și SCL ai senzorului la pinii SDA și SCL ai Arduino. Acum ai terminat!

Acum, conectați pinul VCC al LED-ului RGB Grove Chainable la pinul de 5V al Arduino și pinul GND al LED-ului la al doilea GND al Arduino. Dacă sunteți Arduino ca un singur pin de 5V, puteți utiliza o placă pentru a conecta 5v de la Arduino la un rând + al plăcii și pentru a conecta toate componentele pinii de 5V pe el sau lipiți-le împreună pe o bucată de panou folosiți conectori wago sau orice preferați. Acum, conectați pinul CI al LED-ului dvs. la pinul 7 al Arduino-ului dvs. și pinul DI al LED-ului dvs. la pinul 8 al Arduino-ului dvs. Dacă nu aveți un astfel de LED, nu vă faceți griji, este posibil să utilizați LED-ul încorporat al plăcii dvs. Arduino sau unul clasic cu doar o mică modificare a codului.

Pasul 5: Scrierea schiței modulului de luminozitate

Să creăm o schiță nouă și să scriem codul pentru modulul nostru.

Dacă nu sunteți interesat de explicația schiței, puteți doar să o copiați și să o inserați în ID-ul dvs. Arduino:

#include

folosind LightModule = AtHomeModule; Flux * fluxuri = {& Serial, nullptr}; GroveChainableLED:: Pins grovePins = {7, 8}; Led LED GroveChainable (& grovePins); LightModule * module = LightModule:: getInstance (); void setup () {// puneți codul de configurare aici, pentru a rula o dată: Serial.begin (9600); module-> setStreams (fluxuri); GroveDigitalLightSensor * lightSensor = nou GroveDigitalLightSensor (); module-> setSensor (lightSensor); module-> setDisplay (& led); module-> setup (); } void loop () {// puneți codul principal aici, pentru a rula în mod repetat: module-> run (); }

Dacă doriți să înțelegeți tot ce face acest cod, puteți citi următoarele sau dacă nu sunteți interesat, puteți trece direct la pasul următor.

Pentru început, trebuie să includem biblioteca noastră în schița noastră, scriind acest rând în partea de sus a schiței:

#include

Acum, trebuie să creăm un alias la obiectul modul pe care îl vom folosi. Îl puteți vedea ca o cutie cu mai multe butoane folosite pentru a-i schimba componentele, a porni, a opri, etc. etc. Deoarece este o cutie construită de un șablon (ca un șablon obișnuit pe care îl folosim pentru proiecte ca oameni, are o bază de pornire și compilatorul Arduino construiește codul final pe baza parametrilor pe care i-i dăm) definind tipul reprezentând o valoare a senzorului și numărul de valori ale senzorului pe care dorim să le păstrăm în memorie, este specificat în numele său și ar trebui repetat în mod normal de fiecare dată când dorim să-l folosim. Ceea ce este puțin enervant, de aceea vom asocia un nume nou, un alias, cu numele complet al acestei casete.

Să presupunem, de exemplu, că vreau ca această casetă să fie numită „LightModule”, deoarece va fi utilizată pentru a implementa un modul de monitorizare a luminozității și vreau să păstrez doar o valoare la un moment dat. Luminozitatea este reprezentată în lux ca un tip integral de senzorul nostru TSL2561, care este reprezentat ca un uint16_t de către computere. Aliasul nostru va arăta astfel:

folosind LightModule = AtHomeModule;

cuvântul cheie „folosind” înseamnă că creăm un alias, iar numele pe care îl dăm imediat după acesta corespunde secvenței de după caracterul „=”.

„AtHomeModule” este numele real al acestei casete, dăm un nume nou, iar parametrii care definesc reprezentarea valorii și numărul de valori păstrate în memorie sunt listate între „”.

Acum, când vom folosi mai târziu numele „AtHomeModule”, Arduino va ști că se referă la numele complet „AtHomeModule”.

Dacă doriți ca caseta dvs. să poată păstra 5 valori în memorie în loc de 1, trebuie doar să înlocuiți „1” cu „5” și Arduino va genera pentru dvs. un alt tip de casetă capabilă să facă ceea ce doriți. Rețineți, totuși, că dacă modulul este programat să-și trimită valorile înainte de a avea timp să măsoare în mod eficient 5 valori ale senzorului, nu veți vedea niciodată 5 dintre acestea fiind trimise, deoarece trimite doar noile valori de la ultima încărcare.

Apoi, trebuie să creăm o serie de pointeri care să conțină pointeri pe fluxurile Arduino folosite de modul pentru a comunica, terminate întotdeauna de keyworkd „nullptr”. Aici, folosesc doar fluxul „Serial” al Arduino care comunică cu computerul prin portul USB, astfel încât matricea arată astfel:

Flux * fluxuri = {& Serial, nullptr};

Caracterul „*” înseamnă că tipul este un pointer (locația elementului, nu elementul în sine), iar parantezele „” înseamnă în Arduino că este o matrice, deci putem pune mai multe valori.

Apoi, trebuie să ne creăm LED-ul. Pentru a face acest lucru, trebuie să scriem următoarele două rânduri;

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

Led LED GroveChainable (& grovePins);

Dacă nu aveți un LED Grove RGB, dar doriți totuși un feedback vizual, îl puteți face cu o simplă schimbare în schiță. Înlocuiți cele două linii anterioare cu această linie:

LED monocromatic (LED_BUILTIN);

În această configurație, LED-ul verde încorporat se va aprinde atâta timp cât valoarea monitorizată este bună pentru sănătate și se va stinge când nu mai este legată. Dacă preferați să-l porniți atunci când este scos din funcțiune (pentru că utilizați, de exemplu, un LED roșu în loc de cel verde de pe pinul 13), puteți folosi în schimb această linie:

LED monocromatic (LED_BUILTIN, adevărat);

Următorul pas este crearea modulului nostru în sine. S-a făcut prima dată când obținem locația în memorie apelând metoda „getInstance”, astfel:

LightModule * module = LightModule:: getInstance ();

Apoi, trebuie să setăm parametrii în funcția „setup ()” a Arduino, începând cu inițializarea portului „Serial” ca de obicei în schițele Arduino:

Serial.begin (9600);

Creăm senzorul de lumină scriind această linie:

GroveDigitalLightSensor * lightSensor = nou GroveDigitalLightSensor ();

Apoi, îi spunem modulului nostru să folosească gama noastră de indicatori de pe Arduino Stream pentru a comunica prin intermediul acestora:

module-> setStreams (fluxuri);

De asemenea, îi spunem modulului nostru să utilizeze senzorul nostru de lumină pentru a monitoriza intensitatea luminii acolo unde este modulul:

module-> setSensor (lightSensor);

Îi spunem modulului nostru să utilizeze LED-ul nostru pentru a ne oferi un feedback vizual:

module-> setDisplay (& led);

În cele din urmă, îi spunem modulului nostru că este gata să facă orice configurație internă pe care trebuie să o facă apelând propria funcție de „configurare”:

module-> setup ();

Ultimul nostru pas este acum să apelăm la funcția „run ()” a modulului nostru, care este concepută pentru a fi apelată la fiecare iterație a funcției „buclă” a Arduino prin scrierea acestei linii în funcția „buclă”:

module-> run ();

Acum, schița noastră este în sfârșit gata pentru încărcare pe Arduino și testarea modulului nostru!

Pasul 6: Testarea modulului nostru AtHome

Pentru a încărca schița pe Arduino, alegeți placa Arduino UNO accesând „Instrumente”> „Port”> „[COMx sau / dev / x] (Arduino / Genuino UNO)”.

Ultimul lucru, trebuie doar să faceți clic pe butonul „Încărcați” (butonul cercului cu o săgeată îndreptată spre dreapta, a doua pictogramă a barei de instrumente) pentru a încărca schița în tablă.

Este gata! Acum modulul dvs. ar trebui să funcționeze și să trimită valori către computerul dvs. vizibile în monitorul serial al Arduino. Puteți să-l verificați deschizând „Monitorul serial” al Arduino în meniul „Instrumente” și ar trebui să aveți o ieșire care arată ca a doua imagine de titlu a acestui pas:)

Pasul 7: Construirea unui caz pentru modul

Puteți construi o cutie simplă pentru modulul dvs. tăind-o cu laser într-o placă de placaj de 3 mm.

Pentru a crea carcasele noastre, folosim makercase pentru a pregăti un șablon la dimensiunile dorite, pe care le personalizăm ulterior. Veți găsi fișierul svg al modulului de luminozitate atașat acestui pas.

Apoi lipiți fețele împreună, cu excepția uneia, astfel încât să o puteți deschide mai târziu, puneți circuitul în interior și lipiți LED-ul în gaura carcasei (folosim bandă transparentă pentru a umple gaura și difuza lumina, în plus pentru a lipi LED-ul în față din ea).

Acum trebuie doar să adăugați o baterie pentru a vă alimenta Arduino, închideți carcasa și modulul dvs. este gata și ar trebui să arate bine:)