[C/C++] Stratagemmi nel ciclo

[neryo]

Ciao a tutti,
sto realizzando un software per pilotare un motore passo-passo interfacciandomi tramite una scheda national (ni-usb 2008). Questo motore avanza di 1,8/50 gradi ad ogni step che vengono fatti dandogli in input sequenze logiche in esadecimale.

Ma arriviamo al problema.. questo viene fatto tramite un ciclo infinito che contiene le 4 sequenze di input e i controlli per la verifica del raggiungimento del target (break). Il mio problema è... supponendo che il motore sia in posizione di partenza... e inizi la procedura di avanzamento (loop) fermandosi a metà ciclo perchè ha raggiunto il punto di arrivo (gradi da raggiungere).. come si potrebbe fare, per fare in modo che al prossimo riavvio della funzione riparta dal punto sucessivo della sequenza logica all'interno del loop? Io ho pensato di utilizzare il goto e magari salvare lo stato su un file.. ma forse voi avete delle idee migliori...

Inoltre dovrei pensare a una procedura di inizializzazione del motore in modo da settarlo nella posizione di partenza.

[Michele Facchin]

Non ho capito se il quesito è troppo facile o è troppo difficile..ci fai un esempio?

[neryo]

Originariamente inviato da Michele Facchin
Non ho capito se il quesito è troppo facile o è troppo difficile..ci fai un esempio?

Diciamo che non è troppo difficile.. forse l'introduzione lo faceva sembrare chissà cosa..

Questo è il ciclo.. diciamo che il quesito è se a un certo numero di volte che eseguo questo ciclo mi fermo ad esempio al secondo step io devo memorizzarmi ad esempio in una variabile dove sono arrivato.. e la volta prossima che entro nel ciclo ripartire dallo stesso punto da dove mi sono fermato.. questo perchè altrimenti se parto dall'inizio il motore nelle prime sequenze rimmarrebbe fermo e introdurrebbe degli errori di gradi nella var current_degrees.. e questo non è bene! Avete qualche brillante idea? Io pensavo di introdurre dei goto.. ma ripeto che forse non è affatto la soluzione migliore!

 do{
		w_data[0] = 0xC;		//1100  primo step
		// DAQmxBaseWriteDigitalU8(taskHandle, numSampsPerChan, autoStart, timeout, dataLayout, writeArray, sampsPerChanWritten, Nothing)
		DAQmxErrChk (DAQmxBaseWriteDigitalU8(taskHandle,1,1,10.0,DAQmx_Val_GroupByChannel,w_data,&written,NULL));		
		
		
		current_degrees += step_value;
		//la funzione qui sopra fa uscire 1100 sui canali della scheda
		if (current_degrees >= degrees) break; //se siamo a posto usciamo

		Sleep(SLEEP_TIME); //mezzo sec di attesa

		w_data[0] = 0x6;		//0110  secondo step
		DAQmxErrChk (DAQmxBaseWriteDigitalU8(taskHandle,1,1,10.0,DAQmx_Val_GroupByChannel,w_data,&written,NULL));		
		//la funzione qui sopra fa uscire 0110 sui canali della scheda
		
		current_degrees += step_value;
		if (current_degrees >= degrees) break; //se siamo a posto usciamo

		Sleep(SLEEP_TIME); //mezzo sec di attesa

		w_data[0] = 0x3;		//0011  terzo step
		DAQmxErrChk (DAQmxBaseWriteDigitalU8(taskHandle,1,1,10.0,DAQmx_Val_GroupByChannel,w_data,&written,NULL));		
		//la funzione qui sopra fa uscire 0011 sui canali della scheda
		
		current_degrees += step_value;
		if (current_degrees >= degrees) break; //se siamo a posto usciamo

		Sleep(SLEEP_TIME); //mezzo sec di attesa

		w_data[0] = 0x9;		//1001  quarto step
		

		DAQmxErrChk (DAQmxBaseWriteDigitalU8(taskHandle,1,1,10.0,DAQmx_Val_GroupByChannel,w_data,&written,NULL));		
		//la funzione qui sopra fa uscire 1001 sui canali della scheda

		current_degrees += step_value;
		if (current_degrees >= degrees) break; //se siamo a posto usciamo
	
		Sleep(SLEEP_TIME);

	}while(1);

[Paulin]

Il tuo quesito è abbastanza chiaro:

Se ho capito bene hai un ciclo a 4 passi e dopo un arresto del ciclo vuoi riprendere la sucessiva esecuzione allo stesso passo (o a quello sucessivo?) in cui il cilclo è stato interrotto.

In assembler si potrebbero indicizzare i passi, ovvero applicando una label ad ogni passo e muovere ad ogni passo l'indice dell'etichetta in un registro del processore (due righe di codice = in tutto due ticks del processore su ogni passo), poi alla ripresa del processo si riprende il registro e si esegue un Jump a quella etichetta all'interno del ciclo.

Di C++ non ci capisco nulla (sto incominciato a studiarlo ora) ma penso che il "goto" potrebbe essere l'equivalente (magari con un po' di codice in più) di quel che ho descritto.


Ciao

[neryo]

si hai capito il problema.. devo riprendere al passo sucessivo di quello che era stato interrotto nel loop precedente. Io ho pensato che si puo fare con dei goto.. ma prima volevo avere nmagari qualche idea diversa..

[CheCk_OUTSIDE]

non importa che tu faccia 4 operazioni uguali nello stesso step del ciclo... semplicemente utilizzi un vettore con i 4 valori da passare a w_data[0] e poi utilizzi un indice azzerandolo ciclicamente ogni volta ke arriva a 4!

In questo modo simuli le quattro chiamate con una solo (servono a questo i cicli dopotutto).. e poi non hai il problema di reiniziare dal punto giusto.. basta ke ti ricordi l'ultimo indice utilizzato!!!

A presto... Ciao!!!!

[Michele Facchin]

Esatto fai come ti dice CheCk.

/* simple step for neryo */

#include <stdio.h>

int main (){
    int i = 0;
    char array[4] = {'0xC', '0x6', '0x3', '0x9'};
    while (!0^0) {
          if (i < 4) { 
                /* ... */
                printf ("Valore di di w_data[0] = %c", array[i++]);
                getchar();
                /* ... */
          } else i = 0;                             
    } 
    return (0);    
}

Ovviamente questo è uno spunto!
i è l'indice di dove sei arrivato..basta che non la modifichi e la dichiari fuori dal ciclo. :P
Se ci sono problemi rispondi pure.