RobotZero
Dopo aver realizzato la 628Board ho pensato che il modo migliore per testarla sarebbe stato realizzare un semplice Robot. Quindi mi sono guardato un po’ intorno, recuperando materiale qua e la ho realizzato “RobotZero”, questo nome mi è venuto in mente proprio ora che sto scrivendo, visto che non è proprio un primo robot, ma una vera e propria base di partenza sulla quale fare esperimenti di ogni genere, infatti la prossima cosa che farò e montare un telemetro a infrarossi, per studiarne il funzionamento.
Ma torniamo a noi eccovi una foto completa dell’accrocco.
Come si può vedere il termine “accrocco” non è sbagliato, ma come dicevo prima serve per studiare. Il circuito è composto da una 628Board, “cervello” del sistema, da un ponte H realizzato con L293D per pilotare i motori e due baffi, che altro non sono che semplici interruttori per evitare gli ostacoli.
Il circuito è alimentato da 4 batterie stilo, quelle che ho usato io sono batterie ricaricabili da 1,2V, per un totale di 4,8V questo mi da la possibilità di alimentare direttamente tutta l’elettronica senza la necessità di montare uno stabilizzatore.
Spesso il problema principale per realizzare un robot sta nella realizzazione della meccanica, io in questo caso ho usato qualcosa di già pronto, la base del primo robot della De Agostini, comunque in caso avete difficolta ora se ne trovano anche in commercio. La base che ho utilizzato monta 2 motori con relativa riduzione e un ruotino piroettante d’appoggio. Ho sfruttato la grande base per montarci il porta pile e una breadboard per realizzare il circuito del ponte H e la 628Board, ma se avete una base più piccola potete pensare sempre ad un montaggio a strati. I baffi sono degli switch di contatto ai quali ho fissato con dei faston del comune filo di ferro come si può vedere nella foto, il funzionamento dei baffi è quello di un comune interrutore, il PIC ne controlla lo stato per capire se è a contatto con un ostacolo o no.
I motori sono pilotati con un segnale PWM, questo permette di realizzare una semplice accelerazione, e non richiedere troppa corrente alle batterie alla partenza. La soluzione migliore sarebbe stata avere 2 PWM, ma il PIC 16F628 ne ha soltanto uno. Se desiderate approfondire il discorso sul PWM, vi consiglio di leggere il tutorial di Giovanni Giannetti al seguente link: http://www.tmasi.com/robotica/pwmtut/PWMTut_H.htm.
Lo schema seguente è quello relativo al circuito, riporta le indicazioni dei collegamenti alla 628Board.
Esaminiamo ora il codice:
/*
** Programma utilizzato per eseguire i test con la base mobile del robot DeAgostini
** Utilizza la scheda 628Board, comanda i motori con un solo segnale PWM e 2 segnali per la direzione
** Gestione di 2 baffi
**
** Porte usate per default:
** PORTB bit 0 Baffo DX (IN)
** PORTB bit 3 Uscita PWM del PIC (OUT)
** PORTB bit 4-7 collegato ai pin LCD data bit 4-7 (OUT)
** PORTA bit 0 collegato al pin LCD RS (OUT)
** PORTA bit 1 collegato al pin LCD EN (OUT)
** PORTA bit 2 collegato al Direzione motore SX (OUT)
** PORTA bit 3 collegato al Direzione motore DX (OUT)
** PORTA bit 4 Baffo SX (IN)
**
*/
#include
#include "delay.c"
#include "DMLCD2R.h"
__CONFIG (0x3F61); // Configurazione del programmatore
static bit DIR_MOT_SX @ ((unsigned)&PORTA*8+2);
static bit DIR_MOT_DX @ ((unsigned)&PORTA*8+3);
static bit BAFFO_SX @ ((unsigned)&PORTA*8+4);
static bit BAFFO_DX @ ((unsigned)&PORTB*8+0);
void motori(unsigned char dir_mot_dx, unsigned char dir_mot_sx, unsigned char rit_acc)
{
unsigned char duty;
CCPR1L=0;
if(rit_acc>100) // Se il ritoardo è maggiore di 100 lo fisso a 100
rit_acc=100;
DIR_MOT_SX=dir_mot_sx; // Direzione Motore Sinistro
DIR_MOT_DX=dir_mot_dx; // Direzione Motore Destro
// Visualizza la direzione dei motori DIR_MOT_SX|NULL|DIR_MOT_DX
lcd_put_uchar(((dir_mot_sx * 100) + dir_mot_dx),1,4);
/* Questo ciclo for permette una accelerazione pseudo esponenziale il
valore iniziale del duty cycle è basato sui motori che ho utilizzato
potrebbe essere necessario cambiarlo */
for(duty=110;duty<255;duty++) { lcd_put_uchar(duty,1,0); CCPR1L=duty; if(rit_acc>1)
rit_acc--;
DelayMs(rit_acc);
}
}
/********************************************************************************/
void main(void)
{
CMCON=0x07; // Disabilita i comparatori sulla PORTA
PORTA=0x00; // Azzera PORTA
PORTB=0x00; // Azzera PORTB
TRISA=0b00010000;
TRISB=0b00000001;
lcd_init(); // INDISPENSABILE serve ad inizializzare l'LCD
lcd_clear(); // Cancella il display
/* Stampa sulla prima riga le etichette per il controllo
dello stato delle varie periferiche */
lcd_puts("PWM DMS SBD ???");
/***** Int PWM *****/
CCPR1L=0; // Valore PWM
PR2=0xFF;
T2CON=0x04;
CCP1CON=0x0C;
/***** END Init PWM *****/
motori(0,0,100);
for(;;) // Loop infinito
{
if(BAFFO_SX==0)
{
// Visualizza lo stato dei baffi BAFFO_SX|NULL|BAFFO_DX
lcd_put_uchar(100,1,8);
motori(1,1,100);
motori(1,0,60);
motori(0,0,70);
// Visualizza lo stato dei baffi BAFFO_SX|NULL|BAFFO_DX
lcd_put_uchar(0,1,8);
}
if(BAFFO_DX==0)
{
// Visualizza lo stato dei baffi BAFFO_SX|NULL|BAFFO_DX
lcd_put_uchar(1,1,8);
motori(1,1,100);
motori(0,1,60);
motori(0,0,70);
// Visualizza lo stato dei baffi BAFFO_SX|NULL|BAFFO_DX
lcd_put_uchar(0,1,8);
}
}
}
Analizziamo prima il codice della funzione main. Al solito per prima cosa vengono inizializzati i registri per il funzionamento delle porte, poi vengono richiamate le funzioni per inizializzare il display. La funzione “lcd_puts(“PWM DMS SBD ???”);” viene usata per stampare sulla prima riga del display delle etichette, di variabili che utilizzeremo per il debug del robot. I valori di tali vaiabili, vengono stampati sotto le etichette nella seconda righa, ad esempio l’etichetta PWM indica la variabile che contiene il valore del PWM generato dal PIC che varia da 0 a 255. Per scrivere questi valori sotto le etichette viene usata la funzione “lcd_put_uchar(valore,riga, colonna);”, dove valore è la variabile che si vuole visualizzare (di tipo unsigned char), riga è la riga del display su cui scrivere, e colonna è la colonna dove va posizionato il valore. Attenzione il valore viene sempre stampato con 3 caratteri a partire dalla posizione colonna, ad esempio se la variabile da visualizzare contiene zero il risultato sarà “000″.
Il passo successivo è l’inizializzazione del PIC per la generazione del segnale PWM, il primo registro da valorizzare è CCPR1L questo registro contiene gli 8 bit più significativi per la regolazione del duty-cycle, in questo esempio si useranno solo questi bit tralasciando i 2 meno significativi esclusivamente per semplicità di realizzazione. Per gli altri registri è possibile vedere in tutorial indicato in precedenza o il data sheet, per una spiegazione più dettagliata.
Vediamo ora la funzione motori(0,0,100); richiamata prima del loop infinito. Questa funzione molto grezza, serve semplicemente a generare una rampa di accelerazione per i motori, ed impostare la direzione in cui devono girare. I valori impostati del duty cycle iniziale nel ciclo for(vedi variabile “duty”) e il controllo iniziale sulla variabile “rit_acc”, sono definiti in base alla caratteristiche dei motori utilizzati, potrebbe essere necesario modificarli, se le caratteristiche dei motori che utilizzate sono diverse da quelle che ho usato io. Comunque controllando i dati visualizzati sul display, avanzando per tentativi si può trovare facilmente il valore più adatto.
Nel loop infito che chiude il programma, viene controllato continuamente lo stato dei baffi e nel caso in cui uno di questi risultasse premuto, il robot retrocede per un periodo di tempo indicato nella funzione motori, poi gira nella direzione opposta al baffo premuto e successivamente riprende ad andare avanti. Anche in questo caso le temporizzazioni potrebbero avere la necessità di essere modificati in base alle caratteristiche dei vostri motori.
A questo punto non vi resta che divertirvi a fare delle prove con il vostro nuovo robot.
English 
Italiano 
Loading ...