RoboYún, robot esploratore con webcam e controllo Wi-Fi

Sul sito Elettronica Open Source, ho già presentato alcuni modelli di robot comandati in remoto, come LittleBot che è comandato tramite Bluetooth , o un altro modello che era comandato tramite un telecomando ad infrarossi
L’opportunità data dal contest 20 Arduino Motor Shield di Infineon gratis per voi, ha portato all’idea di realizzare un nuovo modello di rover comandato in remoto utilizzando il sistema Wi-Fi. Per il controllo si è utilizzata una scheda Arduino Yún che è la combinazione di un classico Arduino Leonardo (basato sul processore ATMEGA32U4) con un sistema-one-chip Wi-Fi in cui viene eseguito Linino (un MIPS GNU / Linux basata su OpenWRT). Altre particolarità sono date dal fatto che sulla scheda sono presenti alcuni connettori tra i quali una porta USB Host a cui è possibile collegare una web camera, che gestita dalla sezione Linux, permette di trasmettere in streaming le immagini riprese attraverso la rete Wi-Fi.

Descrizione dei componenti base che formano il rover.

Cominciamo con la descrizione dei principali elementi che formano il Rover:

  • Base robotica con telaio in alluminio e 2 motoriduttori;
  • Scheda con controllo Arduino Yún;
  • Motor shield di Infineon (ricevuto tramite il contest 20 Arduino motor shield di Infineon gratis per voi )
  • Dispositivo Pan & Tilt per movimentazione webcam;
  • Shield con circuito gestione motori, dispositivo Pan & Tilt, sensori;
  • Scheda alimentazione;
  • Webcam.

Queste sono solo alcune delle caratteristiche del robot RoboYún:

Telaio Il telaio in alluminio di tipo commerciale prodotto dalla DFRobot: Turtle - 2WD Mobile Platform
Scheda di comando Scheda Arduino Yúnconsigliato l’uso di una memoria SD esterna per ospitare i propri files
Modulo comando motori DC Motor Control Shield with BTN8982TA for Arduino
Shield controllo Comando relè per inversione senso di rotazione motore
Comando fari a led per illuminazione frontale
Uscite per azionamento servo Pan & Tilt
Sensore Temperatura/umidità – Sensore DHT11
Webcam Webcam modello C170 della Logiteh - Altezza 60.5 mm, Larghezza 70.3 mm, Profondità 71 mm, Peso 75 g
Dispositivo Pan & Tilt Dispositivo Pan & Tilt SparkFun codice ROB-10335
Alimentazione 5 batterie tipo AA per una tensione di 7,5V
Modulo di tipo Step-Down basato sul circuito integrato LM2596S, per l’uscita di 5V alimentazione parte elettronica.
Motoriduttori In plastica con rapporto riduzione 1:120, alimentazione 7,5V, assorbimento 170 mA
Ruote Ruote di plastica e gomma, Diametro esterno: 65mm, Larghezza ruota: 26 millimetri, Hub: 6mm
Misure robot Diametro 170 mm altezza massima 170 mm
Peso robot  750 g, compreso batterie

descrizione_robotyun

Posizione delle varie parti che costituiscono il robot

Passiamo ora a una breve descrizione dei singoli componenti:

Base robotica

Il telaio utilizzato per la realizzazione del Rover è prodotto dalla DFRobots e il suo nome commerciale è Turtle - 2WD Mobile Platform, si tratta di un kit costituito da un corpo in alluminio, due motoriduttori, due ruote Tamiya racing (diametro 65 mm), un ballcaster in metallo, un portabatteria, un deviatore, una presa di alimentazione, le viti e i dadi.

Turtle_2wd

Il montaggio è molto semplice, è sufficiente seguire le indicazioni riportate sul manuale cartaceo (o in versione pdf) presente all'interno della confezione.

Motoriduttori

All'interno del kit della base robotica sono presenti due motoriduttori (SKU: FIT0016) con motore a corrente continua con un’uscita di 160 rpm se alimentati a 6V.

motore_robot

Caratteristiche Elettriche:

  • Tensione di funzionamento: 3 ~ 7.5V (6V nominale);
  • Max. A vuoto Corrente (3V): 140 mA (3V) - 170 mA (6V);
  • Velocità a vuoto (3V): 90 rpm (3V) - 160 rpm (6V);
  • Max. Coppia di uscita: 0.8 kgf.cm;
  • Max. corrente di Stallo: 2,8 A.

Condizioni Operative:

  • Carico stimato: 0,2 kgf.cm;
  • Temperatura di funzionamento: -10 ~ + 60 ℃;
  • Tipo motore: 130.

Caratteristiche meccaniche:

  • Modalità uscita: 2 lati;
  • Rapporto di trasmissione: 1:120;
  • Max. Diametro Asse di uscita: 5,4 millimetri;
  • Peso netto: 45 g

dimensioni_riduttore

Dimensioni del motoriduttore utilizzato

NOTA: Per ridurre le interferenze con la circuiteria elettronica causate dallo scintillio dovuto allo sfregamento delle spazzole del motore elettrico sul collettore, è consigliabile saldare tre condensatori ceramici (o meglio multistrato) da 100nF uno tra positivo e carcassa, uno tra negativo e carcassa e uno tra positivo e negativo. Nella Figura è visibile lo schema di collegamento dei condensatori utilizzati come filtri antidisturbo.

condensatori_motore

Scheda di controllo Arduino Yún

La scheda di controllo utilizzata è il modello Arduino Yún, in cui sono presenti due microcontrollori: il primo è un Atheros AR9331 che supporta una distribuzione Linux basata su OpenWRT chiamata Linino, il secondo è un ATmega32u4, lo stesso che utilizza la scheda Arduino Leonardo o la scheda Arduino Esplora.  La scheda offre così un potente computer connesso con il microcontrollore di Arduino, è dotata di connettore per rete Ethernet, Wi-Fi, slot MicroSD e di 20 pin di I/O, dei quali 7 PWM e 12 ingressi analogici, le sue dimensioni sono 73x53mm per un peso di 32g.

YunParts

Caratteristiche del microcontroller AVR Arduino

Microcontroller: ATMEGA32U4
Tensione di funzionamento:  5V
Tensione in ingresso: 5V
Pin di I/O Digitale: 20
Canali PWM: 7
Canali di ingresso analogici 12
Corrente per Pin I/O: 40 mA
Corrente sul Pin 3.3V:  50 mA
Flash Memory:  32 KB (di cui 4 KB utilizzato da bootloader)
SRAM: 2.5 KB
EEPROM:  1 KB
Velocità di clock:  16 MHz

Caratteristiche microprocessore Linux

Processore: Atheros AR9331
Architettura: MIPS @ 400MHz
Tensione di funzionamento:  3.3V
Ethernet:  IEEE 802.3 10 / 100Mbit / s
WiFi: IEEE 802.11b / g / n
USB tipo A: Host USB 2.0
Lettore di schede: Micro-SD
RAM:  64 MB DDR2
Memoria flash: 16 MB

Alimentazione

L’alimentazione della scheda avviene attraverso la connessione micro-USB con una tensione di 5VDC.  Se si vuole utilizzare il pin Vin, è necessario fornire una tensione di 5V DC stabilizzata, in quanto sulla scheda non è presente come nelle normali schede Arduino, l’apposito integrato regolatore. Fornire una tensione superiore può danneggiarla.

Memoria

Il processore ATMEGA32U4 ha 32 KB (con 4 KB per il bootloader). Ha anche 2.5 KB di SRAM e 1 KB di EEPROM (che può essere letta e scritta con la libreria EEPROM ).
La memoria dell’ AR9331 non è incorporata all'interno del processore.  La RAM e la memoria di archiviazione sono collegate esternamente. Yún ha 64 MB di DDR2 RAM e 16 MB di memoria flash.

Pin di Ingresso e uscita

Si dispone in totale di 20 pin di input/output digitali, di cui 7 da utilizzare come output PWM e 12 come input analogici.
Ciascuno di questi pin può essere pilotato in maniera indipendente dal software.
Alcuni di questi pin hanno comportamenti specifici:

  • I pin 0 (Rx) e 1 (Tx) possono essere utilizzati per la comunicazione seriale.
  • I pin 0, 1, 2, 3 e 7 possono essere configurati come trigger per eventi esterni
  • I pin 3, 5, 6, 9, 10, 11 e 13 possono essere configurati per generare segnali PWM con risoluzione di 8 bit
  • I pin A0-A5 e A6-A11 (sui pin digitali 4, 6, 8, 9, 10 e 12) sono gli ingressi analogici. Ognuno di questi pin può essere utilizzato come I/O digitale. Ogni ingresso analogico fornisce 10 bit di risoluzione (cioè 1024 valori differenti). Di default, gli ingressi analogici hanno un range che va da massa a 5V, anche se è possibile cambiare l'estremità superiore con il pin AREF.

Bridge

Come abbiamo visto Arduino Yún integra il microcontrollore ATmega32u4 e l'Atheros AR9331 in cui "gira" Linino, una distribuzione di Linux.  Il "Bridge" è una libreria che mette in comunicazione questi due componenti.

Bridge_arduino_yun

Dalla figura si nota come la microSD, l'interfaccia Wi-Fi ed Ethernet non siano direttamente connesse al microcontrollore ATmega; quest'ultimo ha accesso tramite il microprocessore AR 9331.  Il Bridge consente quindi ad Arduino di interfacciarsi con queste periferiche.

Motor shield della Infineon

Il controllo dei motori è realizzato tramite il motor Shield della Infineon che permette di controllare, tramite alcune porte I/O di Arduino, un motore DC nei due sensi di marcia, oppure due motori DC nello stesso di marcia.
Lo schema della scheda è molto semplice, essendo formato da un circuito per la protezione contro l’inversione di polarità e da due circuiti ponte circondati da pochissimi altri componenti passivi.

Motor_shield_Infineon_adrirobot

Circuito per la protezione contro l’inversione di polarità
Il circuito di protezione contro l’inversione della polarità è formato dal mosfet Q1 tipo IPD90P04P4L, prodotto dalla stessa Infineon, questi è un mosfet di potenza canale P, la qui polarizzazione è realizzata dalla resistenza R8 e dallo zener D1, mentre la tensione di alimentazione è limitata nel suo valore massimo tramite lo zener D2 da 39 V, il condensatore elettrolitico C4 da 1000µF è necessario per mantenere basso il ripple della tensione VS durante la commutazione.

protezione_alimentazione

Circuito di potenza
Il cuore della scheda è rappresentato da due integrati tipo BTN8982TA: si tratta di un integrato semiponte H, il circuito interno è formato da un MOSFET canale P e uno a canale N più il relativo circuito driver.
Il circuito è facile da controllare, poiché è sufficiente applicare segnali di livello logico al pin IN e INH.

infineon_motor_BTN8982TA_diagram

Quando si applica un segnale PWM (acronimo inglese di Pulse-Width Modulation o modulazione di larghezza di impulso) al pin IN, la corrente fornita al motore, può essere controllata tramite il duty cycle del PWM.
Con un resistore collegato esternamente tra il pin SR e GND è possibile regolare la velocità di risposta, o slew rate.

schema_ponte

Le principali caratteristiche dell’integrato sono:

  • Tensione d’ingresso nominale 8-18 V (max. 6 - 40 V);
  • Possibilità di controllo motori Brushed DC fino a 250 W con carico continuo
  • Unità per il controllo sia di un motore DC bidirezionale con spazzole o di due motori a corrente continua unidirezionali;
  • Corrente media pari a 30 A (BTN8982 ha una limitazione in corrente @55 A), il limite è dato dalla dissipazione del PCB;
  • Alta frequenza PWM, per esempio 30 kHz;
  • Slew Rate modificabile per EMI ottimizzato tramite resistori esterni;
  • Circuito del driver con ingressi a livello logico;
  • Protezione da sovraccarichi o temperature eccessive;
  • Diagnosi con current sense, protezione da sovratemperatura e sovracorrente;
  • Lo shield presenta già i collegamenti con i pin di controllo.

Modifiche effettuate sullo shield originale.

Allo shield originale sono state apportate alcune modifiche per adattarlo al progetto.
Inserimento morsettiere a vite: la scheda in origine prevede l’utilizzo di boccole per spinotto a banana con diametro 4 mm, si è invece preferito inserire le più comode morsettiere a vite. Per questo motivo si è dovuto forare il circuito ed effettuare qualche saldatura.

morsettiere

Modifica orientamento condensatore: il condensatore di livellamento C4 che era montato in verticale, per ridurre l’ingombro è stato montato orizzontalmente.
Isolamento pin alimentazione: esiste la possibilità che il pad dell’alimentazione vada a contatto con la presa usb (nel caso della scheda Arduino UNO) o con la presa ethernet (nel caso della scheda Arduino Yún) per questo motivo la scheda è stata isolata con del nastro adesivo.

modifiche

Sensore di temperatura e umidità

Il sensore di temperatura e umidità e il modello DHT11 che è un sensore con uscita dati in formato digitale. I suoi elementi sensibili sono connessi ad un processore 8-bit single-chip.
Ogni sensore è compensato in temperatura e calibrato in un'apposita camera di calibrazione che determina in modo preciso il coefficiente che viene poi salvato all'interno della memoria OTP.

Modello DHT11
Alimentazione 3-5.5V DC
Segnale di uscita digitale tramite single-bus
Elemento sensibile resistenza in  Polimero
Campo di misura umidità 20-90% di umidità relativa, temperatura di 0-50 gradi Celsius
Precisione umidità ±4% RH (Max ±5% di umidità relativa), temperatura ±2.0 Celsius
Risoluzione o la sensibilità umidità 1% di umidità relativa, temperatura 0.1 Celsius
Ripetibilità umidità ±1% di umidità relativa temperatura ±1 Celsius
Umidità isteresi ±1% RH
Stabilità a lungo termine ±0.5% UR / anno
Tempo di rilevazione medio: 2s
Dimensioni 12x 15,5 x5,5 millimetri

Il modello utilizzato venduto da Banggood è già montato su una basetta, insieme alla resistenza tra il pin di alimentazione e il pin dati, è inoltre presente un led che segnala la presenza dell’alimentazione. Il sensore è montato sullo speciale shield previsto sul robot ed è connesso al pin D7; per la sua gestione si utilizza una speciale libreria DHT.h.

sensore_dht11

Dispositivo PAN & TILT

Il dispositivo Pan & Tilt è analogo a quello già mostrato nell’articolo Gestione di un dispositivo Pan & Tilt con la scheda Arduino Esplora, questo è venduto dalla SparkFun codice ROB-10335.
Nel kit sono presenti i componenti meccanici cioè due staffe e tutto l’hardware necessario per il fissaggio, i servomotori devono essere presi a parte, quelli consigliati sono dei servo compatibili con il modello Hitec HS-55 codice Sparkfun ROB-09065 le cui caratteristiche sono:

  • Tensione: 4,8-6,0 V;
  • Coppia: 1,6/ 2 Kg/cm. (4.8 / 6.0V);
  • Velocità: 0.15 / 0.10 sec / 60 ° (4,8 / 6.0V);
  • Rotazione: ~ 160 °;
  • Ingranaggi in Nylon;
  • 3-Pole ferrite motore;
  • Dimensioni: 31,8 x 11,7 x 29 mm;
  • Filo Lunghezza: 160 mm;
  • Peso: 9g.

kit-pan_tilt

I due servo sono collegati allo speciale shield realizzato per il robot e risultano collegati alle porte D5 (servo Pan) e D6 (servo Tilt).
Per la gestione è utilizzata la libreria servo.h.

WebCam

RoboYún è dotato di una webcam, la scelta del modello, è fatta anche in funzione della possibilità di essere riconosciuta dalla sistema operativo della scheda Arduino Yún, quindi si è scelto il modello C170 della Logiteh.

c170

Questa WebCam è un modello poco costoso dalle buone caratteristiche, che sono:

  • Acquisizione video: Fino a 1024 x 768 pixel;
  • Tecnologia Logitech Fluid Crystal;
  • Foto: Fino a 5 megapixel (con interpolazione software);
  • Microfono incorporato con funzionalità di riduzione del rumore;
  • Certificazione Hi-Speed USB 2.0;
  • Clip universale per laptop e monitor LCD o CRT.

Shield con circuito gestione motori, dispositivo Pan & Tilt, sensori

Come abbiamo visto il motor Shield della Infineon, presenta un solo ponte H, per cui può gestire un solo motore DC nei due sensi di marcia, oppure due motori DC nello stesso senso di marcia.
Per questo motivo nell'azionamento dei motori sono utilizzati dei motor shield con intergrati tipo L293, SN754410, L298, che hanno al loro interno 4 ponti H, il che permette di gestire due motori nei due sensi di marcia.
Per aggirare il problema si è realizzato un apposito shield (Schema formato pdf) su cui sono montati due relè a doppio contatto, che permettono di invertire il senso di rotazione dei motori, indipendentemente dal senso dato dal modulo Infineon, che in questo caso viene utilizzato solo come regolatore della velocità di rotazione tramite la gestione PWM.

shield_yun

Il segnale proveniente dallo shield Infineon è applicato alla morsettiera X1, dove arriva ai due relè a doppio scambio controllati tramite i due transistor TR1 e TR2 (tipo BC547) pilotati dalle porte D2 e D4.

shield_yun_rele

Dettaglio della sezione gestione dei relè controllo rotazione motori.

L’attivazione dei relè è segnalato anche tramite i due Led D3 e D4, nel circuito sono poi presenti i diodi D1 e D2 che hanno il compito di scaricare rapidamente tutta l'energia accumulata nella bobina mantenendo la tensione inversa a valori accettabili e non dannosi per gli altri componenti.

rotazione_1

rotazione_2

Schema di attivazione  relè e rotazione motori

Sulla scheda sono inoltre presenti i connettori per il collegamento dei due servo del dispositivo di orientamento della webcam, il connettore per il sensore di temperatura/umidità e uno per il pilotaggio del circuito dei fari.

shield_yun_output

Sullo shield è poi montato un led di colore blu D5 controllato dalla porta D9 che è utilizzato per segnalare quando il robot è pronto ad accettare i comandi.
L’alimentazione +5V proveniente dal modulo regolatore è fornita alla morsettiera V_ALIM, dove tramite il ponticello JP1, viene trasferita al pin VIN per alimentare la scheda Arduino Yún. La funzione dei pin ingresso/uscita è riassunta in questa tabella:

Pin IN/OUT Funzione
D2 OUT Comando Relè 1
D3 OUT IN_1 (Infineon)
D4 OUT Comando Relè 2
D5 OUT Comando Servo TILT
D6 OUT Comando Servo PAN
D7 IN Sensore DHT11
D8 OUT Gestione Faro
D9 OUT Led blu
D11 OUT IN_2 (Infineon)
D12 OUT INH_1 (Infineon)
D13 OUT INH_2 (Infineon)
A0 IN IS_1 (Infineon)
A1 IN IS_2 (Infineon)

shield_yun_pin

L’elenco dei componenti per la sua costruzione è:

Sigla Componente
D1, D2  Diodo 1N4148
D3, D4 Diodo led ø 3mm Rosso
D5  Diodo led ø 3mm Blu
R1,R2, R7 Resistenza 390 Ω ¼ W
R3,R4 Resistenza 4,7 kΩ ¼ W
R5, R6  Resistenza 10 kΩ ¼ W
RL1, RL2 Relè FINDER tipo 30.22.7.005.0010, 5VDC
TR1, TR2 Transistor tipo BC547
X1  Morsettiera 3 poli passo 2,5 mm
MOT_A, MOT_B, V_ALIM Morsettiera 2 poli passo 2,5 mm
FARI, PAN, TILT Pinhead 3 poli maschio
DHT1 Pinhead 3 poli femmina
JP1 Pinhead 2 poli mascho con jumper

I componenti sono montati su una scheda prototipo tipo Proto shield R3.

ArduinoProtoShield

Circuito fari

Per l’illuminazione della zona sorvegliata dal robot si utilizzano due led bianchi ad alta luminosità, montati su due piccoli circuiti stampati fissati al telaio. Per il pilotaggio dei led si è utilizzato un transistor in modo da non sovraccaricare la porta di Arduino.

schema_fari_robot

STAMPATO_FARI

L’elenco dei componenti:

Sigla  Componente
D1, D2 Diodo led bianco ad alta luminosità ø 5mm
R1  Resistenza 4,7 kΩ ¼ W
R2,R3  Resistenza 100 Ω ¼ W
TR1 Transistor tipo BC547
JP1 Pinhead 3 poli maschio
JP2, JP3 Pinhead 2 poli maschio

Alimentazione del robot

L’alimentazione del robot è fornita dal pacco batteria composto da 5 batterie da 1,5V per un totale di 7,5V.

LM2596_DC-DC_Step_Down-Circuit

Il modulo utilizzato per la regolazione della tensione di alimentazione è basato sul circuito integrato LM2596S: questa serie di regolatori monolitici fornisce tutte le funzioni attive, per realizzare un regolatore di commutazione di tipo Step-Down (buck), in grado di erogare sino a 3A con ottima regolazione del carico.
Questi dispositivi sono disponibili sia con tensioni fisse di uscita 3.3V, 5V, 12V oppure nella versione con uscita regolabile.
Per realizzare il circuito è richiesto un numero minimo di componenti esterni, questi regolatori sono semplici da usare avendo un circuito interno di compensazione della frequenza e un oscillatore a frequenza fissa.
La serie LM2596 opera a una frequenza di commutazione di 150 kHz permettendo l’uso di componenti del filtro di dimensioni più piccole di quanto sarebbe necessario con regolatori a commutazione operanti a frequenza inferiore.
Altre caratteristiche includono una tolleranza del ± 4% sulla tensione di uscita e ± 15% della frequenza dell’oscillatore.
E’ possibile la funzione di Shutdown esterno, con una corrente di standby di circa 80 μA.
Sono inoltre presenti funzioni di protezione che includono un limitatore della corrente d’uscita e l'arresto in caso si surriscaldamento o di guasto.

LM2596_DC-DC_Step_Down-foto

Nel nostro caso è stato utilizzato un piccolo modulo commerciale dalle ridotte dimensioni (con uscita regolabile tramite un trimmer multigiro) le cui caratteristiche sono:

  • Tensione di ingresso: da 3 V a 40 V;
  • Tensione di uscita regolabile: da 1,5 V a 35 V (la tensione d’uscita deve essere almeno 1,5V più elevata dell’ingresso);
  • Corrente massima: 3 A;
  • Dimensioni: 48,35 x 23,35 x 14 mm.

Montaggio del robot

Le operazioni di montaggio sono molto semplici poiché il telaio è già dotato di tutte le forature necessarie.
Le schede Arduino Yún, il motor Shield della Infineon e lo sheld di gestione si montano una sull'altra, un po’ di manualità sarà necessaria per effettuare i vari cablaggi, come visibile nello schema sotto riportato.

schema_collegamento

Programmi di gestione.

Per la gestione del robot tramite la rete Wi-FI è previsto l’utilizzo di un’interfaccia che potrà essere caricata su un PC o su un Tablet.
L’interfaccia è al momento in via di completamento: è composta da una normale pagina web che viene caricata all’interno della memoria della scheda Arduino Yún.
Questa pagina potrà essere richiamata direttamente tramite l’indirizzo della scheda se questa è collegata senza access point ip di default tramite:
http://192.168.240.1/sd/robot/ index.html
oppure se la scheda è connessa con access point con il comando
http://arduino.local/sd/robot/ index.html
Il video stream potrà essere visto all’indirizzo:
http://arduino.local:8080/stream.html
Il Pannello di controllo è formato da due frame in cui il quello superiore mostrerà le immagini riprese dalla webcam, mentre in quello inferiore è presente l’interfaccia di comando.

pannello_controllo_robot

Per la gestione dei comandi è utilizzata una libreria javascript Open Source chiamata Zepto , questa è rilasciata con licenza MIT ed è largamente compatibile con jQuery e destinata ai browser moderni e in particolare a quelli dei dispositivi mobili e proprio per questo motivo è piccolissima (5-10 kb) anche rispetto a jQuery.
Zepto utilizza le stesse API di jQuery in modo che gli sviluppatori possano utilizzarla senza dover imparare nuove istruzioni, per questo motivo insieme alle pagine HTML sarà necessario inserire anche il file: “zepto.min.js”.
Il listato del programma di gestione sarà inserito in un futuro articolo, in questa fase si procederà solamente a testare le varie parti e a collegare e installare i driver per la gestione della webcam. Per quanto riguarda la programmazione di Arduino Yún utilizzeremo il relativo IDE, che in questo momento è disponibile nella versione 1.6.6.

IDE_arduino_ver-1.6.6

Una volta installato, basterà selezionare Arduino Yún dal menu Strumenti> Board.
Per i dettagli, vedere la pagina reference e tutorials .
L'ATmega32U4 su Arduino Yún è fornito con un bootloader che permette di caricare un nuovo codice senza l'uso di un programmatore hardware esterno.  È anche possibile programmarlo direttamente utilizzando il collegamento Wi-Fi.

Programma di test

Per verificare il funzionamento del programma potremmo caricare RoboYun_test, che permette di testare tutte le varie parti.
Le varie fasi dell'esecuzione del programma possono essere seguite tramite il collegamento WiFi, in quanto i messaggi del programma sono inviati al computer  con il comando "console", questi  utilizzando il bridge,  che consente di inviare informazioni da Yún ad un computer proprio come si farebbe con il monitor seriale, ma in modalità wireless.
Il programma testerà in sequenza le varie parti del robot:

  • Accensione Fari
  • Accensione led blu
  • Test servo Pan (effettuare il test senza la webcam)
  • Test servo Tilt
  • Test sensore temperatura/umidità
  • Test motori

Una volta caricato il programma, si dovrà attivare il monitor seriale, che mostrerà le varie fasi di esecuzione del programma.

attivazione_programma

out_test_robot

Listato del programma di test

#include <Servo.h>   //Libreria gestione servomotori
#include "DHT.h"     //Libreria gestione sensore
#include <Console.h> //Libreria 

#define DHTTYPE DHT11    // Definisce il tipo di senore DHT 11
#define DHTPIN 7         // Definisce il pin a cui è collegato
DHT dht(DHTPIN, DHTTYPE);// Inizializza il sensore DHT11

Servo panservo;
Servo tiltservo;
const int rele_1 = 2;
const int rele_2 = 4;
const int fari = 8;
const int led_1 = 9;
const int vel = 120;


// Assegnazione dei pin per il primo half-bridge
const int IS_1 = A0; // current sense and diagnostics
const int IN_1 = 3; // input (PWM)
const int INH_1 = 12; // inhibit (low = sleep)

// Assegnazione dei pin per il secondo half-bridge
const int IS_2 = A1; // current sense and diagnostics
const int IN_2 = 11; // input (PWM)
const int INH_2 = 13; // inhibit (low = sleep)

void setup() {
  
  // initializa la comunicazione seriael
  Bridge.begin();
  Console.begin();
  // Gestione servo
  tiltservo.attach (5); // Collega il servo Tilt alla porta D5
  panservo.attach (6); //Collega il servo Pan alla porta D6
  tiltservo.write(90); //tilt servo al centro
  panservo.write(90); // panservo al centro

  // Gestione relè
  pinMode(rele_1, OUTPUT);
  digitalWrite(rele_1, LOW);
  pinMode(rele_2, OUTPUT);
  digitalWrite(rele_2, LOW);

  // Impostazione stato input/output dei pin
  pinMode(IS_1, INPUT);
  pinMode(IN_1, OUTPUT);
  pinMode(INH_1, OUTPUT);
  pinMode(IS_2, INPUT);
  pinMode(IN_2, OUTPUT);
  pinMode(INH_2, OUTPUT);
  pinMode(fari, OUTPUT);
  pinMode(led_1, OUTPUT);

  // Impostazione pin gestione motori
  analogWrite(IN_1, 0); // set motor speed to 0
  digitalWrite(INH_1, HIGH); // enable OUT1
  analogWrite(IN_2, 0); // set motor speed to 0
  digitalWrite(INH_2, HIGH); // enable OUT2
  digitalWrite(led_1, HIGH); // robot operativo

  while (!Console) {
    ; // Attesa per la connessione con la Console.
  }
  Console.println("Connessione stabilita!!!!");
  digitalWrite(led_1, HIGH);
}

void loop() {
  //Messaggio iniziale
  Console.println("");
  Console.println("TEST FUNZIONAMENTO RoboYun");
  Console.println("By Adriano Gandolfo");
  Console.println("");

  //Test funzionamento fari
  Console.println("TEST FUNZIONAMENTO FARI");
  Console.println("Fari accesi");
  digitalWrite(fari, HIGH);
  delay (1000);
  Console.println("Fari spenti");
  digitalWrite(fari, LOW);
  delay (1000);
  Console.println("");

  //Test funzionamento led blu
  Console.println("TEST FUNZIONAMENTO LED BLU");
  Console.println("Led BLU acceso");
  digitalWrite(led_1, HIGH);
  delay (1000);
  Console.println("Led BLU spento");
  digitalWrite(led_1, LOW);
  delay (1000);

  // Test del servo Pan
  Console.println("");
  Console.println("TEST FUNZIONAMENTO SERVO MOVIMENTO PAN");
  panservo.write(45);
  delay(1000);
  panservo.write(0);
  delay(1000);
  panservo.write(90);
  delay(1000);
  panservo.write(135);
  delay(1000);
  panservo.write(160);
  delay(1000);
  panservo.write(90);
  delay(1000);

  // Test del servo TILT
  Console.println("");
  Console.println("TEST FUNZIONAMENTO SERVO MOVIMENTO TILT");
  tiltservo.write(45);
  delay(1000);
  tiltservo.write(0);
  delay(1000);
  tiltservo.write(90);
  delay(1000);
  tiltservo.write(135);
  delay(1000);
  tiltservo.write(160);
  delay(1000);
  tiltservo.write(90);
  delay(1000);

  // Test sensore
  float t = dht.readTemperature();
  float h = dht.readHumidity();
  Console.println("");
  Console.println ("TEST SENSORE TEMPERATURA/UMIDITA'");
  Console.print ("Temperatura :");
  Console.print (t);
  Console.println (" C");
  Console.print ("Umidita'    :");
  Console.print (h);
  Console.println (" %");

  // Test funzionamento motori
  // Robot AVANTI
  Console.println("");
  Console.println ("TEST FUNZIONAMENTO MOTORI");
  Console.println("Robot Avanti");
  avanti(vel);
  delay(2000);

  // Robot INDIETRO
  Console.println("Robot Indietro");
  indietro(vel);
  delay(2000);

  // Robot a DESTRA
  Console.println("Robot rotazione oraria");
  destra(vel);
  delay(2000);

  // Robot a Sinistra
  Console.println("Robot rotazione antioraria");
  sinistra(vel);
  delay(2000);

  //Robot fermo
  Console.println("Robot fermo");
  fermo();
  delay(5000);
}

//Routine

void avanti(int motorSpeed) {
  digitalWrite(rele_1, HIGH);
  digitalWrite(rele_2, HIGH);
  delay (100);
  analogWrite(IN_1, motorSpeed);
  analogWrite(IN_2, motorSpeed);
}

void indietro(int motorSpeed) {
  digitalWrite(rele_1, LOW);
  digitalWrite(rele_2, LOW);
  delay (100);
  analogWrite(IN_1, motorSpeed);
  analogWrite(IN_2, motorSpeed);
}

void destra(int motorSpeed) {
  digitalWrite(rele_1, HIGH);
  digitalWrite(rele_2, LOW);
  delay (100);
  analogWrite(IN_1, motorSpeed);
  analogWrite(IN_2, motorSpeed);
}

void sinistra (int motorSpeed) {
  digitalWrite(rele_1, LOW);
  digitalWrite(rele_2, HIGH);
  delay (100);
  analogWrite(IN_1, motorSpeed);
  analogWrite(IN_2, motorSpeed);
}

void fermo() {
  digitalWrite(rele_1, LOW);
  digitalWrite(rele_2, LOW);
  analogWrite(IN_1, 0);
  analogWrite(IN_2, 0);
}

Collegamento webcam

Vediamo ora come collegare la webcam C170 alla scheda Arduino Yún.
La distribuzione Linino in esecuzione su Arduino Yún è in grado di gestire le webcam supportate dal driver UVC.
Prima di collegare la webcam, dobbiamo però installare qualche pacchetto software, per questo motivo dovremmo necessariamente collegare Arduino Yún in rete con la possibilità di navigare in internet.
Una volta collegati con un browser (Internet Explorer, Google Crome o quello che preferite) dovrete accedere all’interfaccia grafica di Arduino e, dopo aver inserito la password, poi “Configure” e “Advanced configuration panel”:

cam_1

Ora dal menu selezioniamo System, e poi Software:

cam_2

Premiamo il pulsante Update lists per aggiornare la lista dei software disponibili:

cam_3

Nel campo filtro digitiamo il nome del pacchetto kmod-video-uvc, spostiamoci nel tab Available packages e installiamolo:

cam_4

cam_5

Facciamo lo stesso per il pacchetto fswebcam:

cam_6

cam_7

Colleghiamo ora la webcam alla porta USB Host di Arduino Yún . Per essere sicuri che Linino l’abbia riconosciuta, visualizziamo il System log di sistema:

cam_8

Tra le informazioni mostrate dovreste vedere quelle che riportano le informazioni della webcam, segno che è stata correttamente configurata:

cam_9

Dato che il nostro progetto prevede la trasmissione di uno streaming video, è necessario caricare un’ulteriore applicativo, realizzato sempre per Linux che è denominato mjpg-streamerQuesto applicativo è in grado di catturare il video dalla webcam e renderlo disponibile tramite interfaccia web.
Per l’installazione dovremo spostarci nella cartella /tmp e scaricare il pacchetto tramite wget (che è un gestore di download per Linux)

wget http://www.custommobileapps.com.au/downloads/mjpg-streamer.ipk

Installiamo il pacchetto con opkg:

opkg install mjpg-streamer.ipk

cam-10

Procederemo a questo punto a modificare il file /etc/config/mjpg-streamer mettendo a 1 il parametro enabled.
Sempre nello stesso file potremo cambiare risoluzione, frame rate…,ecc.
Per fare questo è stato utilizzato WinSCP che è un client grafico open source per Windows per SFTP e FTP.  La sua funzione principale è quella di copiare in modo sicuro file tra un computer locale e uno remoto, ma permette tra le altre cose di muoversi agevolmente nelle varie cartelle di Arduino Yún

cam_11

Eseguiamo ora il programma:

cam-12

Collegandoci con il browser all’indirizzo di Yún e alla porta 8080 possiamo visualizzare l’interfaccia di mjpg-streamer, e se selezioniamo la voce Stream potremo vedere il video proveniente dalla webcam. A questo punto saremo sicuri che tutto il processo d’installazione ha avuto successo.

cam_13

Filmato illustrativo

E’ possibile vedere l’esecuzione del programma visionando il filmato:

Conclusioni

Termina così quest’articolo in cui si sono analizzate le parti che costituiscono il nostro robot a comando Wi-Fi, lo shield di Infineon e la possibilità di utilizzarlo per la gestione di una coppia di motori, aggirando la limitazione dovuta alla presenza di un solo ponte H.
Abbiamo anche visto come utilizzare una semplice webcam in accoppiamento con una scheda Arduino Yún per permettere la trasmissione di filmati in streaming.
Nel prossimo articolo vedremo l’interfaccia di comando e lo doteremo del programma completo.
Chi vorrà potrà comunque partire da questa base per realizzare una propria versione di robot, inserendo magari altri sensori, permettendo al robot di muoversi autonomamente: per esempio inserendo dei sensori radar in modo da controllare la presenza di eventuali ostacoli, mentre l’inserimento di un sensore di luce permetterebbe la gestione in automatico dell’accensione dei fari.

Registrati gratuitamente all'Embedded IOT

Registrati gratis all'EmbeddedIOT
STAMPA     Tags:, ,

14 Commenti

  1. Ernesto Sorrentino 16 settembre 2015
    • adrirobot 16 settembre 2015
  2. Davide Japan 22 settembre 2015
    • adrirobot 22 settembre 2015
  3. Davide Japan 22 settembre 2015
    • adrirobot 22 settembre 2015
  4. Davide Japan 23 settembre 2015
    • adrirobot 23 settembre 2015
  5. adrirobot 25 settembre 2015
  6. Davide Japan 25 settembre 2015

Scrivi un commento