MECCANICA e DINTORNI

il timer continua a contare si ma in che direzione? Quella che ti dice il DIR.... e come lo leggi il DIR?
Per sapere da che parte sta girando il mandrino devi controllare il DIR, non c'é altro modo.
Oppure usi una QEI (Quadrature Encoder Interface) che legge la fase e aggiorna il conteggio autonomamente.....

Chi lo dice che non posso usare il microstep?
il motivo per cui non lo uso é perché non serve e richiede potenza di calcolo inutile. Come puoi vedere le filettature vengono bene anche con i miei miseri 400 passi di stepper e 1000 passi di encoder.
il Microstep oltretutto é inaffidabile sul posizionamento ed é molto più facile perdere passi e, non ultimo, ti limita nella velocità massima.
comunque, se leggerai il PDF, capirai anche perché ho impostato lo stepper a 400 passi.

Premettendo che quello che tu dici non si possa fare, io l'ho fatto è salvo il caso che ti ho descritto non ci sono perdite di passi. Ho letto di sfuggita il tuo PDF, lo leggerò poi con più attenzione. Che il micro passo penalizzi le prestazioni del motore e tutto da verificare. Io ho riscontrato l'esatto contrario. Il tutto funziona da circa un anno. Inoltre il mio codice non richiede calcoli complessi.

facciamo così, voi mi mandate un prototipo ed io lo testerò per bene poi decideremo il vincitore, tipo la prova del cuoco......

Non è una gara ma solo un confronto costruttivo.

la mia era solo una battuta

Per un processore a 8bit, il calcolo che include variabili float é già definito come complesso visto che richiede parecchi cicli di clock. Mi piacerebbe capire come e dove esegui i calcoli frazionari per calcolare il rapporto tra passi encoder e passi stepper.... Se non utilizzi una lookup table come faccio io con l'array allora per forza di cose esegui il calcolo ad ogni passo stepper e lo esegui durante il ciclo di filettatura e avanzamento.

Gli unici calcoli complessi che eseguo sono una sottrazioni e un'addizioni di numeri interi a 16 bit, che eseguo all'interno della routine di interruzione.

scusa ma non ti seguo. Da qualche parte una divisione la devi fare.
Certo se mantieni questo riserbo sul codice è difficile comprendere come hai fatto.....

Se non sbaglio Mimoletti usa una tabella dove il passo, trasformato in impulsi encoder e' diviso in due interi, il primo contiene la parte intera e il secondo la parte frazionaria moltiplicata per mille degli impulsi necessari ad eseguire un passo.
Il concetto e' che quando la parte frazionaria oltrepassa quota mille devo aggiungere un impulso in piu' e al contatore frazionario sottrarre 1000... e il gioco continua.
In questo modo non si eseguono divisioni con resti ecc ma semplici addizioni e sottrazioni.
Con una tabella il lavoro e' ancora minore dato che praticamente non ci sono calcoli da fare, sono gia' stati eseguiti e il discorso del resto della divisione gia' inserito in un elemento dell'array. Non so quanti elementi debba avere un array per avere una buona risoluzione su passi con molti impulsi encoder interi e pochi frazionati, li il metodo di Mimoletti si "autoregola" tenendo in memoria la piccola parte frazionaria fino al momento del superamento dell'unita.
Sul fatto dell'unita' esterna al mpu io volevo usare un circuito che mi desse un impulso su un pin in caso di rotazione oraria e su un'altro pin in caso contrario, ma qui cambia la gestione del programma. Avrei usato l'interrup su pin change e fatto una somma tipo CONTATORE = CONTATORE +PINCW -PINCCW cosi' automaticamente aumento o decremento il contatore a seconda se il valore 1 e' presente sul pincw o sul pinccw...queste sono le mie idee ancora lontane dalla realizzazione
Mandi Mecha

dai un occhio al mio sorgente ed in particolare alla funzione "InterrupEncoderFilettatura()". Il concetto è quello solo che l'encoder viene letto con i segnali in quadratura senza rischi di inversioni simultanee del DIR che, a mio avviso, ricavato con logica esterna è sempre a rischio.

Pressa poco ho fatto come è stato spiegato da mecha, in ogni caso se il codice è strutturato correttamente, con logica esterna il funzionamento è assicurato.

Piuttosto leggere ogni fronte di salita del canale A e B, in tempo reale, ti permette senza una logica esterna di stabilire la direzione di rotazione, ma non ti permette la realizzazione di una routine per gli avanzamenti sincronizzati, infatti hai dovuto ripiegare arrangiando in altri modi.

Facendo due calcoli, la strategia che tua hai scelto non può funzionare correttamente (ovviamente potrei aver capito male, il modo in cui è stata strutturata). Mi spiego, se tu in anticipo prima di ogni giro calcoli il numero di step che deve fare il motore, alla lunga perdi dei passi.
Facciamo un'esempio, immaginando che il valore di divisione e 3, la risoluzione del encoder è 2000 (leggendo solo i fronti di salita dei canali A e B siamo a 1000 x 2), il tuo sistema prevede che il numero di passi a giro debba essere di: 2000 : 3 = 666, dopo dieci giri il tuo sistema ha generato 6660 passi, ma in realtà ne avrebbe dovuto generare 20000 : 3 = 6666.
Di conseguenza hai perso 6 passi.
Quindi avrai una filettatura con un passo che non è costante. Perché il numero di passi non è costante ad ogni giro.

Nel mio caso il mio sistema quando il valore di divisione è 3. Al primo giro genera 666 passi, al secondo genera ancora 667 passi,
al terzo 666, al quarto 667 e cosi via.

Non ho capito perché dovrei perdere dei passi per il calcolo.
Ti faccio un esempio pratico con la mia attuale configurazione: encoder 1000 passi (250x4); vite 400 passi; passo vite 3,175mm (8 filetti per pollice)
Poniamo di voler costruire un passo da 2mm, questo vuol dire ad ogni giro mandrino (quindi 1000 passi) lo stepper della vite dovrà eseguire:
(400/3.175)*2 = 251,96 che arrotondiamo all'intero più prossimo quindi 252.
Per via dell'arrotondamento avrò certamente una lieve differenza rispetto al passo nominale ed in particolare questa sarà così calcolata:
(3.175/400)*252 = 2.00025 mm. Ovvero avrò un errore sul passo di 0.25 micron

Calcolato quindi che lo stepper dovrà eseguire 252 passi ad ogni giro del mandrino, questo vorrà dire che dovrò eseguire un passo stepper ogni:
1000/252 = 3,9682 passi del mandrino.

Poiché non posso frazionare i passi, devo eseguire passi interi con una sequenza tale che mi permetta di raggiungere, alla fine di ogni singolo giro del mandrino, i 252 passi stepper che ho calcolato. Per fare questo creo un array che contiene tanti valori quanti sono i passi stepper da eseguire (quindi 252 celle), in ognuna delle quali inserisco un numero intero che indica quanti passi mandrino si dovranno attendere prima di fare il passo stepper e passare quindi alla cella dell'array successiva (o precedente, dipende ovviamente dalla direzione di filettatura). Una volta creato l'array eseguo un controllo atto a verificare che la somma di tutti i passi mandrino contenuti nell'array sia esattamente 1000, ovvero il giro mandrino completo. Può capitare che, a causa degli arrotondamenti nei calcoli ad approssimazione successiva, ci sia un passo in più o uno in meno, in questo caso aggiusto l'ultimo valore in modo da far tornare il conto ed avere quindi i 1000 passi richiesti. Tutto questo viene fatto PRIMA di iniziare la routine di filettatura.

Nella routine di filettatura l'array viene scandito regolarmente rispettando i passi mandrino richiesti ed eseguendo il passo stepper ad ogni cambio cella. In questo modo non eseguo alcun conto durante la routine ma mi limito a scandire l'array che verrà ripetuto dall'inizio una volta terminato, come se fosse una lista circolare.

Ora viene la parte critica ovvero quella in cui devo verificare che il codice non sia troppo lento e ogni interrupt venga gestito correttamente.
Immaginiamo di far girare il mandrino a 1000 giri al minuto (che in filettatura sono troppi comunque); il che vuol dire 1000/60 = 16,666 giri al secondo. Il che significa che ad ogni secondo varranno generati 16,666*1000 = 16666 interrupt, uno per ogni impulso encoder. Ovvero, avrò interrupt a distanza regolare con frequenza di 16,666Khz, ovvero un interrupt con periodo 60 microsecondi.
Il processore di ARDUINO ha un clock a 16Mhz, quindi con un ciclo/clock di 62,5 nanosecondi. Il processore è in architettura RISC con un set di 131 istruzioni la stragrande maggioranza delle quali viene eseguita con un solo ciclo di clock. Facciamo anche una media conservativa e diciamo che siano 1,5 per stare larghi, questo vuol dire che il micro, tra un interrupt e l'altro, sarà in grado di eseguire 640 istruzioni in codice macchina non complesse.

Questa è la mia routine di interrupt:
************
void InterruptEncoderFilettatura()
{
static byte prev_encoder; //definizione di variabile byte (1 ciclo di clock: 62,5 nanosecondi)
byte port; //definizione di variabile byte (1 ciclo di clock: 62,5 nanosecondi)

port = PIND & B00001100; //and logico tra due valori e trasferimento indiretto (3 cicli di clock: 187,5 nanosecondi)
port |= prev_encoder; //or logico tra due valori e trasferimento indiretto (3 cicli di clock: 187,5 nanosecondi)
steps += encoder[port]; //addizione tra due valori e trasferimento indiretto (3 cicli di clock: 187,5 nanosecondi)
absolute_encoder_steps += encoder[port]; //addizione tra due valori e trasferimento indiretto (3 cicli di clock: 187,5 nanosecondi)

port >>= 2; //shift a destra di due posizioni (2 cicli di clock: 125 nanosecondi)
prev_encoder = port; // load indiretto (2 cicli di clock: 125 nanosecondi)
step_flag = true; // cambio di stato logico (1 ciclo di clock: 62,5 nanosecondi)
} //END of the Interrupt Service Routine
**************
In totale sono 1187,5 nanosecondi. Ovvero 1,1875 microsecondi.
Se vuoi aggiungiamo il tempo di chiamata dell'interrupt, il pop e il push dello stack, ma anche con quelli direi che con 60 microseocndi ci sto dentro...

Quindi, mi spieghi dove dovrei perdere i passi ?

Non è a causa della durata delle routine di interruzione che hai questa perdita di passi, ma a causa del modo approssimativo con cui esegue la divisione degli impulsi.

Facciamo un'esempio:
Encoder 1000 impulsi a giro;
Stepper Vite 400 passi a giro;
Passo vite madre 3,175;

Volendo eseguire una filettatura ad. esempio di 1.75mm, il numero di passi a giro, dovrà essere: (400/3.175)*1.75 = 220,47;
Rapporto di divisione: 1000/220,47=4,5357

Ora immaginando di arrotondare a 220 passi a giro, dopo 20 giri di mandrino il tuo sistema avrà generato 4400 passi.
Immaginando di arrotondare a 221 passi a giro, dopo 20 giri di mandrino il tuo sistema avrà generato 4420 passi.

Il numero di passi che avrebbe dovuto generare sarebbe dovuto essere: 20000/4,5357= 4409.

Quindi nel primo caso hai un'errore di 9 passi (un'errore di circa 8 cent), nel secondo caso di 12 passi (un'errore di circa 1 decimo).

Dopo 40 giri hai un'errore compreso tra 1,6 decimi e 2 decimi.

Il mio sistema dopo 20 giri genera esattamente 4409 passi.
Dopo 100 giri genera esattamente 22047;

Il tuo invece dopo 100 giri avrà generato: 22000 o 22100 con un'errore di circa mezzo millimetro.

Certo. Il conto lo faccio una volta sola, prima della routine di filettatura.

Non è a causa della durata delle routine di interruzione che hai questa perdita di passi, ma a causa del modo approssimativo con cui esegue la divisione degli impulsi.

Facciamo un'esempio:
Encoder 1000 impulsi a giro;
Stepper Vite 400 passi a giro;
Passo vite madre 3,175;

Volendo eseguire una filettatura ad. esempio di 1.75mm, il numero di passi a giro, dovrà essere: (400/3.175)*1.75 = 220,47;
Rapporto di divisione: 1000/220,47=4,5357

Ora immaginando di arrotondare a 220 passi a giro, dopo 20 giri di mandrino il tuo sistema avrà generato 4400 passi.
Immaginando di arrotondare a 221 passi a giro, dopo 20 giri di mandrino il tuo sistema avrà generato 4420 passi.

Il numero di passi che avrebbe dovuto generare sarebbe dovuto essere: 20000/4,5357= 4409.

Quindi nel primo caso hai un'errore di 9 passi (un'errore di circa 8 cent), nel secondo caso di 12 passi (un'errore di circa 1 decimo).

Dopo 40 giri hai un'errore compreso tra 1,6 decimi e 2 decimi.

Il mio sistema dopo 20 giri genera esattamente 4409 passi.
Dopo 100 giri genera esattamente 22047;

Il tuo invece dopo 100 giri avrà generato: 22000 o 22100 con un'errore di circa mezzo millimetro.