SCHEDA Arduino Esplora - Gestione dispositivo Pan & Tilt

Sulla scheda troviamo un processore PIC18F14K50-I/SS a 8 bit, 48MHz, memoria 16 kB, memoria dati da 256 bytes., con implementare di un’interfaccia USB V2.0, risuonatore per il clock, un regolatore di tensione, tre led di stato e vari connettori con funzione di alimentazione di interfaccia e per il collegamento dei servomotori
Supporta tre metodi di controllo: USB per una connessione diretta con il computer, seriale TTL per l'utilizzo con sistemi embedded, e internal scripting per applicazioni integrate, senza bisogno di un controllore esterno. I canali possono essere configurati come uscite servo per utilizzarli con i normali servo RC da modellismo o con gli ESC (Electronic Speed Control), come uscite digitali, oppure ancora come ingressi analogici.
Con il modulo è possibile il controllo integrato di velocità ed accelerazione su ciascun canale rendendo possibile ottenere movimentazioni morbide e senza scatti.
Ogni scheda può essere collegata in cascata con altri controllers Pololu su una singola linea seriale. Il firmware della scheda è aggiornabile.
Il modulo Micro Maestro ha tre led indicatori di tre colori diversi: il LED verde indica lo stato del dispositivo USB, il led rosso error/user di solito indica un errore, il LED giallo indica lo stato di controllo.

I comandi per la gestione di servomotori disponibili per il Micro Maestro in modo Pololu sono:

• Set Target – Impostazione della posizione del servo
• Set Speed - Imposta la velocità con cui il servo raggiunge la posizione assegnata
• Set Acceleration - Questo comando imposta l'accelerazione del servomotore
• Get Position - Questo comando consente di ricevere il valore di posizione di un servomotore.
• Get Moving State - Questo comando è utilizzato per determinare se le uscite servo hanno raggiunto la loro posizione finale o stanno ancora cambiando.
• Get Errors - Utilizzato per esaminare gli errori che il Maestro ha rilevato.
• Go Home - Questo comando porta tutti i servi alle loro posizioni iniziali

Protocollo : 0xAA, numero del dispositivo, 0x04, numero servo, target low bit, target high bit.

Si utilizza questo comando per ruotare il servo di un determinato angolo.
Nel nostro caso il target rappresenta la larghezza dell'impulso da trasmettere in unità di quarti di microsecondi.
Un valore di 0 indica alla scheda di interrompere l'invio di impulsi al servo.
Ad esempio: se si vuole inviare sul canale 2 un impulso di 1500 ms (1500 × 4 = 6000 = 01011101110000 in binario), è possibile inviare la seguente sequenza di byte:
• in binario: 10000100, 00000010, 01110000, 00101110
• in esadecimale: 0x84, 0x02, 0x70, 0x2E
• in decimali: 132, 2, 112, 46

Protocollo: 0xAA, numero del dispositivo, 0x07, numero servo, accelerazione bit bassi, accelerazione bit alti.

Questo comando limita la velocità con cui cambia il valore di uscita di un canale servo. Il limite di velocità è espresso in unità di (0,25 ms) / (10 ms).
Una velocità di 0 (valore di default) rende la velocità illimitata, in modo che l'impostazione della destinazione influenzerà immediatamente la posizione. Si noti che la velocità reale alla quale si muove il servo è limitata dalle caratteristiche del servo stesso, la tensione di alimentazione e carichi meccanici.

Protocollo: 0xAA, numero de dispositivo, 0x09, numero servo, accelerazione bit bassi, accelerazione bit alti.

Questo comando imposta l'accelerazione del servomotore
Il limite di accelerazione è un valore compreso tra 0 a 255 in unità di (0,25 ms) / (10 ms) / (80 ms).
Il valore 0 corrisponde a nessun limite di accelerazione. Il limite di accelerazione determina la velocità che impiega il servo ad arrivare alla velocità massima, poi il tempo impiegato in decelerazione, questo provoca un movimento relativamente fluido da un punto ad un altro.
Con l'impostazione di minima accelerazione 1, l'uscita del servo impiega circa 3 secondi per passare agevolmente da un valore di 1 ms ad un valore di 2 ms.

Protocollo: 0xAA, numero di dispositivo, 0x10, numero del canale.

Questo comando consente al dispositivo di comunicare con la scheda di controllo per ottenere il valore di posizione di un servo. La posizione è inviata come risposta a due byte immediatamente dopo che il comando viene ricevuto. Il valore rappresenta la larghezza d’ impulso che la scheda sta trasmettendo al servo.

Protocollo: 0xAA, numero di dispositivo, 0x13
Risposta: 0x00 se i servo non si muovono, 0x01 se i servo si stanno muovendo.

Questo comando è utilizzato per determinare se le uscite dei servo hanno raggiunto la loro posizione o stanno ancora ruotando. Il valore sarà 1 purché vi sia almeno un servo che sia ancora in movimento. L'utilizzo di questo comando è necessario per avviare diversi movimenti servo e attendere che tutti i movimenti per finire prima di passare alla fase successiva del programma.

Protocollo: 0xAA, numero di dispositivo, 0x21
Risposta: bit di errore 0-7, errore di bit 8-15

Si può utilizzare questo comando per esaminare gli errori che la scheda controllo ha rilevato. Sul manuale, alla Sezione 4.b sono elencati gli errori specifici che possono essere rilevati dal Maestro. Il registro di errore viene inviato come risposta a due byte immediatamente dopo che il comando è stato ricevuto, allora tutti i bit di errore vengono cancellati.

Protocollo: 0xAA, numero di dispositivo, 0x22

Questo comando invia a tutti i servi la loro posizioni iniziale, proprio come se si fosse verificato un errore. Per i servi e le uscite impostate su "Ignora", la posizione sarà invariata.

Come abbiamo visto, i comandi per la gestione dei servo sono molti, realizzare un programma di gestione da utilizzare con la scheda Arduino potrebbe essere complesso. Per questo motivo è molto più comodo utilizzare un’apposita libreria che si occupi di inviare i giusti comandi. Ricercando in rete si è trovata una libreria già pronta, questa denominata PMCtrl realizzata da Graham Sortino. Per utilizzare la libreria sarà sufficiente accedere alla pagina e scaricare l’ultima versione della libreria, questa dovrà essere salvata all’interno della cartella Library dell’IDE di Arduino.

Per utilizzarla, occorre prima di tutto includerla nel programma con il comando.

#include <PMCtrl.h>

Quindi occorre definire il nome con cui si chiamerà il modulo, a quali pin sarà connesso per il dialogo seriale e a quale velocità si utilizzerà per la comunicazione, il comando da utilizzare è

PMCtrl servoCtrl (11, 3, 9600); //RX, TX, Baud

Comandi disponibili nella libreria.

A questo punto si potranno utilizzare i vari comandi disponibili nella libreria, questi sono:

servoCtrl.setServoSpeed (servoSpeed, channel, 12)
Il comando imposta la velocità servoSpeed con cui il servo si muove, channel è il servo che di cui vogliamo variare la velocità e deviceID per il Micro Maestro è il numero 12.

servoCtrl.setTarget (pos, channel, 12);
Il comando imposta la posizione pos che vogliamo far assumere al servo, channel è il servo che di cui vogliamo variare la posizione e deviceID è sempre il numero 12.

servoCtrl.goHome(12)
Il comando sposta tutti i servi collegati alla loro posizione di riposo.

servoCtrl.getPosition(canne,12)
Il comando restituisce la posizione attuale di un servo.

getErrors (channel, 12)
Il comando restituisce le informazioni riguardanti lo stato di errore del servo connesso a canne, per i codici vedere la relativa pagina.

• Scheda Arduino Esplora
• Scheda Micro Maestro;
• Due servomotori per esempio connessi ad un semplice dispositivo pan & Tilt
• Cavo di collegamento seriale tra scheda Arduino Esplora e Micro Maestro
• Fonte di alimentazione per i servomotori, per esempio porta batterie e 3 batterie tipo AA 1,5V

Per realizzare il cavo di collegamento tra scheda Arduino Esplora e Micro Maestro sono necessari:
- n° 2 connettori a tre pin femmina passo 2,54 mm tipo Molex 22-1-3037 (codice RS 679-5375P).
- N° 1 connettore pin strip femmina 1X4 passo 2.5 mm
- n° 4 spezzoni di cavi lunghezza a piacere
Nella figura è riportato come devono essere collegati i 4 cavi che sono Positivo e Negativo, alimentazione, TX e RX.

Per il test si è utilizzato un piccolo dispositivo Pan & Tilt, 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 ROB-09065.

Per le istruzioni di montaggio si può fare riferimento alla seguente pagina.

Il programma di test che è presente nell’allegato è molto semplice, è utilizzato il Joystick presente sulla scheda Arduino esplora per comandare un dispositivo pan & Tilt dotato di due servomotori. Il programma utilizza le seguenti librerie:

Gestione della Micro Maestro tramite libreria realizzata da gNSortino@yahoo.com

Il programma è sufficientemente commentato e non dovrebbe presentare problemi di comprensione.
Per quanto riguarda il comando map, questo è utilizzato per adattare i valori letti dal Joystick ai valori e nei limiti necessari alla gestione dei servomotori, si potrà far riferimento alla guida presente sul sito Arduino (https://arduino.cc/en/reference/map)

/*####################################################################
 FILE: Arduino_esplora_servo.ino
 VERSION: 1.0
 Descrizione: Programma di esempio per la gestione di servomotori
 tramite la scheda Arduino Esplora e la scheda Micro Mestro prodotta
 dalla Pololu
 
 Scheda Arduino Esplora: https://arduino.cc/en/Main/arduinoBoardEsplora
 Micro Maesto Pololu: http://www.pololu.com/product/1350
 
 Gestione Arduino Esplora
 #include <Esplora.h>: https://arduino.cc/en/Reference/EsploraLibrary
 
 Gestione della Micro Maestro tramite libreria realizzata da gNSortino@yahoo.com
 # include <PMCtrl.h>  https://github.com/gNSortin
 #include <SoftwareSerial.h>  https://arduino.cc/en/Reference/SoftwareSerial
 
 
 Ultima modifica il 26/12/2014
 Applicazione realizzata da Adriano Gandolfo
 Sito https://www.adrirobot.it 
 Blog http://it.emcelettronica.com/author/adrirobot/
 
 This example code is in the public domain.
 #################################################################### */

//Gestione Arduino Esplora 
#include <Esplora.h>: 
//Gestione Micro Mestro
#include <PMCtrl.h>
#include <SoftwareSerial.h>
//Definizione pin gestione Micro Maestro
#define rxPin 11
#define txPin 3
//Impostazione Parametri di collegamento con Micro Mestro
PMCtrl servoCtrl (rxPin, txPin, 9600); //RX, TX, Baud

//Definizione delle varibili utilizzate
//Assegnazione canali servomotori
const int servo0 = 0;
const int servo1 = 1;
//Definizione delle posizioni minime e massime
// per i due assi
const int MAX_W = 2224;
const int MIN_W = 598;
const int MAX_H = 1808;
const int MIN_H = 495;
//Definizione delle variabili della posizione
//assunta dal Joystick
int xPos = 0; 
int yPos = 0;

void setup ()
{
  //Imposta la velocità dei due servomotori
  servoCtrl.setServoSpeed (100, servo0, 12);
  servoCtrl.setServoSpeed (100, servo1, 12);
  //Sposta i servomotori nella posizione di riposo
  servoCtrl.goHome(12);  
}

void loop ()
{
  //Assegna a XValue e YValue i valori letti dal Joystick
  int xValue = Esplora.readJoystickX();
  int yValue = Esplora.readJoystickY();
  //Utilizzo del comando map https://arduino.cc/en/reference/map
  //per adattare i valori letti nel range dei servomotori
  xPos = map( xValue, 512, -512, MIN_W,MAX_W);
  yPos = map( yValue, 512, -512, MIN_H,MAX_H);
  //Invia alla scheda MicroMestro le posizioni dei due servomotori
  servoCtrl.setTarget (xPos, servo0, 12);
  servoCtrl.setTarget (yPos, servo1, 12);
  delay (50); //Pausa tra gli aggiornamenti dei valori letti
}

Elenco revisioni
01/02/2015	Emissione preliminare