The Artificial Plant Emotion Expressor (A.P.E.X.): 7 stappe (met foto's)

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

Maar wag … Daar is meer!

Stap 1: Inleiding

Wat is APEX?

APEX is 'n slim (om nie te praat van oulike) plantmoniteringstoestelle nie. Koppel dit net aan enige plant en dit sal die 'geluk' van die plant vertoon! Dit is 'n goeie herinnering om u plante nat te maak as u die gewoonte het om dit te vergeet.

Hoe werk dit?

Towerkuns. Ek grap net! APEX gebruik 'n Arduino wat aan 'n vogsensor gekoppel is, wat in die grond van die plant geplaas word. Hierdie sensor sal die voginhoud van die grond lees, en dan bereken die Arduino watter gesig dit moet vertoon.

Maar hoekom?

Hoekom nie?

Stap 2: Versamel die onderdele en gereedskap

Kom ons gaan daarin! Vir hierdie instruksies benodig u 'n hele paar onderdele en gereedskap. Gelukkig vir u word hulle almal hieronder gelys:

In die gees van die Microcontrollers Contest, is hierdie projek volledig gemaak deur onderdele wat op Amazon gekoop is! (nie geborg nie)

Onderdele lys:

• Arduino Uno
• 8x8 LED -skerm
• Kapasitiewe aanraaksensor
• Vog sensor
• 9V batteryaansluiting
• 9V battery

Gereedskaplys:

• 22 Spoordraad
• Elektriese band
• Draadstroppers
• Soldeerbout
• Desoldeerpomp

As u al die nodige toerusting versamel het, is dit tyd om die Arduino -sagteware op te stel!

Stap 3: Installeer die Arduino IDE

Om hierdie projek te laat werk, moet ons die Arduino kan programmeer. Dit vereis dat die Arduino Integrated Development Environment (IDE) op u rekenaar afgelaai en geïnstalleer word. Dit is 'n redelik eenvoudige verduideliking, maar ek sal u deur die proses lei:

1. Besoek die Arduino -webwerf

2. Gaan na die aflaai -bladsy (sagteware> aflaaie)

3. Klik op die aflaai -skakel vir u bedryfstelsel

Kantopmerking: die program werk op Windows, Mac en Linux.

4. Installeer op Windows

• Dubbelklik op die afgelaaide lêer om dit uit te voer
• Klik op "Stem saam" om in te stem tot die lisensie
• Volg die res van die aanwysings
• Die program moet nou geïnstalleer word!

(Kyk na die skermkiekies as u verdwaal)

5. Installeer op Mac

• Klik op die afgelaaide lêer
• Kies "Open"
• Die program word outomaties geïnstalleer en uitgevoer!

(Kyk gerus na die skermkiekies as u deurmekaar raak)

6. Dit is dit

En jy is klaar! U het nou die Arduino IDE op u stelsel afgelaai!

Stap 4: Die kode

Hierdie stap handel oor die kode. Dit is 'n redelik kort program, so ek sal met u daaroor gaan en verduidelik hoe dit werk. Eerstens 'n kort oorsig, dan 'n diepgaande verduideliking, en laastens hoe u dit na die Arduino kan stoot!

Die kort oorsig

Vir diegene onder u wat nie belangstel in die gedetailleerde verduideliking van die kode nie, bied ek 'n TL; DR -segment aan! Hier is die basiese verduideliking. Die Arduino haal elke paar sekondes waardes van die vogsensor af. Hierdie inligting word dan gebruik om 'n sekere gesig te bereken en weer te gee! Daar is ook 'n bietjie kode aan die einde waarmee die kapasitiewe aanraakknoppie die skerm kan aan- en uitskakel. Redelik eenvoudig reg?

Die Nitty Gritty

Hierdie gedeelte van die tutoriaal is vir diegene wat baie belangstel in hoe die hele program werk, reël vir reël. Ek sal die skermkiekies hierbo verskaf om u te help verstaan waaroor ek praat, asook om 'n paar reëls kode in hierdie beskrywing op te neem.

Hierdie program is verdeel in vyf afdelings:

1. Insluitend biblioteke en die skep van veranderlikes
2. Die opstelfunksie
3. Funksies vir gesigsuitdrukkings
4. Die skryf Arduino op matriks funksie
5. Die lusfunksie

Insluitend biblioteke en die skep van veranderlikes:

Die eerste afdeling van hierdie kode handel oor die veranderlikes en biblioteke wat ons sal gebruik.

#sluit "LedControlMS.h" in

#define TouchSensor 7 LedControl lc = LedControl (12, 11, 10, 1); int sensorPin = A5; int sensorValue = 0; bool begin = vals; bool op = waar; booleaans gedruk = LAAG;

Die eerste reël bevat 'n biblioteek genaamd LedControlMS. Hierdie biblioteek is nodig om waardes na die LED -skerm te kan stuur. Die volgende reël is 'n definisie -stelling wat die pen vir die aanraaksensor op 7. stel. Daarna het ons nog drie veranderlikes wat die penne vir die LED -skerm, die vogsensor en die waarde daarvan definieer. Die laaste drie reëls is almal booleans wat die toestand van die aanraakknoppie en die skerm reguleer. Hierna het ons ons byte -waardes:

byte smile [4] = {B00000100, B00110010, B01100100, B01100000}; byte verrassing [4] = {B00001110, B00001010, B01101110, B10010000}; byte meh [4] = {B00000100, B00100100, B00100100, B00100000}; greep hartseer [4] = {B00000010, B01100100, B00110010, B00110000}; greep dood [6] = {B00001010, B00100100, B00101010, B00100000, B01100000, B01101010}; greepfout [8] = {B00111100, B01000010, B10100001, B10010001, B10001001, B10000101, B01000010, B00111100}; // Evil Faces byte esmile [4] = {B00000010, B00101010, B01000100, B01000000}; byte elaugh [4] = {B00000010, B00101010, B01100100, B01100000}; byte eplain [4] = {B00000010, B00101010, B00100100, B00100000}; byte eyell [4] = {B00000001, B01101001, B01100010, B01100000}; byte etalk [4] = {B00000001, B00101001, B01100010, B01100000};

Hierdie waardes verteenwoordig al die vlakke van APEX. Elke byte is 'n skikking wat veelvoudige bisse bevat wat die toestand van elke pixel in 'n gegewe ry bepaal. "1" en "0" verteenwoordig onderskeidelik Aan/Uit.

Die opstelfunksie:

As ons na die volgende afdeling gaan, het ons ons opstellingsfunksie.

ongeldige opstelling () {// MS Serial Output Serial.begin (9600);

pinMode (TouchSensor, INPUT);

// LED Matrix Setup lc.shutdown (0, vals); lc.setIntensity (0, 4); lc.clearDisplay (0); }

Die naam verduidelik dit baie goed. Dit is waar ons ons raaksensor en skerm vertoon. Die eerste twee reëls begin ons reeksuitset (gebruik vir ontfouting). Die derde reël stel die aanraaksensorpen op 'n invoer, en die laaste vier reëls begin die skerm.

Funksies vir gesigsuitdrukkings:

Dit is waarskynlik die langste gedeelte, maar dit is baie eenvoudig en herhalend.

leegte gebreek () {lc.setRow (0, 0, fout [0]); lc.setRow (0, 1, fout [1]); lc.setRow (0, 2, fout [2]); lc.setRow (0, 3, fout [3]); lc.setRow (0, 4, fout [4]); lc.setRow (0, 5, fout [5]); lc.setRow (0, 6, fout [6]); lc.setRow (0, 7, fout [7]); }

leegte gelukkig () {

lc.setRow (0, 0, glimlag [0]); lc.setRow (0, 1, glimlag [1]); lc.setRow (0, 2, glimlag [2]); lc.setRow (0, 3, glimlag [3]); lc.setRow (0, 4, glimlag [3]); lc.setRow (0, 5, glimlag [2]); lc.setRow (0, 6, glimlag [1]); lc.setRow (0, 7, glimlag [0]); }

void plain () {

lc.setRow (0, 0, meh [0]); lc.setRow (0, 1, meh [1]); lc.setRow (0, 2, meh [2]); lc.setRow (0, 3, meh [3]); lc.setRow (0, 4, meh [3]); lc.setRow (0, 5, meh [2]); lc.setRow (0, 6, meh [1]); lc.setRow (0, 7, meh [0]); }

leegte verras () {

lc.setRow (0, 0, verrassing [0]); lc.setRow (0, 1, verrassing [1]); lc.setRow (0, 2, verrassing [2]); lc.setRow (0, 3, verrassing [3]); lc.setRow (0, 4, verrassing [3]); lc.setRow (0, 5, verrassing [2]); lc.setRow (0, 6, verrassing [1]); lc.setRow (0, 7, verrassing [0]); }

leegte sterf () {

lc.setRow (0, 0, dood [0]); lc.setRow (0, 1, dood [1]); lc.setRow (0, 2, dood [2]); lc.setRow (0, 3, dood [3]); lc.setRow (0, 4, dood [4]); lc.setRow (0, 5, dood [5]); lc.setRow (0, 6, dood [1]); lc.setRow (0, 7, dood [0]); }

leegte huil () {

lc.setRow (0, 0, hartseer [0]); lc.setRow (0, 1, hartseer [1]); lc.setRow (0, 2, hartseer [2]); lc.setRow (0, 3, hartseer [3]); lc.setRow (0, 4, hartseer [3]); lc.setRow (0, 5, hartseer [2]); lc.setRow (0, 6, hartseer [1]); lc.setRow (0, 7, hartseer [0]); }

void evilsmile () {

lc.setRow (0, 0, esmile [0]); lc.setRow (0, 1, esmile [1]); lc.setRow (0, 2, esmile [2]); lc.setRow (0, 3, esmile [3]); lc.setRow (0, 4, esmile [3]); lc.setRow (0, 5, esmile [2]); lc.setRow (0, 6, esmile [1]); lc.setRow (0, 7, esmile [0]); }

leegte evillaugh () {

lc.setRow (0, 0, elaugh [0]); lc.setRow (0, 1, elaugh [1]); lc.setRow (0, 2, elaugh [2]); lc.setRow (0, 3, elaugh [3]); lc.setRow (0, 4, elaugh [3]); lc.setRow (0, 5, elaugh [2]); lc.setRow (0, 6, elaugh [1]); lc.setRow (0, 7, elaugh [0]); }

void evilplain () {

lc.setRow (0, 0, eplain [0]); lc.setRow (0, 1, eplain [1]); lc.setRow (0, 2, eplain [2]); lc.setRow (0, 3, eplain [3]); lc.setRow (0, 4, eplain [3]); lc.setRow (0, 5, eplain [2]); lc.setRow (0, 6, eplain [1]); lc.setRow (0, 7, eplain [0]); }

void evilyell () {

lc.setRow (0, 0, eyell [0]); lc.setRow (0, 1, eyell [1]); lc.setRow (0, 2, eyell [2]); lc.setRow (0, 3, eyell [3]); lc.setRow (0, 4, eyell [3]); lc.setRow (0, 5, eyell [2]); lc.setRow (0, 6, eyell [1]); lc.setRow (0, 7, eyell [0]); }

leegte eviltalk () {

lc.setRow (0, 0, etalk [0]); lc.setRow (0, 1, etalk [1]); lc.setRow (0, 2, etalk [2]); lc.setRow (0, 3, etalk [3]); lc.setRow (0, 4, etalk [3]); lc.setRow (0, 5, etalk [2]); lc.setRow (0, 6, etalk [1]); lc.setRow (0, 7, etalk [0]); }

Hierdie funksies word gebruik om elke gesigsuitdrukking te definieer met behulp van ons bytewaardes uit die eerste afdeling. Elke reël definieer 'n x -posisie en greepwaardes en pas dan die waardes toe op die kolom. Sommige funksies benodig meer lyne omdat daar meer rye gebruik word om die waardes van die gesig te vertoon. Elke gesig is simmetries, daarom herhaal ons die lyne.

Die WriteArduinoOnMatrix -funksie:

Die vierde afdeling word gebruik om die regte vlakke op die LED -skerm te bereken en neer te skryf. Dit bestaan uit 'n reeks anders -as -stellings wat na die waterwaardes kyk en dan die vertoning stel deur verskillende funksies uit die vorige afdeling te roep.

void writeArduinoOnMatrix () {if (sensorValue> 0 && sensorValue 30 && sensorValue 100 && sensorValue 200 && sensorValue 400 && sensorValue 650 && sensorValue <= 800) {verbaas (); } anders {gebroke (); }}

U sal miskien sien dat ons 'stukkende' gesigte bygevoeg het, ingeval die sensor buite die werkbereik gaan. Dit voorkom 'n paar vreemde nulfoute wat plaasvind en gee ons 'n beter visuele begrip van wat binne die kode aangaan.

Die lusfunksie:

Laaste maar nie die minste nie, is die lusfunksie. Hierdie kode doen presies wat die naam sê, dit loop! Alhoewel daar 'n hele paar reëls in hierdie funksie is, is dit eintlik redelik eenvoudig. Die kode lees eers die knoppie -status en kyk of die skerm "Aan" is. As dit die waarheid vind, sal dit die WriteArduinoOnMatrix -funksie bel, wat dan 'n gesig op APEX sal trek. Omdat hierdie funksie los is, sal dit die skerm so gereeld as moontlik bywerk. Hierdie vertraging word bepaal deur die vertragingstyd veranderlike.

leemte -lus () {as (begin == waar) {delaytime = 3000; } // Lees knoppie ingedruk = digitalRead (TouchSensor);

as (ingedruk) {

as (op == waar) {lc.clearDisplay (0); op = vals; vertraging (vertragingstyd); } anders {on = waar; vertraging (vertragingstyd); }} sensorValue = analogRead (sensorPin); vertraging (vertragingstyd); if (on == true) {// Draw Faces writeArduinoOnMatrix (); }

begin = waar;

}

Dit is al wat die kode bevat. Hopelik het u nou 'n beter begrip van hoe dit alles werk, en kan u hierdie kennis gebruik om dit aan te pas by u projek!

Druk die kode na die Arduino

Noudat ons al die kode gedek het, is dit tyd om dit na die Arduino te stoot! Gelukkig maak die IDE dit baie eenvoudig. Al wat u hoef te doen is om u Arduino met 'n USB -kabel op u rekenaar aan te sluit, en klik dan op die pyltjie regs in die linkerbovenhoek van die IDE. Laat die kode druk, en u sal 'n suksesboodskap onderaan die program sien as u dit reg gedoen het!

Stap 5: Kringdiagram

Net soos die kode, is die stroombaandiagram nie te ingewikkeld nie. Dit bestaan slegs uit drie sensors en die Arduino, so ek sal u die pin-outs vir elkeen vertel, en as u ander hulp nodig het, raadpleeg die diagram hierbo.

Die LED -skerm:

• VCC -> 5V
• GRD -> GRD
• DIN -> Speld 12
• CS -> Speld 10
• CLK -> Speld 11

Die vog sensor:

• Positief -> 5V
• Negatief -> GRD
• Sein -> A5

Die kapasitiewe aanraaksensor:

• VCC -> 5V
• GRD -> GRD
• SIG -> 7

Nie te moeilik nie, reg? As u probleme ondervind met hierdie pin-out, verwys dan na die video hieronder waar ek u kan leer hoe om dit op te los.

Stap 6: Alles saamvoeg

Dit is moeilik om in die teks te verduidelik hoe dit bymekaar pas, so ek sal beslis aanbeveel om na die video vir hierdie deel te kyk. Ek gaan nie presies verduidelik hoe ek myne saamgestel het nie, dit is te moeilik. Maar om dinge vaag te verduidelik, het ek aan die draadverbindings gesoldeer en dit om die agterkant van die bord gedraai. Toe plaas ek die sensors en gebruik elektriese band om dit bymekaar te hou. Laastens het ek dit met die 9V -battery getoets, en toe ek eers weet dat dit werk, plaas ek die battery op die agterkant en plak dit ook vas. Soos ek al voorheen gesê het, kyk na die video vir hierdie stap; dit het 'n mooi soldeersegment wat versnel word en u sal help om die drade korrek te draai. Stop dit gerus of speel dit teen halfsnelheid as u verdwaal.

Baie geluk! As alles suksesvol verloop het, behoort u nou 'n ten volle funksionele APEX -eenheid te hê!

Soek 'n natgemaakte aanleg om u eenheid uit te toets en sluit dit aan! U moet vind dat dit gelukkig of verras is, en dit beteken dat dit moet werk !!! Puik werk om die projek te voltooi!

Stap 7: Gevolgtrekking

En dit is die hele Instructable! Dankie dat u na die projek gekyk het! Laat enige vrae en kommentaar hieronder, en volg die Urban Farming Guys vir meer interessante tutoriale soos hierdie! Ons hoor graag hoe u APEX -konstruksie verloop het, en foto's word baie waardeer! Weereens baie dankie vir die inloer, lekker dag verder!

(Hierdie instruksie is geïnspireer deur 'n ouer projek, die Plant Emoji!)

P. S. Hierdie instruksies word ingeskryf vir die Microcontrollers -wedstryd, dus moenie vergeet om vir ons te stem nie! Ons waardeer dit baie:)

P. P. S. Kom ons kry APEX in Make Magazine! Stem hier! Dankie:)