MECCANICA e DINTORNI

Breve video del funzionamento:

Come accennavo ho un problemino software che devo cercare di risolvere: se faccio partire lo stepper alla massima velocita' non parte, ma se parto da velocita' piu' basse e giro il potenziometro allora riesco ad arrivare a velocita' veramente elevate.

Immagino che dovro' modificare il firmware per introdurre un' accelerazione graduale partendo piu' lento ed accelerando.

Un ulteriore problema e' che a basse velocita' il movimento e' piuttosto "ruvido" ( si sente anche nel video ).

Questo e' piu' complesso, immagino, da risolvere pero' potrei fregarmene e farlo lavorare "ruvido", ma se avete consigli sono ben accetti.

Vorrei poi passare al microstepping perche' ho poco controllo sul movimento: se voglio muovermi di poco ( 1/2 cent ) non riesco perche' anche a velocita' piu' basse, il tempo di pressione del pulsante porta ad un numero di step tali che supero sempre il punto voluto. Inoltre ho notato che il mio DRO ha un problemino che devo capire. Anche lui, su brevi movimenti, e' impreciso. Riesco ad avere buone letture se e solo se toro ben indietro ( diciamo 1mm ) e poi rivado avanti. Praticamente ha una sorta di backlash che non riesco a ridurre. Immagino dipenda dalla scarsa rigidita' dell' asta del DRO, unita ad un non perfetto allineamento del sistema di ancoraggio del cursore alla testa.

Ulteriore modifica e' stata ( come si vede dal video ) passare da un nema 17 ad un nema 23. Il 17 non aveva abbastanza coppia per muovere la testa ( troppi attriti irrisolvibili ).

Per aggirare il problema del ritorno di tensione ho deciso che faccio un sistema che mi consenta di muovere il motore in alto e basso in maniera semplice cosi da disgiungere la cinghia quando non mi serve.

In ogni caso per il momento sono soddisfatto. Dovrei riuscire ad usarla per quello che mi serve ora ( foratura del blocco centrale dell' affilatore ), poi passeremo a migliorarla.

Pigi

Il firmware l'hai scritto tu ? Come li gestisci i passi ?
Il modo migliore per inserire l'accelerazione è quello di generare i passi con un PWM. Il periodo di ON deve essere fisso, diciamo nell'ordine dei 5-10 uSec (dipende dal minimo impulso accettabile per il driver), mentre il tempo di OFF è variabile ed è più lungo quando vuoi girare lento e più corto quando vuoi girare veloce. L'accelerezaione la puoi definire come un parametro (eventualmente configurabile) che determina il tempo di attesa tra un cambio di tempo di OFF e l'altro.
Facciamo un esempio:
tempo di ON: 5usec (impulso di step minimo accettabile dallo stepper driver)
Massima velocità di rotazione dello stepper: 500 rpm
Con stepper a 400 passi/giro (half step), vuol dire 500/60 = 8,33 giri al secondo, quindi 400*8,33 = 3332 passi/sec
Questa è la velocità massima del motore stepper che, tradotta in PWM vuol dire 3.3Khz circa, ovvero un periodo da 1/3332 = 0,0003 (300usec).
Se il tempo di ON è fisso a 5usec, il tempo di OFF, per andare alla massima velocità, dovrà essere di 300-5 = 295usec.
Ipotizziamo di partire da una velocità di 10 rpm in modo che lo stepper non stalli per l'accelerazione troppo brusca:
10rpm = 0.16 giri al secondo; 0.16*400=66.6 passi/sec, ovvero un PWM da 1/66.6=0.015 (15mSec = 15000uSec). Quindi, per partire a 10rpm, il PWM dovrà avere un tempo di OFF di 15000 uSec.
Per creare l'accelerazione sarà necessario, partendo da 15000uSec di periodo di OFF, arrivare a 295uSec decrementando questo valore ed inserendo un tempo di delay tra un decremento e l'altro.
Il tempo di delay determinerà la velocità di accelerazione, più sarà lungo, più lenta sarà l'accelerazione.
Decvrementando di 1uSec per volta avrai una granularità molto elevata del cambio di accelerazione ma rischi, se il micro non è velocissimo, di rallentare troppo la curva di accelerazione anche riducendo il delay di parecchio. Il mio consiglio è quello di decrementare di 10uSec per volta aggiustando poi il delay di conseguenza.
Se vuoi chiamami che ti spiego meglio...

Ragionare al contrario non è sempre sbagliato...

Si, Max, il firmware lo ho scritto io.

Il problema che ho trovato nel riciclare codice e' che non c'e' nessuno in giro che ha un controllo "fino a che il pulsante e' premuto".
Sono tutti tipo "premi il pulsante e parte, premi il pulsante e si ferma" o peggio ancora "premi il pulsante e si muove di tot passi, poi si ferma".
Io, come ho detto, volevo un sistema tipo "fino a che tengo premuto ti muovi, appena lascio ti fermi".

In piu', avendo pochi input digitali a disposizione ho usato una rete resistiva per usare un solo pin analogico per 6 pulsanti.

Questo lo schema dei pulsanti ( e potenziometro per la velocita' su un altro ingresso digitale ):

Pulsanti.jpg

Il ciclo che faccio e' semplice: nel loop controllo il valore del potenziometro e lo infilo in una variabile, controllo il valore della rete resistiva, nel caso abbia una lettura "valida" setto la direzione, alzo il pin di step, aspetto il valore del pot, abbasso il pin di step, aspetto il valore del pot.

Codice: Seleziona tutto

#define PULSANTI A0
#define POTENZIOMETRO A1

#define D13 13

#define ENA_X 12
#define DIR_X 4
#define STP_X 5

#define ENA_Y 11
#define DIR_Y 6
#define STP_Y 7

#define ENA_Z 10
#define DIR_Z 8
#define STP_Z 9


int speedVal ;
int newspeedVal ;
int keyPressedVal;
int keyPressed;

void speedUp(int speedVal) {
newspeedVal = map(speedVal, 0, 1023, 150,2000); // Converts the read values of the potentiometer from 0 to 1023 into desireded delay values (150 to 2000)
 }
void readValues(){
  /* 
   *  Val: 0    1
   *  Val: 683  2
   *  Val: 768  3
   *  Val: 512  4
   *  Val: 820  5
   *  Val: 854  6
   */

  keyPressed=0;
  speedVal = analogRead(POTENZIOMETRO);
  speedUp(speedVal);
  speedVal=newspeedVal;

  keyPressedVal = analogRead(PULSANTI);

  if (keyPressedVal <= 5) {
     keyPressed=1;
  } else if ( keyPressedVal > 5   && keyPressedVal <= 520 ) {
     keyPressed=4;
  } else if ( keyPressedVal > 520 && keyPressedVal <= 685 ) {
     keyPressed=2;
  } else if ( keyPressedVal > 685 && keyPressedVal <= 770 ) {
     keyPressed=3;
  } else if ( keyPressedVal > 770 && keyPressedVal <= 825 ) {
     keyPressed=5;
  } else if ( keyPressedVal > 825 && keyPressedVal <= 858 ) {
     keyPressed=6;
  }
  
}

void setup() {

  pinMode(13, OUTPUT);
  pinMode(PULSANTI, INPUT );
  pinMode(POTENZIOMETRO, INPUT );
  pinMode(ENA_X,OUTPUT );
  pinMode(DIR_X,OUTPUT );
  pinMode(STP_X,OUTPUT );

  pinMode(ENA_Y,OUTPUT );
  pinMode(DIR_Y,OUTPUT );
  pinMode(STP_Y,OUTPUT );

  pinMode(ENA_Z,OUTPUT );
  pinMode(DIR_Z,OUTPUT );
  pinMode(STP_Z,OUTPUT );

}

// the loop function runs over and over again forever
void loop() {

  readValues();  // Leggiamo i valori analogici
  digitalWrite(D13, LOW);
  if ( keyPressed > 0 ) {
      digitalWrite(D13, HIGH);

     switch ( keyPressed ){
          case 1:     // Y Left 
             digitalWrite(DIR_Y, HIGH);
             digitalWrite(STP_Y, HIGH);
             delayMicroseconds(speedVal);
             digitalWrite(STP_Y, LOW);
             delayMicroseconds(speedVal);
             break;
          case 2:     // X Forw
             digitalWrite(DIR_X, HIGH);
             digitalWrite(STP_X, HIGH);
             delayMicroseconds(speedVal);
             digitalWrite(STP_X, LOW);
             delayMicroseconds(speedVal);
             break;
          case 3:     // X BACK
             digitalWrite(DIR_X, LOW);
             digitalWrite(STP_X, HIGH);
             delayMicroseconds(speedVal);
             digitalWrite(STP_X, LOW); 
             delayMicroseconds(speedVal);
             break;
          case 4:     // X BACK
             digitalWrite(DIR_Y, LOW);
             digitalWrite(STP_Y, HIGH);
             delayMicroseconds(speedVal);
             digitalWrite(STP_Y, LOW);
             delayMicroseconds(speedVal);
             break;
          case 5:     // Z UP
             digitalWrite(DIR_Z, HIGH);
             digitalWrite(STP_Z, HIGH);
             delayMicroseconds(speedVal);
             digitalWrite(STP_Z, LOW);
             delayMicroseconds(speedVal);
             break;
          case 6:     // Z UP
             digitalWrite(DIR_Z, LOW);
             digitalWrite(STP_Z, HIGH);
             delayMicroseconds(speedVal);
             digitalWrite(STP_Z, LOW);
             delayMicroseconds(speedVal);
             break;
          default:
             break;
     }
  }
}

Ovviamente e' gia' pronto per gestire i 3 assi, ma ne uso uno solo. Potrei anche ottimizzare il ciclo di step, ma per ora va funziona ( a parte i suddetti problemi.

Ho capito il tuo discorso sui cicli per l' accelerazione, ma come sempre mi scontro con il fatto del funzionamento a pulsante premuto.
Inoltre con la rete analogica non posso nemmeno usare proficuamente gli interrupt "on change" ( ma di questo non sono sicuro ) e quindi calcolare il ciclo dell' accelerazione deve essere empirico.

Quello che pero' ho capito bene e' di tenere fisso il tempo di ON, e forse e' per quello che il motore e' rumoroso alle basse velocita'.
Quindi cambiero':

Codice: Seleziona tutto

             digitalWrite(STP_Y, HIGH);
             delayMicroseconds(speedVal);
             digitalWrite(STP_Y, LOW);
             delayMicroseconds(speedVal);

in

Codice: Seleziona tutto

             digitalWrite(STP_Y, HIGH);
             delayMicroseconds(10);
             digitalWrite(STP_Y, LOW);
             delayMicroseconds(speedVal);

dove il 10 e' un valore assolutamente casuale ma dovrebbe andare bene, dato questo:

DRV8825_Timing.png

Il minimo time e' 1,9 micro, quindi a 10 dovrei andare bene.

Il codice fa abbastanza schifo, ma se vedi grosse cavolate sono tutto orecchi :)

Iniziamo con lo schema dei pulsanti. Allora il concetto è ok solo che non mi piace avere un partitore variabile; meglio avere una maglia sempre con la stessa corrente soprattutto quando si vogliono usare ingressi analogici.
Usa questo schema:

Pigi_Stepper_control_connections.jpg

accanto ad ogni tasto ti ho scritto la tensione calcolata che leggerai sull'ingresso analogico.
Quando non c'è premuto alcun tasto leggerai la massima tensione (5V) per via del pull-up.
Fatto in questo modo è molto più lineare ed ordinato.

Ti sei semplificato la vita utilizzando le digitalWrite con i delay ma in questo modo il controllo dell'accelerazione e altre funzionalità sono pressochè impossibili da implementare. Senza contare che, finchè hai un solo asse tutto va bene, ma quando inizi ad averne 2 o 3 (e mi sembra sia quella la tua idea) la cosa diventa ingestibile.
L'utilizzo del PWM in modalità avanzata ti permette di far gestire gli step in modo autonomo ai timer senza inserire delay, ne per l'esecuzione dello step stesso, ne tantomeno per l'attesa di quello successivo.
Purtroppo le funzionalità del PWM implementate da ARDUINO con la classe "analogWrite" sono basilari e non ti permettono di fare cose incredibili.
Per poter utilizzare il PWM in modo serio dovrai andare a scrivere nei registri dell'ATMega direttamente e senza usare classi preconfezionate.
Stasera ti giro alcuni pezzi del mio codice dell'ELS dove si vede come uso il PWM per generare gli step e ti spiego più o meno come fare.
Chiamami più tardi che ne parliamo... l'argomento è complesso e, sebbene sia giusto scriverlo anche per lasciarne traccia sul forum, alcune cose è meglio chairirle a voce!

Ti chiamo senz'altro !
Pero' intanto ho un chiarimento da fare. Nel mio "joystick" non ho intenzione di muovere 2 o piu' assi contemporaneamente.
Ho intenzione si di avere due o piu' assi motorizzati, ma sempre muovendoli uno alla volta.
Questo semplifica notevolmente il codice ( o dovrebbe) .

Se ho capito il tuo messaggio precedente, la routine di accelerazione dovrebbe (potrebbe) funzionare cosi.
da ( nella readVal ):

Codice: Seleziona tutto

void readValues(){

  keyPressed=0;
  speedVal = analogRead(POTENZIOMETRO);
  speedUp(speedVal);
    speedVal=newspeedVal;
 ...

a

Codice: Seleziona tutto

  void readValues(){
  
  keyPressed=0;
  speedVal = analogRead(POTENZIOMETRO);
  speedUp(speedVal);
  if (( 15000-decrement) > newspeedVal ){
      speedVal=(15000-decrement) ;
      decrement+=10;
  } else {
    speedVal=newspeedVal;
  }

dove il 15000 e' il valore di massima lentezza ( newspeedVal = map(speedVal, 0, 1023, 10,15000); )

Poi nel loop principale, quando il keyPressed vale 0 metto il decrement = 0.

Ovvio che se ci dovesse essere un transitorio per cui mi legge il valore dell' A0 ( pulsanti ) in modo errato e mi fa diventare 0 il decrement, il motore si blocca di colpo e ricomincia ad accelerare, ma grossi danni non ne dovrebbe fare.

Altrimenti ( ma e' uno step evolutivo ) dal momento che i miei arduini li ho pagati meno di un euro l' uno, posso prenderne 3 e allora il software si semplifica di molto, cosi come la disponibilita' di pin digitali per pulsanti e pwm.

Come ti sembra così? :

Codice: Seleziona tutto

 
void readValues(){
  
  keyPressed=0;
  speedVal = analogRead(POTENZIOMETRO);
  speedUp(speedVal);
  if (speedVal > newspeedVal)
     speedVal -= 10;
  ....

Devo ancora capire bene come gestisci la funzione "speedUp".... in ogni caso non starei troppo a scervellarmi su questo adesso: quando vedrai cosa puoi fare con i PWM questo codice non avrà più alcun senso

La speedUp e' un sistema per cambiare la "granularita'" dell' ingresso analogico.

Dall'ingresso analogico ottieni un valore che va da 0 a 1023, ma ovviamente se usassi 0 come valore minimo e sopratutto 1023 come valore massimo, avrei un range di ritardo ( o accelerazione ) molto limitato.
Allora nella speedup uso una funzione ( map ) a cui passo: valore minimo e valore massimo in ingresso e valore minimo e valore massimo da convertire.
Mi spiego meglio: newspeedVal = map(speedVal, 0, 1023, 150,5000); significa che se speedval vale 0, newspeedval deve valere 150,
se vale 1023 deve valere 4000, e per tutti i valori in mezzo ci pensa lui a valorizzarli in proporzione.

Questa e' la formula della libreria:
long map(long x, long in_min, long in_max, long out_min, long out_max)
{
return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
}
e questa la descrizione ( dal sito arduino) :

Re-maps a number from one range to another. That is, a value of fromLow would get mapped to toLow, a value of fromHigh to toHigh, values in-between to values in-between, etc.
...
...
The map() function uses integer math so will not generate fractions, when the math might indicate that it should do so. Fractional remainders are truncated, and are not rounded or averaged.

Dopo un interessantissima telefonata con Max che mi hanno spinto ad approfondire il discorso PWM, vorrei aggiornarne questo thread sui risultati delle modifiche segnalate ieri al mio codice, per ora ancora con il controllo diretto e le Digitalwrite.
Il prossimo passo sara' quello di riscrivere tutto con il pwm, ma mi ci vorra' un po, e siccome voglio portare avati l' affilatrice per ora usaro' il mio codice.

Ho effettuato 3 prove:
1) Gestendo l' accelerazione a step di 10us
2) Gestendo l' accelerazione a ste di 250 ( poi ridotti a 100 ma con gli stessi risultati )Us
3) Gestendo l' accelerazione con step variabili in funzione della curva di accelerazione.

In pratica il codice e' passato da ( modo 1 ):

Codice: Seleziona tutto

void readValues(){
  
  keyPressed=0;
  speedVal = analogRead(POTENZIOMETRO);
  speedUp(speedVal);
  if (( 15000-decrement) > newspeedVal ){
      speedVal=(15000-decrement) ;
      decrement+=10;
  } else {
    speedVal=newspeedVal;
  }

( Questo ha dato i migliori risultati in termini di velocita' massima. Sono riuscito ad arrivare a velocita' incredibili senza che il motore stallasse.
Naturalmente c'e' un prezzo da pagare, ed e' il tempo in cui si arriva alla velocita' massima, molto lungo. )

a ( modo 2 ) :

Codice: Seleziona tutto

void readValues(){
  
  keyPressed=0;
  speedVal = analogRead(POTENZIOMETRO);
  speedUp(speedVal);
  if (( 15000-decrement) > newspeedVal ){
      speedVal=(15000-decrement) ;
      decrement+=250;    // ( poi diventato 100 ) 
  } else {
    speedVal=newspeedVal;
  }

( questo e' molto piu' rapido nell' accelerazione ma comincia abbastanza presto a perdere passi )

a:

Codice: Seleziona tutto

void readValues(){
  keyPressed=0;
  speedVal = analogRead(POTENZIOMETRO);
  speedUp(speedVal);
  if (( 15000-decrement) > newspeedVal ){
      speedVal=(15000-decrement) ;
      if ( decrement <= 10000 )  {
         decrement+=500;
      } else if ( decrement  > 10000 && decrement <= 13500 ) {
           decrement += 100 ;
      } else if ( decrement  > 13500  ) {
          decrement += 10 ;
      }
  } else {
    speedVal=newspeedVal;
  }

Quest' ultimo ha migliorato un po' la velocita' massima, ma comunque non arriva alle performaces del primo esempio.
In pratica ho cominciato a rallentare l' accelerazione ( scusate il gioco di parole ) man mano che i giri aumentavano.
Credo pero' che il numero di istruzioni necessarie a gestire i check abbia contribuito a fare perdere timing al ciclo al punto che il motore ne ha risentito.

Probabilmente l' optimum e' davvero quest' ultimo, ma c'e' da giocare un po' con i valori e forse non ne vale la pena.

Per ora ritornero' al modo 1 che e' lento nell' accelerazione ma mi da velocita' incredibili, fino a che non riesco a gestire il tutto in pwm.

Stasera "riflasho" con il codice 1 e poi mi fermo su questo progetto fino a che non ho portato avanti l' affilatrice.
Inoltre, vorrei anche cominciare a pensare alla motorizzazione dell' asse X, che e' forse il piu' importante per quando si fanno i lavori di spianatura con i fly-cutter per avere una superficie piu' liscia possibile.

Pigi scusa ma la variabile "decrement" dove la inizializzi?

La variabile decrement viene inizializzata nelle variabili globali, e azzerata nel ciclo del loop quando nessun pulsante e' premuto, ( nella versione postata prima non c'era ).

Codice: Seleziona tutto

  if ( keyPressed > 0 ) {

     switch ( keyPressed ){
          case 1:     // Y Left 
               ...
               ...
             break;
          case 2:     // X Forw
               ...
               ...
             break;
               ...
               ...

          default:
             break;
     }
  } else {             // Se nessun tasto e' premuto
    decrement=0;
  }

Cosi sono certo che se mollo il pulsante partiro di nuovo con una rampa di accelerazione.

per fare il polling dei tasti puoi usare questa libreria:
http://playground.arduino.cc/Main/MsTimer2
Utilizza gli interrupt con il Timer2 per chiamare funzioni ad intervalli regolari. La funzione nel tuo caso potrebbe essere la lettura dell'ingresso analogico associato ai tasti per verificare se è cambiato qualcosa....

La prossima volta, per sviluppare, passa ad un micro più serio.
Le schede NUCLEO di ST costano 10€ al pezzo e montano un processore ARM a 32 bit, hanno sia la piedinatura compatibile ARDUINO che la piedinatura estesa (formato ST MORPHO) che ti permette di utilizzare tutti gli I/O del processore e sono davvero parecchi.
Per sviluppare il codice si fa tutto online creando un account su MBED, una piattaforma gratuita fornita da ARM, piena di librerie per fare praticamente tutto. Tra l'altro il C è di livello più avanzato ed esistono già funzioni e classi standard per fare qualsiasi cosa... ad esempio QUESTA è la classe "Ticker" che ti permette di definire tutte le istanze che vuoi e chiamare funzioni diverse ad intervalli di tempo che decidi tu.... insomma puoi programmare un microcontrollore come se avessi a bordo un sistema operativo!
Una volta che hai scritto il tuo codice, lo compili e lui ti scarica un file .bin; connetti la NUCLEO al PC/MAC con l'USB e ti viene rilevata come fosse un drive USB, ci copi dentro il file .bin ed il micro è programmato.
Il debug lo fai sempre utilizzando la seriale (emulata da USB) ed usando un terminale standard (io uso ZTerm)
Inutile spiegati che passare da un micro come l'ATMega a 8 bit ad un ARM a 32 bit è come passare dal triciclo scassato alla Ferrari da formula uno

Max,
sono veramente bellerrime quelle schede.

Credo proprio che per il prossimo progetto ci faro' un pensierino.

Devo vedermi quante linee di interrupt hanno perche' mi sta venendo in mente di fare una scheda che mi faccia da contagiri/controllo movimento/dro ( sola lettura assi )/altro per la mia fresettina....

Grazie della segnalazione !

16 linee di interrupt solo per gli I/O, mappabili su qualsiasi pin via software con 1 istruzione.
Ci sono poi altri interrupt associati alle periferiche (USB, UART, ecc.)

MECCANICA e DINTORNI

Motorizziamo l' asse Z ! ( Sieg SX2P )

Re: Motorizziamo l' asse Z ! ( Sieg SX2P )

Re: Motorizziamo l' asse Z ! ( Sieg SX2P )

Re: Motorizziamo l' asse Z ! ( Sieg SX2P )

Re: Motorizziamo l' asse Z ! ( Sieg SX2P )

Re: Motorizziamo l' asse Z ! ( Sieg SX2P )

Re: Motorizziamo l' asse Z ! ( Sieg SX2P )

Re: Motorizziamo l' asse Z ! ( Sieg SX2P )

Re: Motorizziamo l' asse Z ! ( Sieg SX2P )

Re: Motorizziamo l' asse Z ! ( Sieg SX2P )

Re: Motorizziamo l' asse Z ! ( Sieg SX2P )

Re: Motorizziamo l' asse Z ! ( Sieg SX2P )

Re: Motorizziamo l' asse Z ! ( Sieg SX2P )

Re: Motorizziamo l' asse Z ! ( Sieg SX2P )

Re: Motorizziamo l' asse Z ! ( Sieg SX2P )

Re: Motorizziamo l' asse Z ! ( Sieg SX2P )