COMUNICAZIONE

NAO-ARDUINO-SERVER IFTTT-SMART PLUG

SAPEREAUDE liceo classico G. D’ Annunzio

-Ad un certo comando vocale,

tramite un blocco di Python, NAO
manda un input numerico ad
arduino, il quale, in funzione di
questo, apre una connessione con
l’host: “maker.ifttt.com” ed
effettua una richiesta web per far
partire un automazione che
accende o spegne una presa
Wi-Fi.
Per realizzare questo progetto
abbiamo utilizzato:
-Ambiente di sviluppo per NAO:
Choregraphe.
-Arduino YUN REV2.
-Applicazione per la domotica
“IFTTT”.
-Smart Plug WiFi tp-link.
Per prima cosa creiamo un evento
con l’applicazione ifttt.
Nella sezione “if this” scegliamo
“Webhooks” e poi clicchiamo su
web request.
Successivamente diamo un nome al
nostro evento, ad esempio
EVENTO1

Nella sezione “then that” creiamo

l’azione che vogliamo eseguire, nel
nostro caso accendere un
dispositivo tp-link Kasa. Quindi
selezioniamo il dispositivo di
interesse e poi l’azione che vogliamo
fargli svolgere. Poiché dovremo
anche spegnere il nostro dispositivo
creeremo due diversi progetti.

Arrivati a visualizzare la schermata

che vedete di fianco clicchiamo su
“continue”, revisioniamo il progetto
,e poi su “finish”.
A questo punto abbiamo creato la
nostra automazione. Non ci resta
che collegarla con arduino.

Torniamo nella home page e

clicchiamo sul nostro account,

quindi andiamo su” help center “e

cerchiamo “Webhook service FAQ”;
apriamo il link “Webhook service”e
andiamo nella sezione
“documentation”.
Sostituiamo “{event}” con il nome
del nostro evento prestando
attenzione a scriverlo
correttamente.
Nel link, dopo “key”, sarà presente il
nostro codice personale. A questo
punto basta copiare il link
escludendo l’host (quindi a partire
da /trigger….). Questo link verrà
usato nel codice di Arduino che
illustreremo nelle prossime slide.
ARDUINO
-Nella parte di “setup” includiamo le
librerie necessarie al nostro programma.

-Definiamo alcune variabili e costanti che

ci torneranno utili in seguito.

-Inizializziamo il server attribuendogli la

“PORT”, definita nella costante omonima.

Nella funzione Void:

-Inizia il “Bridge” ovvero la comunicazione

tra il processore linux installato sulla
scheda e la scheda Arduino stessa.

-Inizia la comunicazione con il monitor

seriale.

-Apriamo il server che avevamo

precedentemente inizializzato.

-Incolliamo sul monitor seriale

alcune frasi al fine di avere un feedback
visivo dalla scheda.

Nella funzione loop:

-Definiamo la variabile
echo_message, che servirà a
restituire un feedback al
NAO.

-Accettiamo la connessione
di un client al server.

-Tramite alcuni controlli di

flusso (if ; while), ci
assicuriamo che il client sia
connesso e in grado di
comunicare.

-A questo punto incolliamo

sul monitor seriale “Client
disponibile” e “leggiamo” il
comando inviato dal client,
ovvero NAO, inserendolo
nella variabile “comando”.
 Tramite l’operatore “if”
controlliamo la variabile
comando: se questa è uguale a
0, eseguiamo il programma
sottostante per spegnere la
SmartPlug, altrimenti se
“comando” è uguale a 1
* eseguiamo il programma
analogo con opportuno link per
accendere la presa.

-Per prima cosa comunichiamo

al Nao che stiamo accendendo la
presa (tramite client.write),
successivamente iniziamo la
connessione al server
“maker.ifttt” mediante il suo
indirizzo ip e la sua porta web
(client.connect(ip,port)).

-A questo punto se Arduino è

correttamente connesso al
server (lo controlliamo con
“if(client.connect())”), inviamo
all’host il link che vogliamo
richiedere. Questo link è
personale e diverso per ogni
progetto IFTTT, lo possiamo
ottenere nella sezione
“documentation” del nostro
progetto IFTTT.
Eseguita la richiesta, sul serial
*Inserisci il link monitor verranno riportate
alcuni frasi di controllo tra cui la
ottenuto dalla sezione risposta del server, ottenuta
documentation tramite il comando
“client.readStringUntil” che
sull’app ifttt .
“legge” fino al valore (‘\n’)
ovvero fino all’ andata a capo, se
questo corrisponde a
“Congratulation…” sul serial
monitor appare “Richiesta http
eseguita con successo “
altrimenti “Richiesta http
fallita”.

Successivamente arduino
incollerà sul monitor la risposta
che il server aveva restituito.

Infine è effettuata la
disconnessione dal server e con
il comando “break;” il
programma ricomincia dal ciclo
“loop”.
 Questo è quanto viene
visualizzato durante
l’esecuzione del programma sul
serial monitor.

-Nell’ultima parte di codice troviamo

alcune istruzioni per il debug:

-Se if(client.connect()) restituisce valore

false (Arduino non è connesso al server di
cui specifichiamo ip e porta tra le parentesi
tonde) allora con il primo else in figura, il
programma incolla sullo schermo
“impossibile connettersi al server”.

Analogamente, nel caso in cui if

(comando==1) e if(comando==0)
restituissero entrambi valore false (Il
comando è diverso da 0 e da 1) il
programma passa per il secondo else e:
incolla sul serial monitor “Il carattere
ricevuto è improprio” .

-Il terzo else è collegato con il primo

if(client.connected()) ovvero quello che
verifica se un client è connesso al server
aperto da Arduino. Nel caso in cui questo
restituisse valore negativo allora sullo
schermo troveremo “Nessun client
connesso”.

Dopo aver incollato questa stringa il

programma aspetta 5 secondi
(delay(5000)) e poi verifica di nuovo che un
client sia connesso. In breve: controlla se
un client è presente, se no, incolla “Nessun
client connesso”, attende 5 secondi e poi
ricomincia, se si, procede con il codice
contentuto nell’if.
Python-Choregraphe

L’ultima cosa che ci rimane da fare è

creare un box di python che permetta al
NAO di comunicare con Arduino.

-Apriamo un progetto di Choregraphe e

clicchiamo: tasto destro/create new
box/python. Diamo un nome al blocco, e
nella sezione “parameters” clicchiamo su
“+”.

Come raffigurato,nominiamo il parametro

“Yun Ip adress”, facendo attenzione alle
lettere maiuscole e agli spazi, poi
selezioniamo il tipo di variabile “String” e
clicchiamo “ok”.

Premiamo nuovamente su ”+” ,ma questa

volta chiamiamo il parametro “Port” e
selezioniamo il tipo di variabile “Integer”,
quindi premiamo “ok”.
Dopo aver premuto ”ok” visualizzeremo una
schermata come questa; assicuriamoci che il
valore “Default value ” sia uguale a quello
mostrato in figura. Il valore “Max value” è
sufficiente che sia maggiore del valore “Default
value”.

Facendo click sulla chiave inglese,

presente in basso a sinistra nel
blocco python sarà possibile
regolare i parametri. Il parametro
Port sarà già impostato su 7891
(ovvero la porta web del server
aperto da Arduino).

Nella sezione “Yun Ip adress

dovremo incollare l’indirizzo ip
dell’Arduino
Possiamo trovare l’indirizzo ip caricando su
arduino un semplice programma reperibile
sull’IDE, nel seguente percorso:
File/Esempi/Bridge/WiFiStatus.

Eseguendo questo sketch verranno mostrati sul

serial monitor (Strumenti/Monitor seriale) alcune
informazioni riguardanti la rete, tra cui l’ip.
Copiamolo e incolliamolo nel blocco python.

Se non troviamo la libreria Bridge, possiamo

installarla tramite la “Gestione librerie”
(Strumenti/Gestione librerie).

Apriamo il pannello per la gestione delle librerie e

digitiamo nella barra di ricerca “Bridge.h” quindi
installiamola. Seguiamo lo stesso procedimento
se non abbiamo ancora installato le altre librerie
(YunClient.h;YunServer.h;string.h) necessarie al
programma principale.

Nota: NAO e Arduino

devono essere connessi
alla stessa rete

Per entrare nella parte di codice del blocco

python facciamo doppio click sopra di esso.

-Come prima cosa importiamo la libreria

socket che contiene le funzioni necessarie
alla connessione con Arduino.

La comunicazione che svolgeranno NAO e

Arduino si chiama TCP/IP ed è una
comunicazione a pacchetti tra due indirizzi
ip.

-Creiamo la classe “MyClass” quindi

creiamo la variabile command (con le
virgolette stiamo comunicando a python
che “command” è una variabile di tipo
stringa, infatti la sintassi prevista per
questo tipo di variabile prevede il doppio
apice)

-Le funzioni (def) che vediamo a seguire

servono a definire alcune informazioni per
gli input e gli output del blocco di python.
Possono essere utilizzate senza apportare
modifiche.
-Con la funzione onInput_userCommand
“inseriamo” l’input che entra nel blocco python
sotto forma di stringa, nella variabile
“user_word” e quidni la incolliamo sul log
viewer assieme alla frase “Comando
ricevuto:”(il log viewer sarebbe una sorta di
serial monitor di Arduino. Vi possiamo accedere
tramite: View/Log viewer).

-Nella funzione “processing” inizia la

connessione ad Arduino:

Dopo aver inizializzato la connessione TCP/IP

l’istruzione “soket_ny.connect” connette NAO
all’ indirizzo ip e porta, specificati nei parametri
del blocco python.

Una volta connesso incolla sullo schermo

“Connesso a: “ e l’indirizzo ip dell’Arduino.

-Controlliamo la variabile “command” con if ed

elif (else if ,in python): se questa è uguale ad
“accendi” inviamo al server a cui siamo connessi
(con soket_ny.send()) il valore 1, se è uguale a
“spegni” inviamo 0 e se è diversa da entrambi
inviamo 2. In questo modo Arduino riceverà il
valore che serve a indicargli se accendere (1) o
spegnere (0) la luce, altrimenti riceve 2 e
comunicherà a NAO “Il carattere ricevuto è
improprio”.

Nelle ultime righe del codice NAO riceve (con

soket_ny.recv) la variabile echo_message, che
gli invia Arduino. Questa contiene il feedback
del programma: se Arduino ha ricevuto 1 allora
“echo_message” sarà: “Accendo la luce”,se 0:
“Spengo la luce”, se riceve 2 (quindi l’input del
blocco python è diverso da “accendi” o
“spegni”): “Errore! Il comando ricevuto è
improprio.
Nel caso del nostro programma,
abbiamo collegato il blocco python ad
uno di riconoscimento vocale, perciò
l’input proveniente da esso sarà di
tipo stringa.

Assicuriamoci che l’output del blocco

“Speech reco.” e l’input del blocco
“python” siano impostati come
raffigurato.
La nostra guida si conclude, speriamo vivamente di essere stati quanto più esaustivi possibile nello spiegare il nostro
progetto.

Buona programmazione!

Il team “SAPEREAUDE” del liceo classico Gabriele D’ Annunzio di Pescara.

PE, 24/4/2022.