Bouw een Luminosity-module met AtHome - Ajarnpa

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:18

AtHome is een volledig opensource en openhardware studentenproject gemaakt door de groep AtHome van Epitech, met als doel een verbonden oplossing te ontwikkelen van verschillende individuele sensormodules die communiceren met een zelf-gehoste database die een API blootlegt die wordt gebruikt om een smartphone-applicatie en een webapplicatie te voeden. De modules bewaken het binnenmilieu van een huis en zijn in staat om visuele feedback te geven aan de gebruiker, gaande van groen (goed) naar rood (slecht) en de verzonden gegevens zijn zichtbaar voor de gebruiker via de seriële communicatie van een module of op onze applicaties als u ze gebruikt.

Hoewel dit project nog volop in ontwikkeling is, zijn de basisfunctionaliteiten van onze modules nu klaar en zogenaamd eenvoudig te gebruiken om aangepaste modules te ontwikkelen. Daarom stel ik je voor om te zien hoe je je eigen eenvoudige module kunt bouwen met dit voorbeeld van een helderheidsmodule.

Deze modules zijn in principe gebouwd met een Arduino-compatibel bord (een gedeeltelijke Arduino-kern zou voldoende moeten zijn zolang deze Stream, Wire en een UART-stream ondersteunt), een LED (rode of RGB) die rood wordt in geval van een probleem, een sensor, een voeding (muurvoeding of batterij) en een lasergesneden behuizing.

Ja, het is zeker niet nieuw, er zijn veel sensorprojecten, maar we hopen dat andere functies, zoals detectie van gezondheidsproblemen, communicatie en opslag van informatie op een zelf-gehoste server en visualisatietoepassing, u kunnen helpen. Of als je gewoon je huis in de gaten wilt houden, simpele projecten of niet minder interessant:)

Stap 1: Componenten verzamelen

Voor dit project heb je een paar componenten nodig om je AtHome-module te bouwen:

• 1x Arduino-compatibel bord: hier gebruik ik een Arduino UNO (maar het werkt ook met andere borden zoals TI Launchpads en ESP8266-borden)
• 1x sensor: ik gebruik een TSL2561-lichtsterktesensor (de lijst met ondersteunde sensoren is beschikbaar in de documentatie van onze bibliotheek)
• 1x led: ik gebruik hier een Grove Chainable RGB LED (maar het kan ook een simpele rode led of een NeoPixel zijn)
• Dupont-draden

De lijst met compatibele componenten is beschikbaar in de documentatie van ons project.

Stap 2: Onze bibliotheek installeren

Om onze bibliotheek te installeren, moet je downloaden van onze repository (we zullen het later publiceren op de Arduino IDE-lijst en PlatformIO) met deze link:

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

Ga dan naar de Arduino IDE en kies "Sketch > Include Library > Add. ZIP Library…". Selecteer vervolgens het zipbestand met de naam "artifacts.zip" en klik op "OK".

Stap 3: Vereiste bibliotheken installeren

Om te werken, heeft onze bibliotheek een aantal andere bibliotheken nodig die op uw computer zijn geïnstalleerd:

• Arkhipenko TaskScheduler-bibliotheek
• SEEED Studio Grove Digital Light Sensor-bibliotheek
• SEEED Studio Grove Chainable RGB LED-bibliotheek
• Adafruit NeoPixel-bibliotheek

Je kunt ze installeren via de bibliotheekmanager van de Arduino IDE, door naar "Sketch" > "Include Library" > "Bibliotheken beheren …" te gaan.

In het nieuwe venster dat wordt geopend, schrijft u in de witte zoekbalk de naam van de bibliotheek die u wilt installeren en klikt u vervolgens op het blok. Er verschijnt een knop "Installeren", u hoeft er alleen maar op te klikken en de IDE zal deze voor u downloaden en installeren.

Stap 4: De module monteren

We beginnen met de sensor. Verbind via een draad de VCC-pin van de TSL2561 met de 5V-pin van de Arduino, de GND-pin van de sensor met een van de GND-pin van de Arduino en de SDA- en SCL-pinnen van de sensor met SDA- en SCL-pinnen van de Arduino. Nu ben je klaar!

Verbind nu de VCC-pin van de Grove Chainable RGB LED met de 5V-pin van de Arduino en de GND-pin van de LED met de tweede GND van de Arduino. Als je Arduino bent als slechts één 5V-pin, kun je een breadboard gebruiken om de 5v van de Arduino aan te sluiten op een + rij van het breadboard en al je componenten 5V-pinnen erop aan te sluiten, of ze aan elkaar te solderen op een stuk stripboard of gebruik wago-connectoren of wat je maar wilt. Verbind nu de CI-pin van je LED met pin 7 van je Arduino en de DI-pin van je LED met pin 8 van je Arduino. Als je zo'n LED niet hebt, maak je geen zorgen, het is mogelijk om de ingebouwde LED van je Arduino-bord of een klassieke te gebruiken met slechts een kleine wijziging in de code.

Stap 5: De schets van de lichtsterktemodule schrijven

Laten we een nieuwe schets maken en de code voor onze module schrijven.

Als je niet geïnteresseerd bent in de uitleg van de schets, kun je deze gewoon kopiëren en in je Arduino IDE plakken:

#erbij betrekken

met behulp van LightModule = AtHomeModule; Stream *streams = {&Serial, nullptr}; GroveChainableLED::Pins grovePins = {7, 8}; GroveChainableLED led(&grovePins); LightModule *module = LightModule::getInstance(); void setup() { // plaats hier uw setup-code om een keer uit te voeren: Serial.begin (9600); module->setStreams(stromen); GroveDigitalLightSensor *lightSensor = nieuwe GroveDigitalLightSensor(); module->setSensor (lichtSensor); module->setDisplay(&led); module->setup(); } void loop() { // plaats hier je hoofdcode, om herhaaldelijk uit te voeren: module->run(); }

Als je alles wilt begrijpen wat deze code doet, kun je het volgende lezen of als je niet geïnteresseerd bent, kun je direct naar de volgende stap gaan.

Om te beginnen moeten we onze bibliotheek in onze schets opnemen door deze regel bovenaan de schets te schrijven:

#erbij betrekken

Nu moeten we een alias maken voor het moduleobject dat we gaan gebruiken. Je kunt het zien als een doos met verschillende knoppen die worden gebruikt om de componenten te wijzigen, te starten, te stoppen, … enz. Omdat het een doos is die is gebouwd door een sjabloon (zoals de gebruikelijke sjabloon die we als mensen voor projecten gebruiken, heeft het een startersbasis en de compiler van Arduino bouwt de definitieve code op basis van parameters die we hem geven) die het type definieert dat een sensorwaarde vertegenwoordigt en de aantal sensorwaarden dat we in het geheugen willen bewaren, het staat in de naam en zou normaal gesproken moeten worden herhaald elke keer dat we het willen gebruiken. Dat is een beetje vervelend, daarom associëren we een nieuwe naam, een alias, aan de volledige naam van dit vak.

Laten we bijvoorbeeld zeggen dat ik deze box de naam "LightModule" wil geven, omdat deze zal worden gebruikt om een module voor het bewaken van de helderheid te implementeren en ik slechts 1 waarde per keer wil behouden. De helderheid wordt in lux weergegeven als een integraal type door onze TSL2561-sensor, die door computers wordt weergegeven als een uint16_t. Onze alias ziet er als volgt uit:

met behulp van LightModule = AtHomeModule;

het sleutelwoord "using" betekent dat we een alias maken en de naam die we er net achter geven, komt overeen met de reeks na het teken "=".

"AtHomeModule" is de echte naam van dit vak dat we een nieuwe naam geven, en de parameters die de waarderepresentatie definiëren en het aantal waarden dat in het geheugen wordt bewaard, staan tussen "".

Als we later de naam "AtHomeModule" gaan gebruiken, weet Arduino dat het verwijst naar de volledige naam "AtHomeModule".

Als u wilt dat uw box 5 waarden in het geheugen kan bewaren in plaats van 1, hoeft u alleen de "1" te vervangen door "5" en Arduino zal voor u een ander type box genereren die kan doen wat u wilt. Houd er echter rekening mee dat als de module is geprogrammeerd om zijn waarden te verzenden voordat deze de tijd heeft gehad om effectief 5 waarden van de sensor te meten, u er nooit 5 van zult zien verzenden, omdat deze alleen de nieuwe waarden sinds de laatste upload verzendt.

Vervolgens moeten we een reeks aanwijzers maken die aanwijzers bevatten op Arduino-streams die door de module worden gebruikt om te communiceren, altijd beëindigd door de keyworkd "nullptr". Hier gebruik ik alleen de "seriële" stroom van de Arduino die via de USB-poort met de computer communiceert, dus de array ziet er als volgt uit:

Stream *streams = {&Serial, nullptr};

Het "*"-teken betekent dat het type een aanwijzer is (de locatie van het element, niet het element zelf) en de ""-haakjes betekenen in Arduino dat het een array is, dus we kunnen meerdere waarden plaatsen.

Vervolgens moeten we onze LED maken. Om dit te doen, moeten we de volgende twee regels schrijven;

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

GroveChainableLED led(&grovePins);

Als je geen Grove RGB-led hebt maar toch visuele feedback wilt, kun je dat doen met een simpele wijziging in de schets. Vervang de twee vorige regels door deze regel:

Monochromatische LED led (LED_BUILTIN);

In deze configuratie gaat de groene ingebouwde LED aan zolang de bewaakte waarde in orde is voor de gezondheid en gaat uit wanneer deze niet meer verbonden is. Als u liever wilt dat het wordt ingeschakeld wanneer het geen verbinding heeft (omdat u bijvoorbeeld een rode LED gebruikt in plaats van de groene op pin 13), kunt u in plaats daarvan deze regel gebruiken:

Monochromatische LED-led (LED_BUILTIN, waar);

De volgende stap is om onze module zelf te maken. Het is gedaan de eerste keer dat we de locatie in het geheugen krijgen door de "getInstance" -methode aan te roepen, zoals deze:

LightModule *module = LightModule::getInstance();

Vervolgens moeten we de parameters instellen in de "setup()" -functie van Arduino, te beginnen met het initialiseren van de "Seriële" poort zoals gebruikelijk in Arduino-schetsen:

Serieel.begin(9600);

We maken de lichtsensor door deze regel te schrijven:

GroveDigitalLightSensor *lightSensor = nieuwe GroveDigitalLightSensor();

Vervolgens vertellen we onze module om onze reeks aanwijzers op Arduino Stream te gebruiken om via hen te communiceren:

module->setStreams(stromen);

We vertellen onze module ook om onze lichtsensor te gebruiken om de lichtintensiteit te bewaken waar de module zich bevindt:

module->setSensor (lichtSensor);

We vertellen onze module om onze LED te gebruiken om ons een visuele feedback te geven:

module->setDisplay(&led);

Ten slotte vertellen we onze module dat het klaar is om elke interne configuratie uit te voeren die het moet doen door zijn eigen "setup" -functie aan te roepen:

module->setup();

Onze laatste stap is nu om de "run()" -functie van onze module aan te roepen, die is ontworpen om te worden aangeroepen bij elke iteratie van de "loop" -functie van Arduino door deze regel in de "loop" -functie te schrijven:

module->uitvoeren();

Nu is onze schets eindelijk klaar om te uploaden naar de Arduino en onze module te testen!

Stap 6: Onze AtHome-module testen

Om de schets naar de Arduino te uploaden, kies je je Arduino UNO-bord door naar "Tools"> "Poort"> "[COMx of /dev/x] (Arduino/Genuino UNO)" te gaan.

Als laatste klik je op de knop "Uploaden" (de cirkelknop met een pijl die naar rechts wijst, het tweede pictogram van de werkbalk) om de schets naar je bord te uploaden.

Het is klaar! Nu zou je module moeten werken en waarden naar je computer moeten sturen die zichtbaar zijn in de seriële monitor van Arduino. Je kunt het controleren door de "Seriële monitor" van Arduino te openen in het menu "Extra" en je zou een uitvoer moeten hebben die lijkt op de tweede titelafbeelding van deze stap:)

Stap 7: Een case voor de module bouwen

U kunt een eenvoudige kast voor uw module bouwen door deze te lasersnijden in een 3 mm dikke multiplex plank.

Om onze boxcases te maken, gebruiken we makercase om een sjabloon op de gewenste afmetingen voor te bereiden die we later aanpassen. U vindt het svg-bestand van de helderheidsmodule die bij deze stap is gevoegd.

Lijm dan gewoon de gezichten aan elkaar, behalve één, zodat je het later kunt openen, plaats je circuit erin en plak de LED in het gat van de behuizing (we gebruiken transparante tape om het gat te vullen en het licht te verspreiden en de LED aan de voorkant te plakken ervan).

Voeg nu gewoon een batterij toe om je Arduino van stroom te voorzien, sluit de behuizing en je module is klaar en zou er goed uit moeten zien:)