L'espressore di emozioni delle piante artificiali (A.P.E.X.): 7 passaggi (con immagini)

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:04

Ma aspetta… C'è di più!

Passaggio 1: Introduzione

Cos'è l'APEX?

APEX è un dispositivo di monitoraggio delle piante intelligente (per non dire carino). Basta collegarlo a qualsiasi pianta e mostrerà il livello di "felicità" della pianta! Questo è un ottimo promemoria per innaffiare le tue piante se hai la cattiva abitudine di dimenticare di annaffiarle.

Come funziona?

Magia. Stavo solo scherzando! APEX utilizza un Arduino collegato a un sensore di umidità, che viene inserito nel terreno della pianta. Questo sensore leggerà il contenuto di umidità del suolo, quindi Arduino calcolerà quale faccia visualizzare.

Ma perché?

Perchè no?

Passaggio 2: raccolta delle parti e degli strumenti

Entriamo in esso! Per questo Instructable, avrai bisogno di alcune parti e strumenti. Fortunatamente per te, sono tutti elencati di seguito:

Nello spirito del Microcontrollers Contest, questo progetto è stato completamente realizzato con parti acquistate su Amazon! (non sponsorizzato)

Elenco delle parti:

• Arduino Uno
• Display a LED 8x8
• Sensore tattile capacitivo
• Sensore di umidità
• Connettore batteria 9V
• Batteria da 9V

Elenco strumenti:

• Cavo calibro 22
• Nastro elettrico
• Spelafili
• Saldatore
• Pompa dissaldante

Dopo aver raccolto tutta l'attrezzatura necessaria, è il momento di configurare il software Arduino!

Passaggio 3: installazione dell'IDE Arduino

Affinché questo progetto funzioni, dovremo essere in grado di programmare Arduino. Ciò richiede il download e l'installazione di Arduino Integrated Development Environment (IDE) sul tuo computer. È una spiegazione abbastanza semplice, ma ti guiderò attraverso il processo:

1. Visita il sito web di Arduino

2. Vai alla pagina dei download (Software > Download)

3. Fare clic sul collegamento di download per il proprio sistema operativo

Nota a margine: il programma funzionerà su Windows, Mac e Linux.

4. Installazione su Windows

• Fare doppio clic sul file scaricato per eseguirlo
• Fare clic su "Accetto" per accettare la licenza
• Segui il resto delle istruzioni
• Il programma dovrebbe ora essere installato!

(Assicurati di guardare gli screenshot se ti perdi)

5. Installazione su Mac

• Fare clic sul file scaricato
• Scegli "Apri"
• Il programma verrà installato ed eseguito automaticamente!

(Assicurati di controllare gli screenshot se ti confondi)

6. Questo è tutto

E hai finito! Ora hai scaricato l'IDE Arduino sul tuo sistema!

Passaggio 4: il codice

Questo passaggio riguarda il codice. È un programma abbastanza breve, quindi lo esaminerò con te e ti spiegherò come funziona. Prima una breve panoramica, poi una spiegazione approfondita e infine come spingerlo su Arduino!

La breve panoramica

Per quelli di voi non interessati alla spiegazione dettagliata del codice, sto fornendo un segmento TL;DR! Ecco la spiegazione di base. L'Arduino acquisisce i valori dal sensore di umidità ogni pochi secondi. Queste informazioni vengono quindi utilizzate per calcolare e visualizzare un determinato volto! C'è anche un po' di codice alla fine che consente al pulsante touch capacitivo di accendere e spegnere il display. Abbastanza semplice vero?

Il Nitty Gritty

Questa parte del tutorial è per coloro che sono molto interessati a come funziona l'intero programma, riga per riga. Fornirò schermate sopra per aiutarti a capire di cosa sto parlando, oltre a includere alcune righe di codice in questa descrizione.

Questo programma è suddiviso in cinque sezioni:

1. Inclusione di librerie e creazione di variabili
2. La funzione di configurazione
3. Funzioni per le espressioni facciali
4. La funzione Scrivi Arduino su Matrix
5. La funzione loop

Inclusione di librerie e creazione di variabili:

La prima sezione di questo codice riguarda le variabili e le librerie che utilizzeremo.

#include "LedControlMS.h"

#define TouchSensor 7 LedControl lc=LedControl(12, 11, 10, 1); int sensorePin = A5; int valoresensore = 0; bool iniziato = falso; bool su = vero; booleano premuto = LOW;

La prima riga include una libreria chiamata LedControlMS. Questa libreria è necessaria per poter inviare valori al display a LED. La riga successiva è un'istruzione define che imposta il pin per il sensore tattile su 7. Dopodiché abbiamo altre tre variabili che definiscono i pin per il display a LED, il sensore di umidità e il suo valore. Le ultime tre righe sono tutte booleane che regolano lo stato del pulsante touch e del display. Dopo questo, abbiamo i nostri valori in byte:

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

Questi valori rappresentano tutte le facce di APEX. Ogni byte è un array che contiene più bit che determinano lo stato di ciascun pixel in una determinata riga. "1" e "0" rappresentano rispettivamente On/Off.

La funzione di configurazione:

Passando alla sezione successiva, abbiamo la nostra funzione di configurazione.

void setup() { // Uscita seriale MS Serial.begin(9600);

pinMode(Sensore tattile, INGRESSO);

//Impostazione matrice LED lc.shutdown(0, false); lc.setIntensity(0, 4); lc.clearDisplay(0); }

Il nome lo spiega molto bene. È qui che "configuriamo" il nostro sensore tattile e il display. Le prime due righe iniziano il nostro output seriale (usato per il debug). La terza riga imposta il pin del sensore tattile su un ingresso e le ultime quattro righe avviano il display.

Funzioni per le espressioni facciali:

Questa è probabilmente la sezione più lunga di tutte, ma è tutta molto semplice e ripetitiva.

void rotto() { lc.setRow(0, 0, errore[0]); lc.setRow(0, 1, errore[1]); lc.setRow(0, 2, errore[2]); lc.setRow(0, 3, errore[3]); lc.setRow(0, 4, errore[4]); lc.setRow(0, 5, errore[5]); lc.setRow(0, 6, errore[6]); lc.setRow(0, 7, errore[7]); }

vuoto felice() {

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

vuoto pianura() {

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]); }

vuoto sorpreso(){

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

vuoto morente() {

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

pianto vuoto() {

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

void malesmile() {

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]); }

void 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]); }

void chiacchiere () {

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]); }

Queste funzioni vengono utilizzate per definire ogni espressione facciale utilizzando i nostri valori in byte della prima sezione. Ogni riga definisce una posizione x e valori di byte e quindi applica i valori a quella colonna. Alcune funzioni richiedono più righe perché ci sono più righe utilizzate per visualizzare i valori di quella faccia. Ogni faccia è simmetrica, motivo per cui ripetiamo le linee.

La funzione WriteArduinoOnMatrix:

La quarta sezione viene utilizzata per calcolare e scrivere le facce corrette sul display a LED. Consiste in una serie di istruzioni else if che controllano i valori dell'acqua e quindi impostano la visualizzazione chiamando funzioni diverse dalla sezione precedente.

void writeArduinoOnMatrix() { if(sensorValue > 0 && sensorValue 30 && sensorValue 100 && sensorValue 200 && sensorValue 400 && sensorValue 650 && sensorValue <= 800) { sorpreso(); } else { rotto(); } }

Potresti notare che abbiamo aggiunto facce "rotte" nel caso in cui il sensore esca dai campi di lavoro. Ciò previene alcuni strani errori nulli che si verificano e ci offre una migliore comprensione visiva di ciò che sta accadendo all'interno del codice.

La funzione di ciclo:

Ultima ma non meno importante è la funzione loop. Questo codice fa esattamente quello che dice il suo nome, va in loop! Sebbene ci siano alcune righe in questa funzione, in realtà è abbastanza semplice. Il codice prima legge lo stato del pulsante e vede se il display è "On". Se trova che questo è vero, chiamerà la funzione WriteArduinoOnMatrix, che disegnerà quindi una faccia su APEX. Poiché questa funzione si ripete, aggiornerà il display tutte le volte che vogliamo. Questo ritardo è dettato dalla variabile delaytime.

void loop() { if (started == true){ delaytime = 3000; } //Leggi pulsante premuto = digitalRead(TouchSensor);

se (premuto) {

if (on == true) { lc.clearDisplay(0); acceso = falso; ritardo (ritardo); } else { on = vero; ritardo (ritardo); } } sensorValue = analogRead(sensorPin); ritardo (ritardo); if (on == true) { //Disegna facce writeArduinoOnMatrix(); }

iniziato = vero;

}

Questo è tutto quello che c'è da sapere sul codice. Spero che ora tu abbia una migliore comprensione di come funziona tutto e che tu possa usare questa conoscenza per iniziare a personalizzarlo per il tuo progetto!

Invio del codice ad Arduino

Ora che abbiamo coperto tutto il codice, è il momento di inviarlo ad Arduino! Fortunatamente, l'IDE lo rende molto semplice. Tutto quello che devi fare è collegare il tuo Arduino al computer con un cavo USB, quindi fare clic sulla freccia destra in alto a sinistra dell'IDE. Lascia che il codice spinga e dovresti vedere un messaggio di successo nella parte inferiore del programma se lo hai fatto bene!

Passaggio 5: diagramma del circuito

Analogamente al codice, lo schema del circuito non è troppo complicato. Consiste solo di tre sensori e Arduino, quindi ti dirò i pin-out per ciascuno e, se hai bisogno di altro aiuto, fai riferimento allo schema sopra.

Il display a LED:

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

Il sensore di umidità:

• Positivo -> 5V
• Negativo -> GRD
• Segnale -> A5

Il sensore tattile capacitivo:

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

Non troppo difficile, vero? Se hai problemi con questo pin-out, assicurati di fare riferimento al video qui sotto dove ti spiego come collegarlo.

Passaggio 6: mettere tutto insieme

È difficile spiegare sul testo come si adatta tutto insieme, quindi consiglierei sicuramente di dare un'occhiata al video per questa parte. In realtà non ho intenzione di spiegare esattamente come ho messo insieme il mio, è troppo difficile. Ma per spiegare le cose vagamente, ho saldato i collegamenti dei cavi e li ho avvolti attorno al retro della scheda. Poi ho posizionato i sensori e ho usato del nastro isolante per tenere tutto insieme. Infine, l'ho testato con la batteria da 9 V e poi, una volta saputo che funzionava, ho posizionato la batteria sul retro e ho registrato anche quella. Come ho detto prima, GUARDA IL VIDEO PER QUESTO PASSO, ha un bel piccolo segmento di saldatura che viene accelerato e ti aiuterà a avvolgere correttamente i fili. Sentiti libero di metterlo in pausa o riprodurlo a metà velocità se ti perdi.

Congratulazioni! Se tutto è andato a buon fine, ora dovresti avere un'unità APEX completamente funzionante!

Per testare la tua unità, trova una pianta innaffiata e collegala! Dovresti scoprire che è felice o sorpreso e questo significa che dovrebbe funzionare!!! Ottimo lavoro per completare il progetto!

Passaggio 7: conclusione

E questo è l'intero Instructable! Grazie per aver controllato il progetto! Lascia qualsiasi domanda e commento in basso e assicurati di seguire Urban Farming Guys per tutorial più interessanti come questo! Ci piacerebbe sapere come è andata la tua build APEX e le immagini sono molto apprezzate! Grazie ancora per essere passata, buona giornata!

(Questo Instructable è stato ispirato da un progetto più vecchio, il Plant Emoji!)

P. S. Questo Instructable è iscritto al concorso Microcontrollori, quindi non dimenticare di votare per noi! Lo apprezziamo molto:)

P. P. S. Prendiamo APEX in Make Magazine! Vota qui! Grazie:)