Bou 'n helderheidsmodule met AtHome: 7 stappe

2024 Outeur: John Day | [email protected]. Laas verander: 2024-01-30 07:26

AtHome is 'n volledig open source en openhardware-studenteprojek gemaak deur die groep AtHome van Epitech, met die doel om 'n gekoppelde oplossing te ontwikkel van verskeie individuele sensormodules wat kommunikeer met 'n databasis wat self aangebied word en 'n API blootstel wat gebruik word om 'n slimfoonprogram en 'n webtoepassing te voer. Die modules monitor die binnenshuise omgewing van 'n huis en kan die gebruiker visueel terugvoer gee, van groen (goed) na rooi (sleg), en die oordraagbare data is deur die gebruiker sigbaar deur die seriële kommunikasie van 'n module of ons toepassings as u dit gebruik.

Alhoewel hierdie projek nog steeds aktief ontwikkel, is die basiese funksies van ons modules nou gereed en vermoedelik maklik om te gebruik om aangepaste modules te ontwikkel. Daarom stel ek u voor om te sien hoe u u eie eenvoudige module kan bou met hierdie voorbeeld van helderheidsmodule.

Hierdie modules is basies gebou met 'n Arduino-versoenbare bord ('n gedeeltelike Arduino-kern behoort genoeg te wees, solank dit Stream, Wire en 'n UART-stroomondersteuning het), 'n LED (rooi of RGB) wat rooi word in die geval van 'n probleem, sensor, 'n kragtoevoer (muurkrag of battery) en 'n lasergesnyde omhulsel.

Ja, dit is beslis nie nuut nie; daar is baie sensorprojekte, maar ons hoop dat ander funksies soos opsporing van gesondheidsprobleme, kommunikasie en berging van inligting op 'n selfbediende bediener en visualiseringstoepassing u kan help. Of as u net u huis wil monitor, eenvoudige projekte of nie minder interessant nie:)

Stap 1: Versamel komponente

Vir hierdie projek benodig u 'n paar komponente om u AtHome -module te bou:

• 1x Arduino-versoenbare bord: hier gebruik ek 'n Arduino UNO (maar dit werk ook met ander borde soos TI Launchpads en ESP8266 boards)
• 1x sensor: ek gebruik 'n TSL2561 luminosity sensor (die lys van ondersteunde sensors is beskikbaar in die dokumentasie van ons biblioteek)
• 1x led: ek gebruik 'n Grove Chainable RGB LED hier (maar dit kan ook 'n eenvoudige rooi led of 'n NeoPixel wees)
• Dupont Wires

Die lys van versoenbare komponente is beskikbaar in die dokumentasie van ons projek.

Stap 2: Die installering van ons biblioteek

Om ons biblioteek te installeer, moet u dit aflaai vanaf ons bewaarplek (ons publiseer dit later op die Arduino IDE -lys en PlatformIO) met hierdie skakel:

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

Gaan dan in die Arduino IDE en kies "Skets> Biblioteek insluit> Voeg. ZIP -biblioteek by …". Kies dan die zip -lêer met die naam "artifacts.zip" en klik op "OK".

Stap 3: Die installering van die vereiste biblioteke

Om te werk, benodig ons biblioteek 'n paar ander biblioteke om op u rekenaar geïnstalleer te word:

• Arkhipenko TaskScheduler -biblioteek
• SEEED Studio Grove Digital Light Sensor biblioteek
• SEEED Studio Grove Kettingbare RGB LED -biblioteek
• Adafruit NeoPixel biblioteek

U kan dit installeer deur die biblioteekbestuurder van die Arduino IDE deur te gaan na "Skets"> "Sluit biblioteek in"> "Bestuur biblioteke …".

In die nuwe venster wat oopmaak, skryf die naam van die biblioteek wat u wil installeer in die wit soekbalk, en klik dan op die blok. 'N "Installeer" -knoppie verskyn, u hoef net daarop te klik, en die IDE sal dit aflaai en dit vir u installeer.

Stap 4: Monteer die module

Ons begin met die sensor. Verbind die VCC -pen van die TSL2561 deur 'n draad met die 5V -pen van die Arduino, die GND -pen van die sensor met een van die GND -pen van die Arduino en die SDA- en SCL -penne van die sensor na SDA- en SCL -penne van die Arduino. Nou is jy klaar!

Koppel nou die VCC -pen van die Grove Chainable RGB LED aan die 5V -pen van die Arduino en die GND -pen van die LED aan die tweede GND van die Arduino. As u Arduino as net een 5V -pen is, kan u 'n broodbord gebruik om die 5v van die Arduino aan 'n + ry van die broodbord te koppel en al u komponente 5V -penne daarop aan te sluit, of dit aan 'n stuk strook te soldeer of gebruik wago -verbindings of wat u ook al verkies. Koppel nou die CI -pen van u LED aan die pen 7 van u Arduino en die DI -pen van u LED aan die pen 8 van u Arduino. As u nie so 'n LED het nie, moenie bekommerd wees nie, dit is moontlik om die ingeboude LED van u Arduino-bord of 'n klassieke een te gebruik, met slegs 'n klein verandering in die kode.

Stap 5: Skryf die Luminosity Module Sketch

Kom ons maak 'n nuwe skets en skryf die kode vir ons module.

As u nie geïnteresseerd is in die verduideliking van die skets nie, kan u dit eenvoudig in u Arduino IDE kopieer en plak:

#insluit

met behulp van LightModule = AtHomeModule; Stroom *strome = {& Reeks, nullptr}; GroveChainableLED:: Pins grovePins = {7, 8}; GroveChainableLED gelei (& grovePins); LightModule *module = LightModule:: getInstance (); ongeldige opstelling () {// plaas u opstellingskode hier om een keer te werk: Serial.begin (9600); module-> setStreams (strome); GroveDigitalLightSensor *lightSensor = nuwe GroveDigitalLightSensor (); module-> setSensor (lightSensor); module-> setDisplay (& led); module-> opstelling (); } void loop () {// plaas u hoofkode hier om herhaaldelik te hardloop: module-> run (); }

As u alles wil verstaan wat hierdie kode doen, kan u die volgende lees, of as u nie belangstel nie, kan u direk na die volgende stap gaan.

Om te begin, moet ons ons biblioteek in ons skets insluit deur hierdie reël bo -aan die skets te skryf:

#insluit

Nou moet ons 'n alias skep vir die module -voorwerp wat ons sal gebruik. U kan dit sien as 'n boks met verskeie knoppies wat gebruik word om die komponente te verander, te begin, te stop, ens. Aangesien dit 'n boks is wat volgens 'n sjabloon gebou is (soos die gewone sjabloon wat ons as mense gebruik vir projekte, het dit 'n voorgereg en die samesteller van Arduino bou die finale kode op grond van parameters wat ons hom gee) wat die tipe definieer wat 'n sensorwaarde en die die aantal sensorwaardes wat ons in ons geheue wil hou, word in die naam gespesifiseer en moet normaalweg herhaal word elke keer as ons dit wil gebruik. Dit is 'n bietjie irriterend, daarom koppel ons 'n nuwe naam, 'n alias, aan die volledige naam van hierdie boks.

Kom ons sê byvoorbeeld: ek wil hê dat hierdie boks die naam "LightModule" moet hê, aangesien dit gebruik sal word om 'n helderheidsmoniteringsmodule te implementeer en ek wil slegs 1 waarde op 'n slag behou. Die helderheid word in lux as 'n integrale tipe voorgestel deur ons TSL2561 -sensor, wat as 'n uint16_t deur rekenaars voorgestel word. Ons alias sal so lyk:

met behulp van LightModule = AtHomeModule;

die 'gebruik' -sleutelwoord beteken dat ons 'n alias skep en die naam wat ons dit net daarna gee, stem ooreen met die volgorde na die' = 'karakter.

"AtHomeModule" is die regte naam van hierdie boks wat ons 'n nuwe naam gee, en die parameters wat die waardevoorstelling en die aantal waardes in die geheue bevat, word tussen "" gelys.

As ons later die naam "AtHomeModule" sal gebruik, sal Arduino weet dat dit verwys na die volledige naam "AtHomeModule".

As u wil hê dat u boks 5 waardes in die geheue in plaas van 1 kan behou, moet u slegs die '1' deur '5' vervang, en Arduino sal 'n ander tipe boks vir u genereer wat kan doen wat u wil. Let egter daarop dat as die module geprogrammeer is om sy waardes te stuur voordat dit tyd het om 5 waardes van die sensor effektief te meet, sal u nooit 5 daarvan sien stuur nie, aangesien dit slegs die nuwe waardes sedert die laaste oplaai stuur.

Vervolgens moet ons 'n verskeidenheid aanwysers skep wat aanwysers bevat op Arduino -strome wat die module gebruik om te kommunikeer, altyd beëindig deur die sleutelwerk "nullptr". Hier gebruik ek slegs die 'Serial' stroom van die Arduino wat via die USB -poort met die rekenaar kommunikeer, sodat die skikking so lyk:

Stroom *strome = {& Reeks, nullptr};

Die "*" karakter beteken dat die tipe 'n wyser is (die ligging van die element, nie die element self nie) en die "" hakies beteken dat dit in Arduino 'n skikking is, sodat ons verskeie waardes kan plaas.

Vervolgens moet ons ons LED skep. Om dit te kan doen, moet ons die volgende twee reëls skryf;

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

GroveChainableLED gelei (& grovePins);

As u nie 'n Grove RGB -LED het nie, maar steeds visuele terugvoer wil hê, kan u dit eenvoudig doen deur die skets te verander. Vervang die twee vorige reëls deur hierdie reël:

Monochromaties LED (LED_BUILTIN);

In hierdie konfigurasie sal die groen ingeboude LED aanskakel solank die gemonitorde waarde vir die gesondheid in orde is en uitskakel as dit uit verband bly. As u verkies dat dit aanskakel as dit nie verband hou nie (omdat u byvoorbeeld 'n rooi LED in plaas van die groen op pen 13 gebruik), kan u hierdie lyn in plaas daarvan gebruik:

Monochromaties LED (LED_BUILTIN, waar);

Die volgende stap is om ons module self te skep. Dit word gedoen die eerste keer dat ons die ligging daarvan in die geheue kry deur die 'getInstance' metode te noem, soos volg:

LightModule *module = LightModule:: getInstance ();

Dan moet ons die parameters in die "setup ()" -funksie van Arduino instel, begin met die initialisering van die "Serial" -poort soos gewoonlik in Arduino -sketse:

Serial.begin (9600);

Ons skep die ligsensor deur hierdie reël te skryf:

GroveDigitalLightSensor *lightSensor = nuwe GroveDigitalLightSensor ();

Dan vertel ons ons module om ons verskeidenheid wenke op Arduino Stream te gebruik om daardeur te kommunikeer:

module-> setStreams (strome);

Ons sê ook vir ons module om ons ligsensor te gebruik om die ligintensiteit waar die module is, te monitor:

module-> setSensor (lightSensor);

Ons vertel ons module om ons LED te gebruik om ons visuele terugvoer te gee:

module-> setDisplay (& led);

Uiteindelik vertel ons ons module dat hy gereed is om enige interne konfigurasie te doen deur sy eie 'opstel' -funksie te noem:

module-> opstelling ();

Ons laaste stap is nou om die "run ()" -funksie van ons module te noem, wat ontwerp is om by elke herhaling van die "lus" -funksie van Arduino genoem te word deur hierdie reël binne die "lus" -funksie te skryf:

module-> run ();

Nou is ons skets uiteindelik gereed om na die Arduino op te laai en ons module te toets!

Stap 6: Toets ons AtHome -module

Om die skets na die Arduino op te laai, kies u Arduino UNO -bord deur in "Tools"> "Port"> "[COMx of/dev/x] (Arduino/Genuino UNO)" te gaan.

Laastens, klik net op die knoppie "Laai op" (die sirkelknoppie met 'n pyltjie na regs, die tweede ikoon van die werkbalk) om die skets in u bord op te laai.

Dis gedoen! Nou moet u module werk en waardes na u rekenaar stuur wat sigbaar is in die Serial Monitor van Arduino. U kan dit kontroleer deur die "Serial Monitor" van Arduino in die menu "Tools" oop te maak, en u moet 'n uitset hê wat lyk soos die tweede titelfoto van hierdie stap:)

Stap 7: Bou 'n saak vir die module

U kan 'n eenvoudige boks vir u module bou deur dit in 'n 3 mm laaghoutplank met laser te sny.

Om ons boksies te maak, gebruik ons 'n hoofletter om 'n sjabloon op te stel met die gewenste afmetings wat ons later kan aanpas. U vind die svg -lêer van die helderheidsmodule wat by hierdie stap aangeheg is.

Plak dan die gesigte vas, behalwe een, sodat u dit later kan oopmaak, u kring kan plaas en die LED in die gat van die omhulsel kan plak (ons gebruik deursigtige band om die gat te vul en die lig te versprei, en die LED voor te plak) daarvan).

Voeg nou net 'n battery by om u Arduino aan te dryf, maak die kas toe en u module is gereed en moet goed lyk:)