MECCANICA e DINTORNI

Rispetto la tua opinione, io sono stato un'autodidatta, cosa intendi per simmetricità del codice?

Che in qualsiasi situazione sai esattamente cosa ti capita. Che non esistono situazioni in cui può o meno capitare qualcosa in funzione del caso e, non ultimo, che l'esecuzione sia simmetrica: se ci metti più tempo a gestire una determinata situazione e la sua inversa il codice non è simmetrico.

Anch'io sono autodidatta e sento molto la mancanza di una preparazione di base. Purtroppo, complice il fatto che quando andavo a scuola non esisteva neanche il VIC20, non ci hanno insegnato nulla.

Lo stepper è accoppiato, per ora in rapporto 1:1 alla vite madre, manca di stozzare la puleggia V.M. per la chiavetta, speriamo nella buona volontà di mafa!

permettetemi un'intrusione a volo

in condizione di non simmetricita', ovvero avere un output non predeterminabile a priori perchè funzione anche di variabili non dipendenti dalla nostra volonta', in caso di debug si ha anche il problema di non sapere se l'errore che riscontriamo è colpa di qualche cosa che non va o è semplicemente una condizione particolare di funzionamento del programma

bye luk

Ottima domanda, di solito divido il programmi in sottoprogrammi, destinati ad un compito specifico. Max che strategie devono essere usate per il debug?

Ciao Mario, sai dove sono.

Problema della simmetria risolto!
Ora ho sempre lo stesso numero d'impulsi in un senso che nell'altro.

Il debug ormai si fa quasi sempre via software visto che quasi tutti gli ambienti di sviluppo integrano degli strumenti di debug.
MPLAB di Microchip prevede la possibilità di inserire dei "breakpoints" ovvero dei punti in cui fermare l'esecuzione del programma in modo da poter osservare quello che succede prima o dopo una determinata azione che magari non sta eseguendo ciò che ci si aspetta. Oltre a ciò è possibile attivare dei "monitor" che fanno vedere quello che succede alle variabili mentre il programma viene eseguito. L'utilizzo dei breakpoints e dei monitor combinato permette un'analisi del codice molto puntuale ed aiuta a capire esattamente dove sta il "bug".
Una volta il debug si faceva su carta, prima ancora di far girare il programma, si compilava una tabella nota come "trace table". In pratica si faceva quello che si fa con breakpoints e monitor con la differenza che il programma non veniva eseguito realmente ma veniva scandito dal programmatore a mente: istruzione per istruzione si analizzava l'esecuzione e si compilava la trace table con i valori delle variabili, cambiandoli manualmente durante l'esecuzione.

Un'altro piccolo passo avanti: la puleggia per l'encoder

Questa è la parte di codice che si occupa di dividere gli impulsi, con una piccola modifica al codice ora posso gestire le inversioni, senza errori e mantenere la sincronizzazioni degli avanzamenti anche ad elevati numero di giri (praticamente due piccioni con una fava):

if Select_Mode = 0 then
TMR0L = Div1
Max_Count = 1
else
TMR0L = 255
if In_Dir = 0 then
Count_Impulse = Count_Impulse + 1
if Count_Impulse > Div_Totale then
Count_Impulse = 1
Max_Count = 1
end if
end if
if In_Dir = 1 then
Count_Impulse = Count_Impulse - 1
if Count_Impulse < 1 then
Count_Impulse = Div_Totale
Max_Count = 1
end if
end if
end if
if Max_Count = 1 then
Max_Count = 0
Step_Out = 0
if Select_Mode = 0 then
Somma = Somma + Div2
if Somma >= 10000 then
Somma = Somma - 10000
Div_Totale = Div1 + 1
else
Div_Totale = Div1
end if
end if
Step_Out = 1
end if
TMR0IF_bit = 0

Non ci sono i commenti ma dovrebbe essere abbastanza chiaro.
In funzione del menu in cui mi trovo, avanzamento o filettatura gestisco il timer i due modi diversi.
In rosso la parte di codice che si occupa di eseguire la divisione frazionaria.

Almeno le variabili peró.....
count_impulse ?
step_out?
div2 da dove arriva?

L'impulso di step come lo generi? come garantisci che stia alto per il tempo giusto senza impegnare il codice in attese?

Hai ragione Max, ma avevo sonno...., ti rispondo:

Div1 é il valore di divisione a sinistra della virgola, Div2 il valore a destra, sono contenuti in una tabella.
Count_Impulse invece l'ha utilizzo per contare gli impulsi. Lo step.... Affrontiamo un problema alla volta.
Possiamo ora stabilire che l'uso del timer non è matematicamente impossibile?

Scusa Massimo ma per decifrare quel codice ci vuole tempo ed in alcuni casi anche fantasia visto che non vedo nemmeno dove sta il ciclo e come gira e, soprattutto, alcune variabili vengono modificate all'esterno di questo spezzone e non posso sapere come.

La prima cosa strana che vedo é che parti con un "if Select_mode = 0" e questo if termina con il suo "else" alla fine dello spezzone di codice. Ma all'interno di questo else tu riproponi la stessa condizione che per dove é messa non potrá mai essere vera.... A meno che il select_mode non venga modificato all'interno di una routine di interrupt ma anche in quel caso non ha molto senso che venga gestito così.

Non ti devi scusare, capire il lavoro degli altri non è mai facile, soprattutto quando scritto in maniera non professionale, a scuola ho avuto un bravo insegnante di elettronica digitale, ma l'ho Z80 l'ho abbiamo appena accennato, non riesco a scriverlo come vorrei, automaticamente quando invio il post mi vengono tolti gli spazi, proviamo cosi, ora gli if e end if sono allineati correttamente:

Inizio Subroutine di interrupt

if Select_Mode = 0 then
*TMR0L = Div1
**Max_Count = 1
*else
****TMR0L = 255
*****if In_Dir = 0 then
******Count_Impulse = Count_Impulse + 1
*******if Count_Impulse > Div_Totale then
********Count_Impulse = 1
********Max_Count = 1
*******end if
*****end if
*****if In_Dir = 1 then
******Count_Impulse = Count_Impulse - 1
*******if Count_Impulse < 1 then
********Count_Impulse = Div_Totale
********Max_Count = 1
*******end if
*****end if
end if
if Max_Count = 1 then
*Max_Count = 0
**Step_Out = 0
***if Select_Mode = 1 then
****Somma = Somma + Div2
*****if Somma >= 10000 then
******Somma = Somma - 10000
*******Div_Totale = Div1 + 1
******else
*******Div_Totale = Div1
*****end if
***end if
****Step_Out = 1
end if
TMR0IF_bit = 0

Fine Subroutine di interrupt

Il valore di Select_Mode viene deciso all'interno della routine principale è può avere, valore 0 se sono in menu avanzamento e 1 se in menu filettatura, quindi quando non mi serve avere il sincronismo perfetto carico nel timer il valore di divisione a destra della virgola div1, (div2 non viene conteggiato, non serve negli avanzamenti), altrimenti carico valore 255 cosi da avere la possibilità di contare ogni singolo impulso. Quindi quando si inverte il senso di rotazione, monitorando In_Dir (uscita del Flip Flop) ho la possibilità di decrementare la mia variabile, esattamente come fai tu con gli indici. Cosa che già facevo quando devo memorizzare la posizione angolare. Quindi l'ho solo applicata al conteggio degli impulsi.

Div1 e Div2 nel rispettivi menu vengono aggiornate quando si passa da un passo ad un'altro.

Quindi riassumendo:

Se sono nel menu avanzamento carico nel Timer il valore di Div1, altrimenti carico valore 255 e conteggio ogni singolo impulso, e il valore della variabile Count_Impulse viene incrementato o decrementato a seconda del senso di rotazione del mandrino, se il valore di Count_Impulse e uguale al valore di divisione, Max_Count varrà 1 e sarà generato un'impulso di step.