Università degli Studi di Cagliari
Ing. Elettronica
Robotica Industriale
Tesina sperimentale di laboratorio
Robot “Geeno”
Angelo Mocci,
matr 37052
Bruno Pinna
matr 37083
•
•
INDICE
Scopo del Progetto
pag 3
Materiale utilizzato
pag 3
Montaggio e prove
pag 4
Struttura logica e di controllo
pag 5
Alimentazione,
pag 6
Sviluppo del Software
pag 8
Funzioni Matlab
pag 9
Cinematica Diretta
pag 10
Cinematica Inversa
pag 11
Programmazione del processore Basic Atom pro 28
pag 14
Alcune fotografie su strada
pag 22
Conclusioni
pag
•
Scopo del Progetto
Il progetto consiste nel realizzare un braccio robotico che abbia la possibilità di muoversi
attraverso il controllo di una struttura cingolata, raccogliere un oggetto e portarlo a
destinazione. Il controllo avviene a ciclo aperto, ma data l'adattabilità dell'elettronica
utilizzata, il sistema è altamente ampliabile con sensoristica di varia natura.
•
Materiale utilizzato:
•
•
Lynx 5 Arm Kit
4 Standard Size Servo HS-422
•
Lynx A Gripper Kit
•
Micro Size Servo HS-81
•
Base Rotate Kit BR-NS
•
•
Standard Size Servo HS-422
Tri-Track Chassis Kit (no electronics)
•
•
2 Geared Motor 12V
2 Condensatori per filtrare le oscillazioni
•
SSC-32 Servo Controller
•
Sabertooth 2x5
•
•
Bot Board II
•
Basic Atom Pro 28
•
Morsettiera da 12
2 Batterie Lynxmotion NiMh 7.2V 2800mA
•
•
•
Pila 9V
Convertitore USB-Seriale
Cavo Seriale (per supplire alla poca affidabilità dovuta alla conversione usb-seriale)
•
Generatori di tensione da 18V e 9V per i test
•
•
•
•
Saldatore
Multimetro
Cavetteria varia
Viti e bulloneria di fissaggio
Montaggio e prove
Seguendo le istruzioni dal sito della LynxMotion ( http://www.lynxmotion.com ) si monta il
Lynx 5 Arm Kit, successivamente la mano con la pinza ( Lynx A Gripper Kit ).
In seguito anche la base rotante ( Base Rotate Kit BR-NS ) il tutto su il chassis con i cingoli (
Tri-Track Chassis Kit).
Gripper
Mano
Avambraccio
Spalla
Base
Per minimizzare le oscillazioni dei due motori in DC si può saldare sui motori un condensatore
(fornito nel kit di assemblaggio del tri-track)
Inizialmente si è proceduto all'azzeramento delle posizioni dei servo-motori, manipolando
l'offset meccanico di montaggio dei servo mottori sulle strutture statiche del braccio, in modo
da poter avere una posizione ad attuatori centrati, corrispondente al braccio disteso
frontalmente a gripper aperto.
Logica di Controllo
La struttura logica di controllo e generazione è costituita dall'inter-connessione di 3 schede:
•
Bot-Board II, ha il compito di alloggiare il microcontrollore, nel nostro caso il Basic Atom
Pro 28, può fungere anche da attuatore dei servomotori ma non nel nostro caso
•
SSC32, scheda per il controllo Live dei servo-motori, possiede un set di istruzioni embedded
ampiamente documentato nel materiale fornito dalla Lynxmotion. Nel nostro progetto funge
da attuatore, in configurazione Master-Slave con la scheda Bot-Board II, il processore Atom
assume il ruolo di Master nella comunicazione con l'SSC32 la quale assume il ruolo di slave.
Al fine dell'attuazione della programmazione la comunicazione è stata scelta come unilaterale
Master (BB2) → Slave (SSC32).
•
Sabertooth 2x5, Driver di potenza, collegando gli ingressi S0 e S1 alle uscite per
Servomotori della SSC32, la scheda, impostata attraverso il banco Jumper per la
comunicazione remota ad impulsi, come descritto nella documentazione fornita, la scheda
esegue la traduzione del segnale impulsivo in segnale continuo adatto a controllare i motori
DC.
Alimentazione
L'alimentazione nominale è così descritta:
- Logica, 9V da batteria a transistor
- Servo, 7,2V nominali da singolo pacco batterie ( con controllo on-off tramite switch
verticale)
- Motori DC, 16,2V da doppio pacco batterie serie (con controllo on-off tramite switch
orrizzontale)
Le interconnessioni, al fine di agevolare l'intervento sulla circuiteria sono state realizzate
attraverso una morsettiera posta sul retro del rover in posizione verticale, mentre i pacchi
batteria possono essere sganciati attraverso delle connessioni faston ad aggancio rapido.
La comunicazione con la logica avviene completamente attraverso il protocollo seriale RS232, è
anche possibile utilizzare adattatori del tipo USB-RS232.
N.B questo approccio è sconsigliato a causa della bassa compatibilità di molti adattatori con la
scheda BBII, se si decide di utilizzare quest'ultimo approccio è necessario che il cavo utilizzi
una conversione basata su chipset FDTI.
Il Driver di potenza ha lo scopo di gestire la generazione del segnale di potenza a tensione
variabile al fine di poter controllare il movimento orario-antiorario dei motori. Questi,
utilizzando una corretta impostazione del banco jumper presente sulla scheda Sabertooth,
utilizzando le modalità descritte nella quick start guide della stessa, possono essere controllati
come se si trattasse di veri e propri motori passo passo. Il range di funzionamento tuttavia non
è il medesimo poiché il controllo è interpretato e non diretto.
Il periodo dell'onda quadra del treno di impulsi và da 1,0ms a 2,0ms, al valore 1000 vi è
l'inversione di marcia (indietro tutta) per valori crescenti si passerà a velocità sempre
minori, fino a 1,5ms ossia valore 1500 per il quale avviene la fermata totale del motore. Per
valori crescenti vi è l'accelerazione del motore fino a 2,0ms(2000) che corrisponde alla
massima velocità raggiungibile (avanti tutta).
N.B. E' da notare che la potenza dei motori, i quali hanno tensione nominale di esercizio 12V, è
direttamente proporzionale alla tensione di alimentazione della scheda Sabertooth 2x5.
I motori DC funzionaranno fintanto che l'ingresso sarà compreso nel range 6-20V, a tal fine
per poter avere la massima coppia possibile si è optato per la coppia maggiore ottenibile senza
dover sacrificare l'autonomia del rover, realizzando attraverso la serie di 2 pacchi batterie da
7,2V nominali (alla massima carica pari a 8,2V) una tensione di alimentazione nominale del
driver di potenza di 16 V.
Inizialmente si era progettato un sistema a partitore di tensione tale da poter ottenere dall'unico
pacco-batterie da 16V sia la tensione di alimentazione dei motori DC sia la tensione di
alimentazione dei servomotori del braccio robotizzato (max 7V), tuttavia in fase di
simulazione si è osservato che allo scaricarsi del pacco batterie il sistema si sarebbe
destabilizato portando a pericolose oscillazioni di tensione che avrebbero potuto danneggiare
la struttura del braccio, soprattutto del servo motore del gripper che essendo un micro-servo
sarebbe incorso a danneggiamenti irreparabili.
Il sistema è stato quindi ri-progettato inserendo un 3° pacco batterie, anch'esso alloggiato
nell'intercapedine di chassis del rover.
Una volta attuate le interconnessioni delle strutture logiche, e delle strutture di potenza, si può
procedere allo sviluppo del controllo cinematico e dinamico del robot.
Sviluppo del Software
Dopo aver collegato tutti i servo alla SSC-32 si procede a fare dei test ON-LINE, collegando il
cavo seriale all'SSC32, utilizzando il programma fornito con il Lynx 5 Arm per testare il
funzionamento dei vari servomotori, nel contempo su MATLAB si scrive e ricava la
cinematica diretta ed inversa del braccio con la mano.
I servomotori rispondono ad una determinata stringa di impulsi:
#(num_pin)P(posizione)T(T tempo in millisecondi, S velocita)
per esempio: #1P550T1000 (fai muovere il servo collegato al pin 1 alla posizione 550 in 1
secondo).
La struttura sintattica del controllo Live dei servo motori è ampiamente descritta nella
documentazione relativa alla scheda SSC32.
Anche tramite MATLAB è possibile inviare queste stringhe. Si può realizzare un programma che
utilizzando la cinematica diretta e inversa ed il collegamento con il pc posizioni i servomotori
nella posizione desiderata dopo che MATLAB si è calcolato gli impulsi da mandare ai vari
servomotori.
La metodica di comunicazione di matlab è sviluppata attraverso la generazione di un oggetto
Seriale attraverso la seguente sintassi (iniz_com)
%inizializzazione delle porte come per il controllo del robot
S=serial('COM13', 'BaudRate', 38400,'Terminator','CR/LF');
fopen(S)
La porta seriale(S), viene avviata sulla porta COM13 ( questo valore và adattato in base alla porta
COM assegnata dal S.O.) alla velocità di 38.4K, con terminatore e metodo Carriage Return &
Line Feed, come descritto per i sistemi Windows.
Una volta avviata la porta comunicazione seriale è stato necessario sviluppare una funzione che
creasse la stringa di controllo dei servomotori in funzione dei valori voluti:
function robot(S,chan,var)
%robot(S,chan,var)
%esegue sull'oggetto serial S, il canale chan e la posizione var l'invio
%seriale
temp=sprintf('#%dP%dS500',chan,var);
fprintf(S,temp);
nella variabile temp viene generata la stringa secondo la sintassi precedentemente descritta, e
attraverso il comando fprintf viene inviata la stringa attraverso la porta seriale.
Questo comando permette il controllo Live dei vari servo.
Un primo test consiste nel richiamare il comando robot_rip che invia in maniera sequenziale un
controllo a tutti i motori del braccio per poterne testare il corretto funzionamento
fprintf(S,'#1p550S100')
pause(0.5)
robot(S,3,1500)
pause(0.2)
robot(S,0,1500)
pause(0.5)
robot(S,2,1500)
pause(0.5)
robot(S,3,1500)
pause(0.5)
robot(S,4,1400)
pause(0.5)
N.B. Il controllo Live, può avvenire unicamente collegando la porta seriale alla scheda ssc32 e
sostituendo il cavo di interconnessione della Bot Board 2 alla SSC32 con i jumper sulla scheda
SSC32 secondo le modalità descritte nel manuale di riferimento della scheda SSC32
Se vi è riscontro con le posizioni descritte, è possibile passare alla descrizione della dinamica.
La cinematica Diretta è stata sviluppata secondo le modalità di Denavit-Hartenberg:
function [pos]=direct_kin(t1,t2,t3,t4)
%matrice di calcolo della cinematica diretta
d1=8;
a1=15.89;
a2=10;
a3=10;
a4=12;
c1=cos(t1);
c2=cos(t2);
c3=cos(t3);
c4=cos(t4);
s1=sin(t1);
s2=sin(t2);
s3=sin(t3);
s4=sin(t4);
px=-a4*s4*(c1*c2*s3+c1*c3*s2)+a4*c4*(c1*c2*c3-c1*s2*s3)+a3*c1*c2*c3-a3*c1*s2*s3+a2*c1*c2;
py=-a4*s2*(c2*s1*s3+c3*s1*s2)+a4*c4*(c2*c3*s1-s1*s2*s3)+a3*c2*c3*s1-a3*s1*s2*s3+a2*c2*s1;
pz=a4*c4*(c2*s3+c3*s3)+a4*s4(c2*c3-s2*s3)+a3*c2*s3+a3*c3*s2+a2*s2+d1;
pos=[px,py,pz];
L'inversione di questa matrice ci permette di determinare gli angoli di giunto fornendo le variabili
spaziali di posizione, poiché occorre determinare 5 variabili di giunto date 3 variabilidi
posizione, il problema non è ovvio poiché si presentano 4 combinazioni possibili per la stessa
posizione, si è scelto quindi di imporre che la posizione della mano sia sempre parallela al
suolo, per facilitare la funzione del gripper e semplificare il problema di inversione cinematica.
Il calcolo della cinematica inversa è affidato a MATLAB utilizzando la funzione
ikine2(x,y,z,ang)
%% ikine2(x,y,z,ang)
%%La funzione ha il compito di svolgere i calcoli e la conversione atti a
%%generare gli angoli della cinematica inversa ed effettuare la conversione
%%degli angoli in impulsi tali da poter controllare i servomotori.
% x= distanza laterale del gripper, con riferimento al centro della base
% rotante e asse positivo rivolto alla sx del rover
% y= distanza frontale del gripper, con riferimento al centro della base
% rotante ed asse positivo rivolto frontalmente al rover
%
% z= quota della mano rispetto al piano sfalsato rispetto al suolo
function usc=ikine2(x,y,z,ang)
h=12;
a1=10;
a2=a1;
a3=12;
px=sqrt(x^2+y^2);
if ang<-10 %se la mano ha angolazione minore di 0 (gripper puntato verso il suolo, viene
compensata la lunghezza della mano per evitare che questa urti
py=z+12;
else py=z-10;
end
%calcolo della cinematica
c2=(px^2+py^2-a1^2-a2^2)/(2*a1*a2); %calcolo della cinematica
s2=-sqrt(1-c2^2);
t2=atan2(s2,c2)*180/pi;
s1=((a1+a2*c2)*py-a2*s2*px)/(px^2+py^2);
c1=((a1+a2*c2)*px+a2*s2*py)/(px^2+py^2);
t1=atan2(s1,c1)*180/pi;
t3=ang-t1-t2;
t0=atan2(y,x)*180/pi;
%t0 angolo giunto base rotante
%t1 angolo giunto di spalla
%t2 angolo giunto di braccio
%t3 angolo giunto di polso
% vettore contenente gli angoli
display('Angoli dei giunti')
angles=[t0 t1 t2 t3]
%%esecuzione della conversione in impulsi nel range 500-2500 per associare i
%%180° possibili attuabili dai servo
t0_i=(2000/180)*t0+500%%esegue la conversione degli angoli in impulsi
e1=(t1)/10;
t1=t1-e1;
t1_i=((2000/180)*t1)+500;
t2_n=(-t2)+39;
e2=t2_n/10;
t2_n=t2_n-e2;
t2_i=((2000/180)*t2_n)+500;
e3=t3/10;
t3=t3-e3;
t3_i=((2000/180)*(t3+100))+500;
%i cicli if limitano gli errori dovuti a posizionamenti scorretti,
%limitando i valori impulsivi di uscita nel range 550-2500
if t0_i<550
t0_i=550;
end
if t0_i>2500
t0_i=2500
end
if t1_i<550
t1_i=550;
end
if t1_i>2500
t1_i=2500
end
if t2_i<550
t2_i=550;
end
if t2_i>2500
t2_i=2500
end
if t3_i<550
t3_i=550;
end
if t3_i>2500
t3_i=2500
end
usc=[t0_i,t1_i,t2_i,t3_i] %valori impulsivi dei servomotori
Ottenuti i valori impulsivi delle variabili di giunto è stato possibile procedere alla programmazione
del microcontrollore basic atom pro 28, questi possiede un ambiente di sviluppo e
compilazione integrato, ed un proprio linguaggio alquanto similare alla programmazione
in C.
Abbiamo utilizzato un microprocessore Basic Atom Pro 28:
•
32K of Program Space
•
•
•
•
•
•
•
•
32K of EEPROM Storage
2000 Bytes (2K) of User / System RAM
Up to 8 A/D pins
100,000 Plus Instructions Per Second
Code and Pin compatible to the BasicATOM
Hardware-based 32 bit math
More built-in hardware than the BasicATOM
Based on the Hitachi 3664
Una volta inserito il microprocessore nell'alloggio da 28 pin previsto sulla scheda Bot Board 2
(facendo partticolare attenzione alla posizione in cui và inserito, si può notare che vi è mezzo
cerchio sul bordo del Atom, che dovrà corrispondere al taglietto frontale del socket.
L'ambiente di sviluppo è molto semplificato, seguendo le procedure illustrate nela quick start
guide dell'atom è possibile giungere agevolmente ad una corretta programmazione.
Utilizzando la cinematica inversa per calcolare la posizione del gripper rispetto alla terna di
riferimento posta al centro della base rotante, e inserendo l'angolo del gripper rispetto al suolo è
stato possibile ottenere una serie di stringhe da poter utilizzare in fase di programmazione.
Tutti i segnali dei servo-motori vengono generati dal processore Atom, che svlge il ruolo di
controllore, la scheda Bot-Board II, utilizzando la corretta sintassi, invia le stringhe contenute
nella programmazione attraverso il canale 8, che nel nostro caso è connesso direttamente al pin
Rx della scheda SSC32 che riceve il segnale e si occupa di decodificare la stringa ricevuta per
poter “attuare” la posizione richiesta nel tempo e velocità richiesti, sul canale desiderato.
Programmazione del processore Atom 28
Il codice della programazione del microcontrollore è quanto segue:
' Tesina di robotica industriale di Angelo Mocci e Bruno Pinna, Codice di controllo del
microcontrollore Atom 28 su Bot Board 2 +SSC32
servo0pwa var word 'Servomotore della base
servo0pwb var word 'Servomotore del braccio
servo0pwc var word 'Servomotore dell avanbraccio
servo0pwd var word 'Servomotore della mano
servo0pwe var word 'Servomotore della pinza
servo0pwf var word 'Cingolo di sinistra
servo0pwg var word 'Cingolo di destra
movetime var word 'Variabile per il tempo degli impulsi per i motori
nn var byte
ledA var bit
ledB var bit
ledC var bit
butA var bit
butB var bit
butC var bit
prev_butA var bit
prev_butB var bit
prev_butC var bit
temp
var
word
BUTTON_DOWN con 0
BUTTON_UP
con 1
ledA = 0
ledB = 0
ledC = 0
butA = 0
butB = 0
butC = 0
nn = 0
'impostazione della posizione iniziale
servo0pwa = 1500 'Base estremi: 550-2500 (550 a sinistra -> 2500 a destra)
servo0pwb = 1400 'Braccio estremi: 550-1400 (550 dritto -> 1400 verso il basso)
servo0pwc = 890 'Avanbraccio estremi: 550-2500 (550 tutto indietro -> 2500 tutto avanti)
servo0pwd = 1611 'Mano estremi: 550-2500 (2500 tutto indietro -> 550 tutto avanti)
servo0pwe = 1400 'Pinza estremi: 740-1400 (740 chiusa -> 1400 aperta)
servo0pwf = 1500 'Motore destro 1000 tutta retro, 1500 stop, 2000 avanti tutta
servo0pwg = 1500 'Motore destro 1000 tutta retro, 1500 stop, 2000 avanti tutta
start:
'posizione iniziale
movetime=1000
serout p8,i38400,["#0P",DEC servo0pwa,"S",DEC 100,13] 'Posizionamento base
serout p8,i38400,["#1P",DEC servo0pwb,"S",DEC 200,13] 'Posizionamento braccio
serout p8,i38400,["#2P",DEC servo0pwc,"S",DEC 400,13] 'Posizionamento avanbraccio
serout p8,i38400,["#3P",DEC servo0pwd,"S",DEC 300,13] 'Posizionamento mano
serout p8,i38400,["#4P",DEC servo0pwe,"S",DEC 80,13] 'Apertura/chiusura pinza
if (butA = BUTTON_DOWN) AND (prev_butA = BUTTON_UP) then 'programma A
sound P9,[100\2000]
'prende l'oggetto davanti a se
servo0pwa = 1500
servo0pwb = 550
servo0pwc = 1550
servo0pwd = 2204
servo0pwe = 900
servo0pwf = 1500
servo0pwg = 1500
serout p8,i38400,["#0P",DEC servo0pwa,"S",DEC 100,13]
serout p8,i38400,["#1P",DEC servo0pwb,"S",DEC 200,13]
serout p8,i38400,["#2P",DEC servo0pwc,"S",DEC 400,13]
serout p8,i38400,["#3P",DEC servo0pwd,"S",DEC 300,13]
serout p8,i38400,["#4P",DEC servo0pwe,"S",DEC 80,13]
sound P9,[1000\500]
pause 10000
'posizione per il trasporto
servo0pwa = 1500
servo0pwb = 934
servo0pwc = 890
servo0pwd = 550
servo0pwe = 900
serout p8,i38400,["#0P",DEC servo0pwa,"S",DEC 100,13]
serout p8,i38400,["#1P",DEC servo0pwb,"S",DEC 200,13]
serout p8,i38400,["#2P",DEC servo0pwc,"S",DEC 300,13]
serout p8,i38400,["#3P",DEC servo0pwd,"S",DEC 200,13]
serout p8,i38400,["#4P",DEC servo0pwe,"S",DEC 100,13]
pause 10000
pause 760
' avanti tutta per 3 secondi
servo0pwf = 2000
servo0pwg = 2000
serout p8,i38400,["#10P",DEC servo0pwf,"S",DEC movetime,13]
serout p8,i38400,["#11P",DEC servo0pwg,"S",DEC movetime,13]
pause 3000 'rotazione oraria
servo0pwf = 1000
servo0pwg = 2000
serout p8,i38400,["#10P",DEC servo0pwf,"S",DEC movetime,13]
serout p8,i38400,["#11P",DEC servo0pwg,"S",DEC movetime,13]
pause 1700 'avanti tutta per 2 secondi
servo0pwf = 2000
servo0pwg = 2000
serout p8,i38400,["#10P",DEC servo0pwf,"S",DEC movetime,13]
serout p8,i38400,["#11P",DEC servo0pwg,"S",DEC movetime,13]
pause 2000 'ferma i motori
servo0pwf = 1500
servo0pwg = 1500
serout p8,i38400,["#10P",DEC servo0pwf,"S",DEC movetime,13]
serout p8,i38400,["#11P",DEC servo0pwg,"S",DEC movetime,13]
sound P9,[1000\10000,500\6000,500\7000]
pause 500
servo0pwe = 1300 'apertura mano
serout p8,i38400,["#4P",DEC servo0pwe,"S",DEC 100,13]
endif
if (butB = BUTTON_DOWN) AND (prev_butB = BUTTON_UP) then 'programma B
'presa avanti a se
sound P9,[100\2000]
servo0pwa = 1500
servo0pwb = 550
servo0pwc = 1550
servo0pwd = 2204
servo0pwe = 900
servo0pwf = 1500
servo0pwg = 1500
serout p8,i38400,["#0P",DEC servo0pwa,"S",DEC 100,13]
serout p8,i38400,["#1P",DEC servo0pwb,"S",DEC 200,13]
serout p8,i38400,["#2P",DEC servo0pwc,"S",DEC 400,13]
serout p8,i38400,["#3P",DEC servo0pwd,"S",DEC 300,13]
serout p8,i38400,["#4P",DEC servo0pwe,"S",DEC 80,13]
sound P9,[1000\500]
pause 10000
'posizione per evitare che il braccio sbatta sui cingoli
servo0pwa = 1500
servo0pwb = 934
servo0pwc = 890
servo0pwd = 550
servo0pwe = 900
serout p8,i38400,["#0P",DEC servo0pwa,"S",DEC 100,13]
serout p8,i38400,["#1P",DEC servo0pwb,"S",DEC 200,13]
serout p8,i38400,["#2P",DEC servo0pwc,"S",DEC 300,13]
serout p8,i38400,["#3P",DEC servo0pwd,"S",DEC 200,13]
serout p8,i38400,["#4P",DEC servo0pwe,"S",DEC 100,13]
pause 10000
'posizione per il rilascio
servo0pwa = 2500
servo0pwb = 1080
servo0pwc = 1612
servo0pwd = 1754
serout p8,i38400,["#0P",DEC servo0pwa,"S",DEC 100,13]
serout p8,i38400,["#1P",DEC servo0pwb,"S",DEC 200,13]
serout p8,i38400,["#2P",DEC servo0pwc,"S",DEC 300,13]
serout p8,i38400,["#3P",DEC servo0pwd,"S",DEC 200,13]
serout p8,i38400,["#4P",DEC servo0pwe,"S",DEC 100,13]
pause 11000
servo0pwe = 1300 ' apertura pinza
serout p8,i38400,["#4P",DEC servo0pwe,"S",DEC 100,13]
endif
' da qui in giu è un controllo per i tasti premuti
ledA = nn.BIT0
ledB = nn.BIT1
ledC = nn.BIT2
if ( nn.BIT0 = 1 ) then
high p0
high p8
high p4
else
low p0
low p8
low p4
endif
if ( nn.BIT1 = 1 ) then
high p1
high p5
else
low p1
low p5
endif
if ( nn.BIT2 = 1 ) then
high p2
high p10
high p6
else
low p2
low p10
low p6
endif
if ( nn.BIT3 = 1 ) then
high p3
high p7
high p11
else
low p3
low p7
low p11
endif
pause 50
prev_butA = butA
prev_butB = butB
prev_butC = butC
gosub button_led_control
goto start
'Subroutine che legge e controlla i valori dei LED
'I pulsanti sono le variabili butA, butB e butC, gli stati dei led
'vengono letti dalle variabili ledA, ledB, ledC.
button_led_control:
'Lettura dei valori e spegnimento dei led
input p12
input p13
input p14
butA = IN12
butB = IN13
butC = IN14
'Accensione dei led
if ledA = 1 then
low p12
endif
if ledB = 1 then
low p13
endif
if ledC = 1 then
low p14
endif
return
Alcune fotografie su strada
Conclusioni
L'attività di sperimentazione robotica che ha portato alla
costruzione, sviluppo e programmazione di questo sistema
robotizzato, prodotto dalla Lynxmotion (www.lynxmotion.com)
è stata un'attività lunga, che ha dato non pochi problemi, sia dal
punto di vista della compatibilità nei sistemi di comunicazione
seriale, sia in fase di progettazione dei movimenti. Riteniamo
comunque positiva tutta l'attività che ci ha permesso di
sperimentare sul campo quanto si è appreso nelle lezioni
teoriche e al calcolatore di Robotica Industriale.
Tutte le attività sono state svolte presso i laboratori di Automatica negli edifici del Dipartimento di
Ingegneria Elettrica ed Elettronica, pertanto ci sembra doveroso ringraziare tutti coloro che per
necessità sicuramente più importanti delle nostre, si trovavano lì ed hanno sopportato il
baylamme che spesso si creava nella nostra postazione di lavoro.
La struttura di Geeno permette a chiunque sia sufficientemente volenteroso di implementare passi
successivi della programmazione robotica, quali la sensoristica, la richiusura di loop di
controllo per una migliore gestione del sistema, la ricalibrazione elettronica al fine di
stabilizzare le oscillazioni dei servomotori, il controllo in tempo reale via Controller PS2/PC e
in remoto tramite sistemi radio WIFI o FM. Le Possibilità, come spesso accade, sono illimitate.