Come far ripetere un intero codice per tot volte?

Come dal titolo è possibile far ripetere un intero codice per un numero di volte prestabilite?

Per esempio da questo codice faccio fare una foto e faccio muovere un motore il tempo di movimento del motore ed il tempo di fotografia è programmabile ma non posso decidere per esempio fammi il ciclo 100 volte poi fermati.

int shutter_on = 200; //tempo di pressione per attivare la cam, da settare intorno i 100 e 300
int shutter_off = 500; // tempo di attesa prima di attivare il motorino

int wakeup = 500; //Tempo fuoco acceso
int wakewait =200; //time between wake and shutter

int outpin = 13; //uscita per lo scatto
int wakepin = 12; //uscita per la messa a fuoco

// init motorino
int DIR_PIN_M1 =7;
int STEP_PIN_M1 =5;
int SLEEP = 6;      // PIN 12 = SLP
int DIR_PIN_M2 =2;
int STEP_PIN_M2 =3;

int delayTime = 500;

void setup() {
// init dei pin per lo scatto
pinMode(outpin, OUTPUT); //outpin gives output
pinMode(wakepin, OUTPUT); //wakepin gives output

// Tempo scatto Otturatore
shutter_on = 15000;

// init dei pin per il motorino
pinMode(DIR_PIN_M1, OUTPUT);
pinMode(STEP_PIN_M1, OUTPUT);
pinMode(SLEEP, OUTPUT); // set pin 12 to output
pinMode(DIR_PIN_M2, OUTPUT);
pinMode(STEP_PIN_M2, OUTPUT);

}

/////////// Loop ////////////

void loop(){


  
digitalWrite(wakepin, HIGH); //turn wakeup/focus on
delay(wakeup); //keep focus
digitalWrite(wakepin, LOW); //turn wakeup off
delay(wakewait); //wait
digitalWrite(outpin, HIGH); //press the shutter
delay(shutter_on); //wait the shutter release time
digitalWrite(outpin, LOW); //release shutter
delay(shutter_off); //wait for next round


 

  //rotate a specific number of microsteps (8 microsteps per step)
  //Avanti a 200 step 
  digitalWrite(SLEEP, HIGH);              // Sveglia il motore.

  rotate_M1(4000, 0.5);
 
  digitalWrite(SLEEP, LOW);                 // Spegne il motore
  delay(2000);

}



void rotate_M1(int steps, float speed){
  //rotate a specific number of microsteps (8 microsteps per step) - (negitive for reverse movement)
  //speed is any number from .01 -> 1 with 1 being fastest - Slower is stronger
  int dir = (steps > 0)? HIGH:LOW;
  steps = abs(steps);

  digitalWrite(DIR_PIN_M1,dir); 
  

  float usDelay = (1/speed) * 70;

  for(int i=0; i < steps; i++){
    digitalWrite(STEP_PIN_M1, HIGH);
    delayMicroseconds(usDelay); 

    digitalWrite(STEP_PIN_M1, LOW);
    delayMicroseconds(usDelay);
}



}

La cosa piu’ banale e’ mettere un while e all’interno piazzarci una variabile che si aggiorna .

Ad esempio nel setup scrivi i=0;
e nel loop() scrivi

while(i<=100){....
.....TUO CODICE....
........
i=i++ // Oppure i=i+1 che e' lo stesso
}

Penso che possa gia’ funzionare cosi’!!!

Ciao,
Fab.

penso che si possa fare con
void loop ()
{
for(int i=0; i<100;i++)
{
codice;
}
break;
}

Bisogna precisare una cosa: - il ciclo deve essere ripetuto per un certo numero di volte e poi MAI più oppure il numero di ripetizioni deve poter essere gestibile dall'utente?

Nel primo caso, si mette la funzione in setup() e poi si lascia loop() vuoto. Arduino esegue il codice contenuto in setup() solo una volta, all'accensione, e poi esegue loop() all'infinito. Nel secondo caso, va scritto il programma in modo che nel loop() si interagisca con l'utente per chiedere il numero di ripetizioni, e poi si esegua il ciclo tot volte. Ciclo che può essere separato dal ciclo loop() inserendolo in una routine esterna richiamata da loop() all'occorrenza.

LucaGilardi:
penso che si possa fare con
void loop ()
{
for(int i=0; i<100;i++)
{
codice;
}
break;
}

Mai visto un “BREAK” dentro la funzione loop().

Penso che marcotroi abbia definito in qualche modo quante volte deve essere eseguito il codice. Gli mancava capire come farlo.

Risposta riassuntiva:
Si puó fare con qualsiasi comando che faccia dei cicli.
percui con for, while, do while o semplicemente con una variabile e un if.
Ciao Uwe

@f.schiano
mi da errore Prova_ripetizione:2: error: expected unqualified-id before ‘while’

while(i<=100){


int shutter_on = 200; //tempo di pressione per attivare la cam, da settare intorno i 100 e 300
int shutter_off = 500; // tempo di attesa prima di attivare il motorino

int wakeup = 500; //Tempo fuoco acceso
int wakewait =200; //time between wake and shutter

int outpin = 13; //uscita per lo scatto
int wakepin = 12; //uscita per la messa a fuoco

// init motorino
int DIR_PIN_M1 =7;
int STEP_PIN_M1 =5;
int SLEEP = 6;      // PIN 12 = SLP
int DIR_PIN_M2 =2;
int STEP_PIN_M2 =3;

int delayTime = 500;


  
void setup(i=0) {
// init dei pin per lo scatto
pinMode(outpin, OUTPUT); //outpin gives output
pinMode(wakepin, OUTPUT); //wakepin gives output

// Tempo scatto Otturatore
shutter_on = 25000;

// init dei pin per il motorino
pinMode(DIR_PIN_M1, OUTPUT);
pinMode(STEP_PIN_M1, OUTPUT);
pinMode(SLEEP, OUTPUT); // set pin 12 to output
pinMode(DIR_PIN_M2, OUTPUT);
pinMode(STEP_PIN_M2, OUTPUT);

}

/////////// Loop ////////////

void loop(){


  
digitalWrite(wakepin, HIGH); //turn wakeup/focus on
delay(wakeup); //keep focus
digitalWrite(wakepin, LOW); //turn wakeup off
delay(wakewait); //wait
digitalWrite(outpin, HIGH); //press the shutter
delay(shutter_on); //wait the shutter release time
digitalWrite(outpin, LOW); //release shutter
delay(shutter_off); //wait for next round


 

  //rotate a specific number of microsteps (8 microsteps per step)
  //Avanti a 200 step 
  digitalWrite(SLEEP, HIGH);              // Sveglia il motore.

  rotate_M1(4000, 0.5);
 
  digitalWrite(SLEEP, LOW);                 // Spegne il motore
  delay(2000);

}



void rotate_M1(int steps, float speed){
  //rotate a specific number of microsteps (8 microsteps per step) - (negitive for reverse movement)
  //speed is any number from .01 -> 1 with 1 being fastest - Slower is stronger
  int dir = (steps > 0)? HIGH:LOW;
  steps = abs(steps);

  digitalWrite(DIR_PIN_M1,dir); 
  

  float usDelay = (1/speed) * 70;

  for(int i=0; i < steps; i++){
    digitalWrite(STEP_PIN_M1, HIGH);
    delayMicroseconds(usDelay); 

    digitalWrite(STEP_PIN_M1, LOW);
    delayMicroseconds(usDelay);
}

i=i+1 // Oppure i=i+1 che e' lo stesso

}

}

Secondo tentativo se ho capito bene come hai descritto il codice mi da questi errori
Prova_ripetizione2:64: error: expected ;' before '}' token Prova_ripetizione2:68: error: a function-definition is not allowed here before '{' token Prova_ripetizione2:106: error: expected }’ at end of input

int shutter_on = 200; //tempo di pressione per attivare la cam, da settare intorno i 100 e 300
int shutter_off = 1500; // tempo di attesa prima di attivare il motorino

int wakeup = 1000; //Tempo fuoco acceso
int wakewait =200; //time between wake and shutter

int outpin = 13; //uscita per lo scatto
int wakepin = 12; //uscita per la messa a fuoco

// init motorino
int DIR_PIN_M1 =7;
int STEP_PIN_M1 =5;
int SLEEP = 6;      // PIN 12 = SLP
int DIR_PIN_M2 =2;
int STEP_PIN_M2 =3;

int delayTime = 500;

void setup(i=0;) {
// init dei pin per lo scatto
pinMode(outpin, OUTPUT); //outpin gives output
pinMode(wakepin, OUTPUT); //wakepin gives output

// Tempo scatto Otturatore
shutter_on = 4000;

// init dei pin per il motorino
pinMode(DIR_PIN_M1, OUTPUT);
pinMode(STEP_PIN_M1, OUTPUT);
pinMode(SLEEP, OUTPUT); // set pin 12 to output
pinMode(DIR_PIN_M2, OUTPUT);
pinMode(STEP_PIN_M2, OUTPUT);

}

/////////// Loop ////////////

void loop(){

  while(i<=100){

  
digitalWrite(wakepin, HIGH); //turn wakeup/focus on
delay(wakeup); //keep focus
digitalWrite(wakepin, LOW); //turn wakeup off
delay(wakewait); //wait
digitalWrite(outpin, HIGH); //press the shutter
delay(shutter_on); //wait the shutter release time
digitalWrite(outpin, LOW); //release shutter
delay(shutter_off); //wait for next round


 

  //rotate a specific number of microsteps (8 microsteps per step)
  //Avanti a 200 step 
  digitalWrite(SLEEP, HIGH);              // Sveglia il motore.

  rotate_M1(4000, 0.5);
  rotate_M2(4000, 0.5);
 
  digitalWrite(SLEEP, LOW);                 // Spegne il motore
  delay(2000);
i=i++ // Oppure i=i+1 che e' lo stesso
}



void rotate_M1(int steps, float speed){
  //rotate a specific number of microsteps (8 microsteps per step) - (negitive for reverse movement)
  //speed is any number from .01 -> 1 with 1 being fastest - Slower is stronger
  int dir = (steps > 0)? HIGH:LOW;
  steps = abs(steps);

  digitalWrite(DIR_PIN_M1,dir); 
  

  float usDelay = (1/speed) * 70;

  for(int i=0; i < steps; i++){
    digitalWrite(STEP_PIN_M1, HIGH);
    delayMicroseconds(usDelay); 

    digitalWrite(STEP_PIN_M1, LOW);
    delayMicroseconds(usDelay);
}
}
void rotate_M2(int steps, float speed){
  //rotate a specific number of microsteps (8 microsteps per step) - (negitive for reverse movement)
  //speed is any number from .01 -> 1 with 1 being fastest - Slower is stronger
  int dir = (steps > 0)? HIGH:LOW;
  steps = abs(steps);

  digitalWrite(DIR_PIN_M2,dir); 
  

  float usDelay = (1/speed) * 70;

  for(int i=0; i < steps; i++){
    digitalWrite(STEP_PIN_M2, HIGH);
    delayMicroseconds(usDelay); 

    digitalWrite(STEP_PIN_M2, LOW);
    delayMicroseconds(usDelay);
}

}

@LucaGilardi sempre se ho interpretato bene dove mettere il tuo codice mi da il seguente errore:
Prova_ripetizione2:74: error: a function-definition is not allowed here before ‘{’ token
Prova_ripetizione2:116: error: expected }' at end of input Prova_ripetizione2:116: error: expected }’ at end of input

void loop ()
{
for(int i=0; i<100;i++)
{


int shutter_on = 200; //tempo di pressione per attivare la cam, da settare intorno i 100 e 300
int shutter_off = 1500; // tempo di attesa prima di attivare il motorino

int wakeup = 1000; //Tempo fuoco acceso
int wakewait =200; //time between wake and shutter

int outpin = 13; //uscita per lo scatto
int wakepin = 12; //uscita per la messa a fuoco

// init motorino
int DIR_PIN_M1 =7;
int STEP_PIN_M1 =5;
int SLEEP = 6;      // PIN 12 = SLP
int DIR_PIN_M2 =2;
int STEP_PIN_M2 =3;

int delayTime = 500;

void setup() {
// init dei pin per lo scatto
pinMode(outpin, OUTPUT); //outpin gives output
pinMode(wakepin, OUTPUT); //wakepin gives output

// Tempo scatto Otturatore
shutter_on = 4000;

// init dei pin per il motorino
pinMode(DIR_PIN_M1, OUTPUT);
pinMode(STEP_PIN_M1, OUTPUT);
pinMode(SLEEP, OUTPUT); // set pin 12 to output
pinMode(DIR_PIN_M2, OUTPUT);
pinMode(STEP_PIN_M2, OUTPUT);

}

/////////// Loop ////////////

void loop(){

 

  
digitalWrite(wakepin, HIGH); //turn wakeup/focus on
delay(wakeup); //keep focus
digitalWrite(wakepin, LOW); //turn wakeup off
delay(wakewait); //wait
digitalWrite(outpin, HIGH); //press the shutter
delay(shutter_on); //wait the shutter release time
digitalWrite(outpin, LOW); //release shutter
delay(shutter_off); //wait for next round


 

  //rotate a specific number of microsteps (8 microsteps per step)
  //Avanti a 200 step 
  digitalWrite(SLEEP, HIGH);              // Sveglia il motore.

  rotate_M1(4000, 0.5);
  rotate_M2(4000, 0.5);
 
  digitalWrite(SLEEP, LOW);                 // Spegne il motore
  delay(2000);

}



void rotate_M1(int steps, float speed){
  //rotate a specific number of microsteps (8 microsteps per step) - (negitive for reverse movement)
  //speed is any number from .01 -> 1 with 1 being fastest - Slower is stronger
  int dir = (steps > 0)? HIGH:LOW;
  steps = abs(steps);

  digitalWrite(DIR_PIN_M1,dir); 
  

  float usDelay = (1/speed) * 70;

  for(int i=0; i < steps; i++){
    digitalWrite(STEP_PIN_M1, HIGH);
    delayMicroseconds(usDelay); 

    digitalWrite(STEP_PIN_M1, LOW);
    delayMicroseconds(usDelay);
}
}
void rotate_M2(int steps, float speed){
  //rotate a specific number of microsteps (8 microsteps per step) - (negitive for reverse movement)
  //speed is any number from .01 -> 1 with 1 being fastest - Slower is stronger
  int dir = (steps > 0)? HIGH:LOW;
  steps = abs(steps);

  digitalWrite(DIR_PIN_M2,dir); 
  

  float usDelay = (1/speed) * 70;

  for(int i=0; i < steps; i++){
    digitalWrite(STEP_PIN_M2, HIGH);
    delayMicroseconds(usDelay); 

    digitalWrite(STEP_PIN_M2, LOW);
    delayMicroseconds(usDelay);
}

}
break;
}

}

@leo72
Si il numero devo gestirlo io inserendo per esempio 150 nel codice facendo interpretare ad arduino che mi deve fare tutti i compiti del codice per 150 poi si ferma.

@uwefed
esatto hai capito perfettamente quello che devo fare solo che non so come scriverlo! ]:slight_smile:

A cosa serve la variabile in void setup(i=0) {

Nel primo sketch : non puoi mettere un while(i<=100){ al inizio fuori dal setup() o dal loop().

Nel secondo sketch manca un “;” nella riga

i=i++ // Oppure i=i+1 che e' lo stesso

Come l’ hai scritto Ti ripete tutto il codice del loop() 100 vole e poi di nuovo perché il loop viene ripetuto in eterno.

Il terzo sketch ti da piú errori non solo quelli che hai indicato:

sketch_nov21a.cpp: In function ‘void loop()’:
sketch_nov21a:24: error: a function-definition is not allowed here before ‘{’ token
sketch_nov21a:43: error: a function-definition is not allowed here before ‘{’ token
sketch_nov21a:74: error: a function-definition is not allowed here before ‘{’ token
sketch_nov21a:116: error: expected }' at end of input sketch_nov21a:116: error: expected }’ at end of input

La causa é perché hai messo 2 volte la funzione loop()
Non puoi mettere un loop e dentro setup() e un secondo loop()

Ti mancano le basi. Incomincia a vedere un tutorial e impara la programmazione.

Ciao Uwe

Ciao Uwe :slight_smile:
dove posso vedere un tutorial per imparare la programmazione?

Ho provato a modificare come mi hai suggerito ,il codice non da errore ma devo verificarlo fisicamente con i motori e macchina fotografica.

int shutter_on = 200; //tempo di pressione per attivare la cam, da settare intorno i 100 e 300
int shutter_off = 1500; // tempo di attesa prima di attivare il motorino

int wakeup = 1000; //Tempo fuoco acceso
int wakewait =200; //time between wake and shutter

int outpin = 13; //uscita per lo scatto
int wakepin = 12; //uscita per la messa a fuoco

// init motorino
int DIR_PIN_M1 =7;
int STEP_PIN_M1 =5;
int SLEEP = 6;      // PIN 12 = SLP
int DIR_PIN_M2 =2;
int STEP_PIN_M2 =3;

int delayTime = 500;

void setup() {
// init dei pin per lo scatto
pinMode(outpin, OUTPUT); //outpin gives output
pinMode(wakepin, OUTPUT); //wakepin gives output

// Tempo scatto Otturatore
shutter_on = 4000;

// init dei pin per il motorino
pinMode(DIR_PIN_M1, OUTPUT);
pinMode(STEP_PIN_M1, OUTPUT);
pinMode(SLEEP, OUTPUT); // set pin 12 to output
pinMode(DIR_PIN_M2, OUTPUT);
pinMode(STEP_PIN_M2, OUTPUT);

}

/////////// Loop ////////////

void loop(){

for(int i=0; i<100;i++)


  
digitalWrite(wakepin, HIGH); //turn wakeup/focus on
delay(wakeup); //keep focus
digitalWrite(wakepin, LOW); //turn wakeup off
delay(wakewait); //wait
digitalWrite(outpin, HIGH); //press the shutter
delay(shutter_on); //wait the shutter release time
digitalWrite(outpin, LOW); //release shutter
delay(shutter_off); //wait for next round


 

  //rotate a specific number of microsteps (8 microsteps per step)
  //Avanti a 200 step 
  digitalWrite(SLEEP, HIGH);              // Sveglia il motore.

  rotate_M1(4000, 0.5);
  rotate_M2(4000, 0.5);
 
  digitalWrite(SLEEP, LOW);                 // Spegne il motore
  delay(2000);

}



void rotate_M1(int steps, float speed){
  //rotate a specific number of microsteps (8 microsteps per step) - (negitive for reverse movement)
  //speed is any number from .01 -> 1 with 1 being fastest - Slower is stronger
  int dir = (steps > 0)? HIGH:LOW;
  steps = abs(steps);

  digitalWrite(DIR_PIN_M1,dir); 
  

  float usDelay = (1/speed) * 70;

  for(int i=0; i < steps; i++){
    digitalWrite(STEP_PIN_M1, HIGH);
    delayMicroseconds(usDelay); 

    digitalWrite(STEP_PIN_M1, LOW);
    delayMicroseconds(usDelay);
}
}
void rotate_M2(int steps, float speed){
  //rotate a specific number of microsteps (8 microsteps per step) - (negitive for reverse movement)
  //speed is any number from .01 -> 1 with 1 being fastest - Slower is stronger
  int dir = (steps > 0)? HIGH:LOW;
  steps = abs(steps);

  digitalWrite(DIR_PIN_M2,dir); 
  

  float usDelay = (1/speed) * 70;

  for(int i=0; i < steps; i++){
    digitalWrite(STEP_PIN_M2, HIGH);
    delayMicroseconds(usDelay); 

    digitalWrite(STEP_PIN_M2, LOW);
    delayMicroseconds(usDelay);
}

}

ciao, allora...hai messo due funzioni loop...cosa che non ha senso...non possono esistere insieme, poi una l'avresti messa all'interno del setup, ancora senza molto senso. poi a occhio così mi sembra che tu ti sia dimenticato qualche parentesi...

@uwefed un break così non si è mai visto, ma in teoria dovrebbe funzionare no? secondo logica, finito il loop arduino non dovrebbe fare più nulla, o sbaglio?

Il break in quel modo ha logica in un programma per computer dove, una volta terminata l'esecuzione, il controllo torna al terminale. Ma in uno sketch Arduino non ha nessun senso perché il loop() è incapsulato all'interno di un classico main() di un programma C eseguito all'infinito. Semplificando, la struttura di esecuzione di uno sketch Arduino si può convertire nel seguente codice C:

main() {
  setup();
  while (true) {
    loop();
  }
}

setup() {
 ...
}

loop() {
 ...
}

Quindi, generalmente si usa inserire un ciclo da eseguire solo 1 o un numero limitato di volte direttamente nel setup(), mentre si usa inserire un ciclo da eseguire all'infinito nel loop(). Se non c'è nulla da eseguire all'infinito, si lascia la routine loop() vuota.

comunque il loop infinito viene fatto con for( ; ; ) { loop() } Facendo un break esci dal for e finisci nel niente, infinito, inesistente o non cosa. Ciao Uwe

[EDIT] Gli smiley mi hanno fregato; aggiungendo qualche spazio va meglio)[/EDIT]

@marcotroi

void loop(){
for(int i=0; i<100;i++)  
digitalWrite(wakepin, HIGH); //turn wakeup/focus on
delay(wakeup); //keep focus
...

senza parentesi graffe e codice incluso fa proprio niente (per la precisione fa esegire la riga sucessiva 100 volte).
Ciao Uwe

uwefed: comunque il loop infinito viene fatto con for(;;){loop()}

Non mi ricordavo di preciso.

Facendo un break esci dal for e finisci nel niente, infinito, inesistente o non cosa.

E' quello che ho detto anch'io. In un micro "uscire" dal codice è impraticabile dato che non puoi passare il controllo a nulla e sei in un ciclo infinito.

ah ok, allora io ragiono nella concezione del PC, ma non funziona allo stesso modo anche arduino. è una buona cosa da sapere, così evito di scapparci di testa in futuro :)

Scusate ragazzi io ci sto mettendo del mio meglio e sto cominciando a studiarmi sia il C++ sia il codice di arduino ma mi viene difficile applicare i vostri suggerimenti sopratutto perchè ho poca esperienza e pratica.
Ora non è che voglio la pappa pronta ma non è che qualche samaritano mi farebbe il piacere di farmi una prova per far ripetere un numero di volte da decidere questo mio intero codice?

Sto diventando pazzo! =(

Il codice è questo :drooling_face:

int shutter_on = 200; //tempo di pressione per attivare la cam, da settare intorno i 100 e 300
int shutter_off = 1500; // tempo di attesa prima di attivare il motorino

int wakeup = 5000; //Tempo fuoco acceso
int wakewait =200; //time between wake and shutter

int outpin = 13; //uscita per lo scatto
int wakepin = 12; //uscita per la messa a fuoco

// init motorino
int DIR_PIN_M1 =7;
int STEP_PIN_M1 =5;
int SLEEP = 6;      // PIN 12 = SLP
int DIR_PIN_M2 =2;
int STEP_PIN_M2 =3;

int delayTime = 500;

void setup() {
// init dei pin per lo scatto
pinMode(outpin, OUTPUT); //outpin gives output
pinMode(wakepin, OUTPUT); //wakepin gives output

// Tempo scatto Otturatore
shutter_on = 200;

// init dei pin per il motorino
pinMode(DIR_PIN_M1, OUTPUT);
pinMode(STEP_PIN_M1, OUTPUT);
pinMode(SLEEP, OUTPUT); // set pin 12 to output
pinMode(DIR_PIN_M2, OUTPUT);
pinMode(STEP_PIN_M2, OUTPUT);

}

/////////// Loop ////////////

void loop(){


  
digitalWrite(wakepin, HIGH); //turn wakeup/focus on
delay(wakeup); //keep focus
digitalWrite(wakepin, LOW); //turn wakeup off
delay(wakewait); //wait
digitalWrite(outpin, HIGH); //press the shutter
delay(shutter_on); //wait the shutter release time
digitalWrite(outpin, LOW); //release shutter
delay(shutter_off); //wait for next round


 

  //rotate a specific number of microsteps (8 microsteps per step)
  //Avanti a 200 step 
  digitalWrite(SLEEP, HIGH);              // Sveglia il motore.

  rotate_M1(4000, 1);

 
  digitalWrite(SLEEP, LOW);                 // Spegne il motore
  delay(2000);

}



void rotate_M1(int steps, float speed){
  //rotate a specific number of microsteps (8 microsteps per step) - (negitive for reverse movement)
  //speed is any number from .01 -> 1 with 1 being fastest - Slower is stronger
  int dir = (steps > 0)? HIGH:LOW;
  steps = abs(steps);

  digitalWrite(DIR_PIN_M1,dir); 
  

  float usDelay = (1/speed) * 70;

  for(int i=0; i < steps; i++){
    digitalWrite(STEP_PIN_M1, HIGH);
    delayMicroseconds(usDelay); 

    digitalWrite(STEP_PIN_M1, LOW);
    delayMicroseconds(usDelay);
}



}

io metterei tutto il codice da ripetere dentro un for…

cosi

for(int i = 0; i < 5; i++){
codice
}

cosi lo ripete 5 volte cambiando il 5 con una variabile da te scelta lo esegui le volte che vuoi

dopo di che esce da solo dal codice

Non Funsia =(

Mi da questo errore:

Scatto_Movimento_con_2_motori_B:0: error: expected unqualified-id before ‘for’
Scatto_Movimento_con_2_motori_B:0: error: expected constructor, destructor, or type conversion before ‘<’ token
Scatto_Movimento_con_2_motori_B:0: error: expected constructor, destructor, or type conversion before ‘++’ token

for(int i = 0; i < 5; i++){

int shutter_on = 200; //tempo di pressione per attivare la cam, da settare intorno i 100 e 300
int shutter_off = 1500; // tempo di attesa prima di attivare il motorino

int wakeup = 1000; //Tempo fuoco acceso
int wakewait =200; //time between wake and shutter

int outpin = 13; //uscita per lo scatto
int wakepin = 12; //uscita per la messa a fuoco

// init motorino
int DIR_PIN_M1 =7;
int STEP_PIN_M1 =5;
int SLEEP = 6;      // PIN 12 = SLP
int DIR_PIN_M2 =3;
int STEP_PIN_M2 =2;

int delayTime = 500;

void setup() {
// init dei pin per lo scatto
pinMode(outpin, OUTPUT); //outpin gives output
pinMode(wakepin, OUTPUT); //wakepin gives output

// Tempo scatto Otturatore
shutter_on = 4000;

// init dei pin per il motorino
pinMode(DIR_PIN_M1, OUTPUT);
pinMode(STEP_PIN_M1, OUTPUT);
pinMode(SLEEP, OUTPUT); // set pin 12 to output
pinMode(DIR_PIN_M2, OUTPUT);
pinMode(STEP_PIN_M2, OUTPUT);

}

/////////// Loop ////////////

void loop(){


  
digitalWrite(wakepin, HIGH); //turn wakeup/focus on
delay(wakeup); //keep focus
digitalWrite(wakepin, LOW); //turn wakeup off
delay(wakewait); //wait
digitalWrite(outpin, HIGH); //press the shutter
delay(shutter_on); //wait the shutter release time
digitalWrite(outpin, LOW); //release shutter
delay(shutter_off); //wait for next round


 

  //rotate a specific number of microsteps (8 microsteps per step)
  //Avanti a 200 step 
  digitalWrite(SLEEP, HIGH);              // Sveglia il motore.
rotate_M2(4000, 0.5);
  rotate_M1(4000, 1);
  
 
  digitalWrite(SLEEP, LOW);                 // Spegne il motore
  delay(2000);

}



void rotate_M1(int steps, float speed){
  //rotate a specific number of microsteps (8 microsteps per step) - (negitive for reverse movement)
  //speed is any number from .01 -> 1 with 1 being fastest - Slower is stronger
  int dir = (steps > 0)? HIGH:LOW;
  steps = abs(steps);

  digitalWrite(DIR_PIN_M1,dir); 
  

  float usDelay = (1/speed) * 70;

  for(int i=0; i < steps; i++){
    digitalWrite(STEP_PIN_M1, HIGH);
    delayMicroseconds(usDelay); 

    digitalWrite(STEP_PIN_M1, LOW);
    delayMicroseconds(usDelay);
}
}
void rotate_M2(int steps, float speed){
  //rotate a specific number of microsteps (8 microsteps per step) - (negitive for reverse movement)
  //speed is any number from .01 -> 1 with 1 being fastest - Slower is stronger
  int dir = (steps > 0)? HIGH:LOW;
  steps = abs(steps);

  digitalWrite(DIR_PIN_M2,dir); 
  

  float usDelay = (1/speed) * 70;

  for(int i=0; i < steps; i++){
    digitalWrite(STEP_PIN_M2, HIGH);
    delayMicroseconds(usDelay); 

    digitalWrite(STEP_PIN_M2, LOW);
    delayMicroseconds(usDelay);
}

}

}

Mi fai il favore di imparare a programmare il C? Per esempio con questo: http://arduino.cc/en/Tutorial/HomePage o con qualsiasi libro di Arduino per principianti. Ciao Uwe

Un programma su arduino funziona così:
la funzione setup() viene eseguita una sola volta (prima della funzione loop)
la funzione loop() viene automaticamente ripetuta “all’infinito”

quindi se vuoi ripetere del codice per X volte ( e non X * Numero di loop)
devi mettere il tuo codice all’interno della setup e usare un ciclo for:

//ipotizzo che il numero di volte provenga da qualche altra variabile

Int altravariabile;

for (int i=0;i<altravariabile;i++ )
{
//Tuo codice da ripetere
}

però… facendo un for, questo verrà eseguito infinite volte nel loop, perche una volta che i =5 interrompe, ma il loop riesegue il for daccapo … quindi andrebbe messa una flag

quindi dovrebbe essere

int numeroRipetizioni = 5
int n = 0

while (n < numeroRipetizioni){
codice
return n++;
}

cosi, se n >= di 5 non esegue il codice, mi suona un po strano, e sicuramente sbaglio… correggetemi