Show Posts
Pages: [1] 2 3 ... 7
1  International / Megatopic / Re: AutoBalance: Self–Balancing of a two–wheeled robot on: July 29, 2013, 11:48:30 am
...
In rete ci sono molti filmati che dimostrano quanto il segway può essere pericoloso se usato senza accendere il cervello smiley

E' una questione di riflessi condizionati smiley-razz ... il nostro sistema di equilibrio non e' abituato a bilanciare il peso "automaticamente" su un piano con un'asse di rotazione, ed ancora meno se il piano si muove ed al baricentro del corpo applichi un vettore (e' per quello che hanno un'impugnatura smiley-razz smiley-lol) ... te ne rendi conto in modo molto semplice cercando di stare in equilibrio a piedi affiancati su un'asse posta su un manico di scopa (senza avere nulla a cui aggrapparsi, ovviamente smiley-lol) ... pochissime persone ci riescono ai primi tentativi smiley-razz ... eppure, quando siamo fermi in piedi su una superficie ferma, i muscoli delle nostre gambe compiono continui assestamenti di posizione senza che nemmeno ce ne accorgiamo, se non ci facciamo caso intenzionalmente (perche' i nostri riflessi "automatici" reagiscono ai minimi sbilanciamenti in modo automatico, dopo anni di "esperienza" nel camminare e nel mantenere la posizione)

Per i robot, comunque, il senso della mia domanda e' diverso ...  l'avere il baricentro il piu basso possibile potrebbe essere molto vantaggioso, anche solo sull'asse di rotazione, se non al di sotto ... e' vero che il periodo di un pendolo dipende dalla sua lunghezza, principalmente, ma l'energia necessaria a contrastarne l'oscillazione (e quindi anche la velocita' ed efficenza di risposta) dipende dal peso e dalla leva ... in fatto di forza da applicare non e' la stessa cosa, per i motori, dover bilanciare, ad esempio, un pendolo di un metro che ha un peso di un chilo all'estremita', ed un pendolo di un metro che ha all'estremita' una cinquantina di grammi smiley-wink
Hai ragione, sicuramente il baricentro sotto l'asse delle ruote aiuterebbe molto... Ma a quel punto non starebbe in piedi anche da spento?  smiley-grin

A parte gli scherzi, mantenere il baricentro sotto o sull'asse delle ruote migliorerebbe di molto la situazione, ma non saprei come fare..
Si dovrebbe ripensare tutta la struttura con questo obiettivo  smiley-roll-sweat
2  International / Megatopic / Re: AutoBalance: Self–Balancing of a two–wheeled robot on: July 29, 2013, 04:24:49 am
Ai complimenti per il progetto, aggiungo una domanda.
Finora ho visto tutti progetti di questi oggetti autobilancianti che stanno ... fermi!  smiley-wink
C'è qualcuno (di voi) che ha realizzato anche un oggetto semovente che si autobilancia? E che ha messo in opensource il progetto?
Che io sappia no  smiley-fat
Quando avrò voglia/tempo ci vorrei provare...   smiley-lol

Comunque farlo muovere avanti e indietro non dovrebbe essere difficile, però c'è sempre da tener conto del tempo impiegato per effettuare un ciclo. (Se aumenta troppo il sistema non è abbastanza reattivo)
3  International / Megatopic / Re: AutoBalance: Self–Balancing of a two–wheeled robot on: July 28, 2013, 03:10:22 am
Mmh.. siamo sicuri che si possa approssimare ad un pendolo?

Non è una approssimazione, è un pendolo inverso a tutti gli effetti.

Quote
Comunque penso di aver capito, l'unico problema è che aumentando l'altezza del baricentro aumenta anche la coppia richiesta ai motori

SI, più alzi il baricentro diventa maggiore il braccio di leva e di conseguenza serva una maggiore coppia.
Capito, grazie della spiegazione  smiley-grin
4  International / Megatopic / Re: AutoBalance: Self–Balancing of a two–wheeled robot on: July 28, 2013, 03:00:54 am
Ovviamente i sensori più sono posti in alto meglio è, ma il baricentro deve rimanere in basso.
Sbaglio io?

Si perché il tempo di oscillazione di un pendolo dipende esclusivamente dalla lunghezza del braccio e più è in alto il baricentro e maggiore è il tempo di oscillazione, di conseguenza diventa più "facile" contrastare l'oscillazione, ovviamente c'è sempre da fare un compromesso tra stabilità e reattività, la prima richiede il baricentro alto, la seconda il baricentro basso.
Se possibile non è male posizionare il baricentro sotto l'asse di rotazione, in questo caso diventa un elemento che collabora alla stabilità perché contrasta l'oscillazione.
Mmh.. siamo sicuri che si possa approssimare ad un pendolo?

Comunque penso di aver capito, l'unico problema è che aumentando l'altezza del baricentro aumenta anche la coppia richiesta ai motori, e quelli che ho usato io cela fanno a malapena così  smiley-fat
5  International / Megatopic / Re: AutoBalance: Self–Balancing of a two–wheeled robot on: July 27, 2013, 03:19:53 pm
Aggiunto nel primo post un video dimostrativo del funzionamento dell' AutoBalance  smiley-grin

---

Una precisazione però, riguardo l'utilizzo del "tappetino" di cartoncino.
Il sistema funziona su tutte le superfici non riflettenti, ma la risposta dei sensori cambia leggermente in base al materiale del piano di riferimento.
Cambiando la risposta dei sensori, cambia anche il comportamento del sistema... (Ad esempio fra plastica e gomma, etc)

Quindi andrebbe regolato il controllo PID ogni volta che si cambia superficie di lavoro.
Per evitare questo ho regolato il PID su cartoncino, e mi porto appresso un "tappetino" di cartoncino  smiley-grin

Quote
Per complicarmi ulteriormente le cose, ho posizionato il baricentro a pochi cm sopra l'asse delle ruote, il che rende ancora piu' difficile gestire l'inclinazione del robot. Per via della regola del pendolo inverso, è piu semplice tenere in equilibrio un corpo con baricentro spostato verso l'alto, piuttosto che il contrario.
Stavo rileggendo la pagina di gioblu... questa frase non mi convince per nulla  smiley-roll
Ovviamente i sensori più sono posti in alto meglio è, ma il baricentro deve rimanere in basso.
Sbaglio io?
6  International / Megatopic / Re: AutoBalance - Self–Balancing of a two–wheeled robot on: July 27, 2013, 02:34:08 pm
Se vuoi risparmiare sui sensori di distanza, invece di usare gli sharp potresti usare delle coppie di led ir; gioblu ci aveva fatto svariati test:
http://www.gioblu.com/tutorials/robotica/295-robot-self-balancing-con-arduino-e-4-led

Stendiamo un velo pietoso su questa cosa, un led non è un fotoricettore, sopratutto non è un telemetro come il sensore Sharp che sfrutta un emittore IR molto ben collimato tramite lente, spot < 1cm, e un array lineare di fotoricettori tramite il quale fornisce l'errore di parallasse e da questo la reale distanza in modo abbastanza preciso.
Meno male che sono andato sul sicuro  smiley-grin
Molto bravo! mi piace smiley
Grazie!  smiley

--

A breve carico un video  smiley-wink
7  International / Megatopic / Re: AutoBalance - Self–Balancing of a two–wheeled robot on: July 26, 2013, 05:16:39 pm
Ciao,
molto ben documentato, spero di riuscire a leggerlo per bene.
Intanto mi è balzata agli occhi una inesattezza, se vuoi pure irrilevante: Eagle NON è opensource smiley

Se vuoi risparmiare sui sensori di distanza, invece di usare gli sharp potresti usare delle coppie di led ir; gioblu ci aveva fatto svariati test:
http://www.gioblu.com/tutorials/robotica/295-robot-self-balancing-con-arduino-e-4-led
Ci avevo pensato, e a dir la verità anche provato.. Con scarso successo  smiley-roll-sweat

Comunque penso sia più semplice acquisire una distanza dai sensori Sharp, e forse anche più affidabile..

Inoltre tramite i sensori si può utilizzare un amplificatore differenziale per effettuale la differenza fra le due distanze, ottenendo direttamente l'errore di inclinazione.
In questo modo tramite un trimmer ( Che và a variare un tensione Vshift) si possono "bilanciare" leggeri dislivelli del piano di riferimento, errori di bilanciamento del robot, o differenti guadagni dei sensori.

Cosa molto più difficile se la differenza viene effettuata direttamente da Arduino... ( sempre dopo aver adattato i due segnali agli ingressi di Arduino, questa volta andrebbero adattati con due amplificatori distinti però )

Non sono sicuro sia possibile farlo con il metodo di gioblu...


Tuttavia ammetto di aver usato i sensori Sharp per una maggiore semplicità  smiley-mr-green


Cavolo per quanto riguarda Eagle hai ragione... Vabbè ormai è andata   smiley-sweat
8  International / Megatopic / Re: AutoBalance - Self–Balancing of a two–wheeled robot on: July 26, 2013, 10:50:18 am
Bel progetto.
Complimenti.  smiley-wink
Grazie!  smiley-grin
9  International / Megatopic / AutoBalance: Self–Balancing of a two–wheeled robot on: July 26, 2013, 09:52:28 am
Salve a tutti  smiley-mr-green
Tempo fà avevo chiesto informazioni su questo forum riguardo sistemi di questo tipo, con la promessa di postare tutto il materiale relativo al progetto, una volta finito (e passato l'esame di stato  smiley-grin). Ora eccomi quì!  smiley

I documenti allegati a questo progetto sono molti: Datasheet, DI, Schemi elettrici, Liste parti, Disegni meccanici, Modelli 3D (Tramite SolidWorks), Piramide Prodotto, Relazione Progettuale, Software, Lista Connessioni, Descrizione Cavi, e non ricordo cos'altro..  smiley-yell

Riassumendo questo AutoBalance è composto dai seguenti componenti "fondamentali", disposti su tre piani in alluminio:
  • Arduino
  • Due sensori di prossimità Sharp
  • Un Driver Motore
  • Un Amplificatore differenziale
  • Due Motori DC
  • Due Ruote
  • Uno Switch

Una spiegazione esaustiva del funzionamento, e dei componenti utilizzati, è data in questa relazione progettuale:
https://docs.google.com/file/d/0B6XepKMbmngoNXc1YW9yNFdxWFE/edit?usp=sharing
(Scaricandolo la qualità migliora)

Mentre quì è disponibile l'intera cartella del progetto:
https://drive.google.com/folderview?id=0B6XepKMbmngoSlR6bXo2YmJoRW8&usp=sharing

Quì invece un video del funzionamento dell'AutoBalance smiley-grin
https://docs.google.com/file/d/0B6XepKMbmngocHdXNEZheTFRbGc/edit

Sono a vostra disposizione per qualsiasi dubbio o richiesta smiley-grin
10  Topics / Robotics / Re: AutoBalance - PID Controller on: April 13, 2013, 05:38:30 pm
Hi Mosc,

> Got it, I must set the PID so that it exceeds these values!

Good to hear that you solve the problem!
What did you change in the code? May I see your updated code? Thanks.
Yes, of course you can!

Unfortunately I have not had much time in this period..
However I have changed a lot the robot, now I'm writing the relationship for the exam.

There there are, the datasheets, the DI, the electrical schematics, the part lists, the 3D models (with solidworks, and 2D with autcad for the mechanic parts), the product pyramid, the relationship, the software, the technical specification, the wiring list and the description of the wires (only for completeness xD).
For now all in Italian... I will post all when i take the exam smiley

--

However, summarizing, the project has undergone considerable changes.

To adapt the output of the sensors to the ADC of arduino, and to make more dynamic the system, allowing it to move the zero point, now the difference between the two distances is performed by a differential amplifier, with Vshift adjusted with a trimmer.
Arduino gets directly the error signal.

Moreover, now the motors are supplied by 8V, in order to have more power.
 And They are controlled by a single PWM.

Here is the software, it works well! smiley

Main Program:
Code:
// Software AutoBalance
// Il programma legge l'errore
// Attraverso un controllo PID muove le ruote in modo da correggere tale errore.

// Definizione dei pin di INPUT
#define input A0                           // Definisce il pin a cui è collegato l'amplificatore differenziale

// Definizione dei pin utilizzati dai motori
#define motore 3                           // Definisce il pin PWM a cui sono collegati i motori

// Variabili per la gestione dell'Errore
float Errore = analogRead( input );        // Inclinazione dell'AutoBalance
float previousErrore = 0;                  // Inclinazione dell'AutoBalance al ciclo precedente

// Variabili temporali, per il calcolo del PID
float time = 0;                            // Tempo auttuale, dall'accensione del dispositivo
float previousTime = 0;                    // Tempo del precedente ciclo
float interval = 0;                        // Tempo impiegato per l'esecuzione di un ciclo di programma

// Variabili PID
float P = 0;                               // Variabile PROPORZIONALE  del PID
float I = 0;                               // Variabile INTEGRATIVA del PID
float D = 0;                               // Variabile DERIVATIVA del PID
float PID = 0;                             // Parametro PID

// Guadagni dei coefficenti PID
float kP = 0.6;                            // Coefficiente PROPORZIONALE del PID
float kI = 7;                              // Coefficiente INTEGRATIVA del PID
float kD = 0.02;                           // Coefficiente DERIVATIVA del PID

void setup()
{  
//Serial.begin( 9600 );                    // Avvia la comunicazione seriale
 pinMode( motore, OUTPUT );                // Imposta il pin del motore1 come uscita
}
void loop()                                  
{
/*
  Serial.print( "  Errore =  " );          // Stampa dei dati
  Serial.print( Errore );
  Serial.print( "  Intervallo =  " );    
  Serial.print( interval );
  Serial.print( "  P =  " );    
  Serial.print( P );
  Serial.print( "  I =  " );    
  Serial.print( I );
  Serial.print( "  D =  " );    
  Serial.print( D );
  Serial.print( "  PID =  " );    
  Serial.print( PID );
  Serial.print( "  PWM =  " );
  Serial.println( 127 + PID );
*/

  time = millis();                         // Salva il tempo corrente
  interval = (time - previousTime)/1000;   // Calcola il tempo impiegato per eseguire un ciclo in secondi
  
  getErrore();                             // Richiama la funzione getErrore() per ottenere l'errore
  getPID();                                // Richiama la funzione detPID() per calcolare i parametri del controllo PID
  controllomotori();                       // Richiama la funzione controllomotori() per il contorllo degli attuatori
 
  previousTime = time;                     // Memorizza il tempo attuale
  previousErrore = Errore;                 // Memorizza posizione attuale
}  
Motor control:
Code:
void controllomotori ()                // Algoritmo per il controllo dei due motori DC
{
  analogWrite( motore, 127 - PID );    // Controlla il motore1 in base al PID
}
GetError:
Code:
float getErrore()                      // Rilevazione della distanza, in ingresso il sensore da cui misurare
{
  int n = 50;                          // Numero di volte che si deve effettuare la misura, per il calcolo della media
  int array[n];                        // Array di appoggio per la rilevazione della distanza
  float somma = 0;                     // Variabile di appoggio per il calcolo della media
  int C;                               // Contatore di appoggio

  for ( C = 0; C < n; C++ )
  {  
    array[C] = analogRead( input );    // Salva n valori letti in un array di dimensione n
    somma = somma + array[C];          // Effettua la somma dei valori contenuti nell'array
  }
  
  Errore =  somma / n ;                // Effettua la media, e salva il valore ottenuto nella variabile Errore
}
GetPID:
Code:
void getPID()                                       // Algoritmo per il calcolo del PID
{
  Errore = Errore - (511.5);                        // Elimina l'offeset
  
  P = Errore * kP;                                  // Calcola la variabile proporzionale
  I = I + (P * interval * kI) ;                     // Calcola la variabile integrativa
  D = kD * ( Errore - previousErrore ) / interval;  // Calcola la variabile derivativa
  
  PID = P + I + D;                                  // Calcola il PID
    
  if( PID > 127 ) PID = 127;                        // Se il valore supera 127, il valore e' impostato a 127  
  if( PID < -127 ) PID = -127;                      // Se il valore e' minore di -127, il valore e' impostato a -127  
}

I'm sorry for the comments in Italian, I didn't have time to translate them....


The main problems were:

The too high time used for the serial communication.
Without the comunication, the too low time that the loop take. You have to put a delay. (I did it by measuring the analog imput 50 times)
The low power in the motors
The dinamyc output of the sensors weren't 0-5V, in the distances where they work.
The arm of the structure has been calculated in such a way as to have an adequate sensitivity

And some others things that now i don't remember xD

If you need something you have only to ask smiley


--

Sorry if i don't post all now, I'll post all when i'll finish the exam!
11  International / Software / Re: AutoBalance - Controllo PID on: January 19, 2013, 01:22:05 pm
Vi tengo aggiornati smiley-grin

Ho così modificato il programma:


Main program:
Code:
// Definizione dei pin utilizzati dai sensori
#define sensore1 A0                           // Definisce il pin del sensore1
#define sensore2 A1                           // Definisce il pin del sensore2

// Definizione dei pin utilizzati dai motori
#define motore1 3                             // Definisce il pin PWM a cui il motore1 è collegato
#define motore2 5                             // Definisce il pin PWM a cui il motore2 è collegato

// Variabili per il calcolo dell'orientamento
float orientamento = 0;                         // Inclinazione dell'AutoBalance, in funzione delle distanze rilevate
float previousorientamento = 0;

// Variabili temporali, per il calcolo del PID
long int time = 0;                               // Tempo auttuale, dall'accensione del dispositivo
long int previousTime = 0;                       // Tempo del precedente ciclo
int interval = 0;                           // Tempo impiegato per l'esecuzione di un ciclo di programma

// Variabili PID
float P = 0;                                  // Variabile PROPORZIONALE  del PID
float I = 0;                                  // Variabile INTEGRATIVA del PID
float D = 0;                                  // Variabile DERIVATIVA del PID
float PID = 0;                                // Parametro PID

// Guadagni dei coefficenti PID
float kP = 5;                                // Variabile PID PROPORZIONALE
float kI = 18;                         // Variabile PID INTEGRATIVA
float kD = 25;                                // Variabile PID DERIVATRIVA

// Gestione PWM
float pwm = 0;

void setup()
{
//Serial.begin( 9600 );                     // Avvia la comunicazzione seriale
    pinMode( motore1, OUTPUT );               // Imposta il pin del motore1 come uscita
    pinMode( motore2, OUTPUT );               // Imposta il pin del motore2 come uscita
}

void loop()                                   //
{  
  controllomotori( getPID() );
/*
  Serial.print( "  Orientamento =  " );    
  Serial.print( orientamento );
  Serial.print( "  Intervallo =  " );    
  Serial.print( interval );
  Serial.print( "  P =  " );    
  Serial.print( P );
  Serial.print( "  I =  " );    
  Serial.print( I );
  Serial.print( "  D =  " );    
  Serial.print( D );
  Serial.print( "  PID =  " );    
  Serial.print( PID );
  Serial.print( "  PWM =  " );
  Serial.println( pwm );
*/
  previousorientamento = orientamento;         // Orientamento al ciclo precedente  
}

Acquisizione dati:
Code:
float getdistanza( int sensore )
{
  int n = 5;                                     // Numero di volte che si deve effettuare la misura, per il calcolo della media
  int arrays1[n];                                // Array di appoggio per la rilevazione della distanza1
  int somma = 0;                                 // Variabile di appoggio per il calcolo della media
  int minimo = 9999;
  int massimo = 0;
  int C;                                        

  for ( C = 0; C < n; C++ )
  {  
    arrays1[C] = analogRead( sensore );
  
    if ( arrays1[C] < minimo )
        minimo = arrays1[C];
      
    if ( arrays1[C] > massimo )
        massimo = arrays1[C];
 
    somma = somma + arrays1[C];
  }
          
  return (somma - minimo - massimo) / ( n - 2 );
}


Calcolo PID:
Code:
float getPID()                                                      // Algoritmo per il calcolo del PID
{
  getorientation();                                               // Richiama la funzione per ottenere l'orientamento
  
  previousTime = time;                                            // Salva il tempo al ciclo precedente
  time = millis();
  interval = time - previousTime;                                 // Calcola il tempo impiegato per eseguire un ciclo
  
  P = orientamento * kP;                                          // Calcola la variabile proporzionale
  I = I + P * interval * kI / 10000 ;                                      // Calcola la variabile integrativa
  D = kD * ( orientamento - previousorientamento ) / interval;    // Calcola la variabile derivativa
  
 // if (I > 100) I=100;
 // if (I < 100) I=100;

  PID = P + I + D;                                                // Calcola il PID
  
  if( PID > 127 ) PID = 127;                                 // Se il valore supera 255/2, il valore è impostato a 255/2  
  if( PID < -127 ) PID = -127;                               // Se il valore è minore di -255/2, il valore è impostato a -255/2  
  
  //if(PID <= 1 && PID > 0) PID = 0;                                // Approssima il PID a 0
  //if(PID >= -1 && PID < 0) PID = 0;                               // Approssima il PID a 0
  
  return( PID );                                                  // Ritorna il valore del PID
}

void getorientation()                                             // Algoritmo per il calcolo dell'orientamento
{
  orientamento = getdistanza( sensore1 ) - getdistanza( sensore2 );               // Differenza fra le distanze rilevate dai due sensori
}


Controllo motori:
Code:
void controllomotori ( float PID )                      // Algoritmo per il controllo dei due motori DC
{
  pwm = 127 + PID;
 /*
  if ( pwm > 127 && pwm < 180 )
     pwm = 180;
    
  if ( pwm < 127 && pwm > 74 )
    pwm = 74;
 */
  analogWrite( motore1, pwm );          // Controlla il motore1 in base al PID
  analogWrite( motore2, pwm );          // Controlla il motore2 in base al PID
}


Non sono ancora riuscito a bilanciare perfettamente il PID, ma ora riesce a tenersi in equlibrio per 15/20 secondi.
Il problema principale erano i print a schermo, che prendevano troppo tempo, tolti quelli e ottimizzato un pò il programma la situazione è migliorata molto  smiley-grin

Inoltre ho notato che distanziando maggiormente i sensori dal corpo del robot funziona meglio (anche se non ho ben capito perchè).

Inoltre ho provato a togliere la "zona morta" in cui il valore del PWM è così basso che i motori non si muovono, forzando questi valori al minimo valore del PWM per cui le ruote muovono (molto lentamente).
Devo ancora capire se serve questa parte o riesco a farla tramite PID  smiley
12  Topics / Robotics / Re: AutoBalance - PID Controller on: January 18, 2013, 02:05:33 pm
It's very common that motors do not start moving until the PWM duty cycle gets past some
minimum threshold. I assume you'd set this value based upon how fast you want the robot
to move, and then use PID to superimpose on that to maintain balance.

Got it, I must set the PID so that it exceeds these values!


And, I found a big problem!
The serial communication took too long time, without it, the time by which the robot reacts has increased dramatically!

I still have to balance the PID, but now it can keep the balance for about 20 seconds!

Thank you very much for your help! smiley
13  Topics / Robotics / Re: AutoBalance - PID Controller on: January 18, 2013, 10:58:36 am
Is it possible that i don't get the balance because the DC motors at low values of the PWM ( 127 +- 30/40 ) don't move?

edit.I'm going to set these values with the minimum value with which the motors work...
14  Topics / Robotics / Re: AutoBalance - PID Controller on: January 17, 2013, 03:55:38 pm
All I know about PID is that it takes a lot of fine tuning to get the correct P,I,D gain values
for a particular situation. John is right. I would start with P, and then add in D only. Lastly, do
I after the others are set well. Break the problem into parts.

For tuning D, you might try just giving the top of the frame a quick push, ie, a sort of
impulse function, and playing with the D gain value until it responds properly. Also, you need
to be sure you have the "sign" of the gains correct. You want negative feedback, and not
positive feedback.




Hmm ok! I'll try and i'll let you know!
Thank you very much.
15  Topics / Robotics / Re: AutoBalance - PID Controller on: January 17, 2013, 01:06:26 pm
You might want to start by eliminating I and D (set kI and kD to 0.0).  Put your robot on its side and hold a board near the wheels so that the distance sensors measure "level".  Your wheels should stop.  As you tip the board slightly the wheels should start driving toward the closer side.  If that test doesn't work (wheels run while 'level' or run in the wrong direction while 'tilted') you need to correct your control system.
This works fine!
He "try" to keep the balance, but after one or two oscillations he falls... ( with only P, with PI, PD, PID... I tried a lot of values of kp, ki and kd but nothing, in any configuration)
Pages: [1] 2 3 ... 7