Lug 03

Dolly Photo incrementa la velocità di impostazione

Le modifiche e implementazioni fatte al Dolly Photo e presentate in questo articolo si concludono con questo articolo in cui trovi come il Dolly Photo incrementa la velocità di impostazione.

dolly photo versione 2

L’esigenza che mi è stat esposta da chi ha provato il Dolly Photo versione 1.0 è stata quella di poter essere più veloce in fase di impostazione del progetto fotografico.

In pratica quando sei su un campo e vuoi iniziare una nuova sequenza di fotografie con il Dolly Photo versione 1.0  impostare i parametri di avvio risulta molto lento in quanto ogni pressione dei pulsanti LEFT e RIGHT incrementa di un solo valore il contatore su cui stai agendo.

Nella versione 2.0 ho modificato questa impostazione anche in funzione del fatto che i tempi sono definiti in millisecondi e non in secondi come nella precedente vesione, ottieni così che il Dolly Photo incrementa la velocità di impostazione.

Principio di funzionamento

Il principio è banale: incrementi di 10 unità ad ogni pressione del pulsante RIGHT e decrementi di 1 alla pressione del pulsante LEFT.

 

Se ti chiedi come mai RIGHT incrementa di 10 e LEFT decrementa di 1 la risposta è semplice: in questo modo sei certo di poter impostare tutti i valoro che desideri rapidamente.

Se ad esempio vuoi che il Dolly Photo incrementa la velocità di impostazione dell’intervallo tra i passi fino al valore 36 premerai quattro volte il pulsante RIGHT arrivando a 40 e quattro volte il pulsante LEFT indietreggiando a 36.

Sketch Dolly Photo incrementa la velocità di impostazione

Lo sketch che ti riporto presenta tutte le ultime funzioni descritte negli articoli precedenti ed aggiunge anche questa funzione:

/**********************************************************
 * Dolly Photo Arduino
 *
 * Data creazione 25 febbraio 2013
 * Ultima modifica 13 marzo 2013
 *
 * autore: Mauro Alfieri
 * web:    mauroalfieri.it
 * tw:     @mauroalfieri
 *
/**********************************************************/

#include <LiquidCrystal.h>

/**********************************************************/

#define MOTDTIME 2000
#define LCDTIME  3000
#define SETMODETIME 2000
#define TIMESCATTO 500
#define TIMEFASE 35
#define TARATURA 800
#define DEBUG

/**********************************************************/

#define SCATTO     2
#define PWMA       3
#define D4         4
#define D5         5
#define D6         6
#define D7         7
#define RS         8
#define EN         9
#define BACKLIGHT 10
#define PWMB      11
#define DIRA      12
#define DIRB      13
#define BUTTON    A0
#define SSTART    A1
#define SSTOP     A2

/**********************************************************/

char line0[16] = "Dolly Foto ver2";
char line1[16] = "mauroalfieri.it";

/**********************************************************/

int SELECT[]     =  {810,830};
int LEFT[]       =  {610,640};
int RIGTH[]      =  {0,20};
int UP[]         =  {190,210};
int DOWN[]       =  {390,420};

int buttonPress  = 0;
int nFase        = 0;
int scatto       = 0;
int passo        = 0;

/**********************************************************/

unsigned long timeToBlacklight  =  0;
unsigned long timeToSetMode     =  0;
unsigned long timeSetting       =  0;
unsigned long timeDelay         =  0;

/**********************************************************/

boolean blacklightStatus = false;

/**********************************************************/

byte symbolselect[8] = {B00001,B00011,B00111,B01111,B00111,B00011,B00001};
byte symbolplay[8]   = {B10000,B11000,B11100,B11110,B11100,B11000,B10000};
byte symbolstop[8]   = {B00000,B11111,B11111,B11111,B11111,B11111,B00000};
byte symbolpause[8]  = {B00000,B10001,B10001,B10001,B10001,B10001,B00000};

/**********************************************************/
char* principale[6]   =  {"Impostazioni","Verifica","Reset Carrello","Reset Auto","Avvio",""};
char* secondario[10]  =  {"Numero passi","per scatto","Intervallo tra","i passi","Tempo di ALT","prima","Tempo di ALT","dopo","Numero scatti","totali"};
char buffer[16];

/**********************************************************/

int passiXscatto      = 0;
int intervalloScatto  = 30;
int tempoAltPrima     = 0;
int tempoAltDopo      = 0;
int numeroScatti      = 0;

/**********************************************************/

LiquidCrystal lcd( RS,EN,D4,D5,D6,D7 );

/**********************************************************/

void setup() {

  #ifdef DEBUG
    Serial.begin( 9600 );
    Serial.println("Avvio");
  #endif

  /**********************************************************/

  pinMode( BACKLIGHT,OUTPUT );
  digitalWrite( BACKLIGHT,LOW );

  /**********************************************************/

  pinMode( SCATTO,OUTPUT );
  digitalWrite( SCATTO,LOW );

  /**********************************************************/

  #ifdef SSTART
    pinMode( SSTART,INPUT );
    digitalWrite( SSTART,LOW );
  #endif

  /**********************************************************/

  #ifdef SSTOP
    pinMode( SSTOP,INPUT );
    digitalWrite( SSTOP,LOW );
  #endif

  /**********************************************************/

  lcd.begin(16, 2);
  lcd.createChar(1, symbolselect);
  lcd.createChar(2, symbolplay);
  lcd.createChar(3, symbolstop);
  lcd.createChar(4, symbolpause);

  /**********************************************************/

  digitalWrite( BACKLIGHT,HIGH );
  lcd.setCursor(0,0);
  lcd.print(line0);
  lcd.setCursor(0,1);
  lcd.print(line1);
  delay( MOTDTIME );
  lcd.clear();
  lcdBlacklightOff();
}

/**********************************************************/

void loop() {

  /**********************************************************/

  #ifdef DEBUG
    Serial.print( " Button: " );           Serial.print( analogRead( BUTTON ) );
    Serial.print( " TimeToBlecklight " );  Serial.print( timeToBlacklight );
    Serial.print( " TimeToSetMode " );     Serial.println( timeToSetMode );
  #endif

  /**********************************************************/

  if ( ctrlButton( analogRead( BUTTON ) ) == 0 || ctrlButton( analogRead( BUTTON ) ) > 1 ) { timeToSetMode = millis(); }
  if (timeToSetMode > 0 && SETMODETIME < (millis() - timeToSetMode) ) { menuMode(); timeToSetMode = 0; }

  /**********************************************************/

  buttonPress = ctrlButton( analogRead( BUTTON ) );

  /**********************************************************/

  if (  (blacklightStatus) && LCDTIME < (millis() - timeToBlacklight) ) { lcdBlacklightOff(); lcd.clear(); }

  /**********************************************************/

  char line0[16] = " in attesa di  ";
  char line1[16] = "    comandi ...";

  /**********************************************************/

  lcd.setCursor(0,0);
  lcd.print(line0);
  lcd.setCursor(0,1);
  lcd.print(line1);

  /**********************************************************/
}

/**********************************************************/

int ctrlButton( int button ) {

  buttonPress = 0;
  if ( SELECT[0] <= button && button <= SELECT[1] )  { buttonPress = 1; }
  if ( LEFT[0] <= button && button <= LEFT[1] )      { buttonPress = 2; }
  if ( RIGTH[0] <= button && button <= RIGTH[1] )    { buttonPress = 3; }
  if ( UP[0] <= button && button <= UP[1] )          { buttonPress = 4; }
  if ( DOWN[0] <= button && button <= DOWN[1] )      { buttonPress = 5; }

  if (buttonPress > 0) {
    digitalWrite( BACKLIGHT,HIGH );
    blacklightStatus = true;
    timeToBlacklight = millis();
  }

  return buttonPress;
}

/**********************************************************/

void lcdBlacklightOff() {
  digitalWrite( BACKLIGHT,LOW );
  blacklightStatus = false;
  timeToBlacklight = 0;
}

/**********************************************************/

void lcdBlacklightOn() {
  digitalWrite( BACKLIGHT,HIGH );
  blacklightStatus = true;
  timeToBlacklight = millis();
}

/**********************************************************/

void menuMode() {

  /**********************************************************/

  #ifdef DEBUG
    Serial.println( "Menu Mode" );
  #endif

  /**********************************************************/

  boolean setMode  = true;
  int setModeLevel = 0;
  timeSetting      = 0;
  lcd.clear();

  /**********************************************************/

  delay( 1000 );

  /**********************************************************/ 

  while ( setMode ) {

    /**********************************************************/

    if ( ctrlButton( analogRead( BUTTON ) ) != 0 ) { timeSetting = millis(); }

    if ( (ctrlButton( analogRead( BUTTON )) == 5 ) && setModeLevel < 4 ) { lcd.clear(); setModeLevel++; }
    if ( (ctrlButton( analogRead( BUTTON )) == 4 ) && setModeLevel > 0 ) { lcd.clear(); setModeLevel--; }

    if ( (setModeLevel % 2) == 0 ) {
      lcd.setCursor(0,0);
      lcd.print( principale[setModeLevel] );
      lcd.setCursor(0,1);
      lcd.print( principale[(setModeLevel+1)] );  

      lcd.setCursor(15,0);
      lcd.write(1);
      lcd.setCursor(15,1);
      lcd.print(" ");
    } else {
      lcd.setCursor(0,0);
      lcd.print( principale[(setModeLevel-1)] );
      lcd.setCursor(0,1);
      lcd.print( principale[setModeLevel] );  

      lcd.setCursor(15,0);
      lcd.print(" ");
      lcd.setCursor(15,1);
      lcd.write(1);
    }

    if ( ctrlButton( analogRead( BUTTON )) == 1 ) {
      if ( setModeLevel == 0 ) { impostazioni(); }
      if ( setModeLevel == 1 ) { verifica();     }
      if ( setModeLevel == 2 ) { reset();        }
      if ( setModeLevel == 3 ) { autoreset();    }
      if ( setModeLevel == 4 ) { avvio();        }

      setMode = false;
      timeSetting = 0;
    }

    if (timeSetting > 0 && (SETMODETIME*2) < (millis() - timeSetting) ) { setMode = false; }
    delay(200);
  }

  /**********************************************************/

  lcd.clear();
}

/**********************************************************/

void impostazioni() {

  /**********************************************************/

  #ifdef DEBUG
    Serial.println( "Menu Impostazioni" );
  #endif

  /**********************************************************/

  lcd.clear();
  lcd.setCursor(0,0);
  lcd.print( "Menu " );
  lcd.setCursor(0,1);
  lcd.print( "Impostazioni" );    

  /**********************************************************/

  delay( SETMODETIME );

  /**********************************************************/

  boolean impostazioniMode  = true;
  int setModeLevel = 0;
  lcd.clear();

  /**********************************************************/

  while ( impostazioniMode ) {

    /**********************************************************/

    if ( (ctrlButton( analogRead( BUTTON )) == 5 ) && setModeLevel < 8 ) { lcd.clear(); setModeLevel = (setModeLevel+2); }
    if ( (ctrlButton( analogRead( BUTTON )) == 4 ) && setModeLevel > 0 ) { lcd.clear(); setModeLevel = (setModeLevel-2); }
    if (  ctrlButton( analogRead( BUTTON )) == 1 )                       { impostazioniMode = false; }

    /**********************************************************/

    #ifdef DEBUG
      Serial.print( "setMenuLevel: " );
      Serial.println( setModeLevel );
    #endif

    /**********************************************************/

    switch ( setModeLevel ) {

      case 0:
        if ( (ctrlButton( analogRead( BUTTON )) == 3 ) && passiXscatto <= 99999)  { passiXscatto += 10; lcd.clear(); }
        if ( (ctrlButton( analogRead( BUTTON )) == 2 ) && passiXscatto >= 1)      { passiXscatto -= 1; lcd.clear();  }

        sprintf(buffer, "%s %d", secondario[(setModeLevel+1)], passiXscatto);
      break;

      case 2:
        if ( (ctrlButton( analogRead( BUTTON )) == 3 ) && intervalloScatto <= 9999999)  { intervalloScatto += 10; lcd.clear();  }
        if ( (ctrlButton( analogRead( BUTTON )) == 2 ) && intervalloScatto >= 1)        { intervalloScatto -= 1; lcd.clear();  }

        sprintf(buffer, "%s %dms", secondario[(setModeLevel+1)], intervalloScatto);
      break;

      case 4:
        if ( (ctrlButton( analogRead( BUTTON )) == 3 ) && tempoAltPrima <= 9999999)  { tempoAltPrima += 10; lcd.clear();  }
        if ( (ctrlButton( analogRead( BUTTON )) == 2 ) && tempoAltPrima >= 1)        { tempoAltPrima -= 1; lcd.clear();  }

        sprintf(buffer, "%s %dms", secondario[(setModeLevel+1)], tempoAltPrima);
      break;

      case 6:
        if ( (ctrlButton( analogRead( BUTTON )) == 3 ) && tempoAltDopo <= 9999999)  { tempoAltDopo += 10; lcd.clear();  }
        if ( (ctrlButton( analogRead( BUTTON )) == 2 ) && tempoAltDopo >= 1)        { tempoAltDopo -= 1; lcd.clear();  }

        sprintf(buffer, "%s %dms", secondario[(setModeLevel+1)], tempoAltDopo);
      break;

      case 8:
        if ( (ctrlButton( analogRead( BUTTON )) == 3 ) && numeroScatti <= 9999999)  { numeroScatti += 10; lcd.clear();  }
        if ( (ctrlButton( analogRead( BUTTON )) == 2 ) && numeroScatti >= 1)        { numeroScatti -= 1; lcd.clear();  }

        sprintf(buffer, "%s %d", secondario[(setModeLevel+1)], numeroScatti);
      break;

    }

    /**********************************************************/

    lcd.setCursor(0,0);
    lcd.print( secondario[setModeLevel] );
    lcd.setCursor(0,1);
    lcd.print( buffer );        

    /**********************************************************/

    delay( 200 );

  }

  /**********************************************************/

  lcd.clear();

}

/**********************************************************/

void verifica() {
  /**********************************************************/

  #ifdef DEBUG
    Serial.println( "Menu Verifica" );
  #endif

  /**********************************************************/

  lcd.clear();
  lcd.setCursor(0,0);
  lcd.print( "Menu " );
  lcd.setCursor(0,1);
  lcd.print( "Verifica" );    

  /**********************************************************/

  delay( SETMODETIME );

  /**********************************************************/

  boolean verificaMode  = true;
  int setModeLevel = 0;
  lcd.clear();

  /**********************************************************/

  while ( verificaMode ) {

    /**********************************************************/

    if ( (ctrlButton( analogRead( BUTTON )) == 5 ) && setModeLevel < 8 ) { lcd.clear(); setModeLevel = (setModeLevel+2); }
    if ( (ctrlButton( analogRead( BUTTON )) == 4 ) && setModeLevel > 0 ) { lcd.clear(); setModeLevel = (setModeLevel-2); }
    if (  ctrlButton( analogRead( BUTTON )) == 1 )                       { verificaMode = false; }

    /**********************************************************/

    #ifdef DEBUG
      Serial.print( "setMenuLevel: " );
      Serial.println( setModeLevel );
    #endif

    /**********************************************************/

    switch ( setModeLevel ) {

      case 0:
        sprintf(buffer, "%s %d", secondario[(setModeLevel+1)], passiXscatto);
      break;

      case 2:
        sprintf(buffer, "%s %dms", secondario[(setModeLevel+1)], intervalloScatto);
      break;

      case 4:
        sprintf(buffer, "%s %dms", secondario[(setModeLevel+1)], tempoAltPrima);
      break;

      case 6:
        sprintf(buffer, "%s %dms", secondario[(setModeLevel+1)], tempoAltDopo);
      break;

      case 8:
        sprintf(buffer, "%s %d", secondario[(setModeLevel+1)], numeroScatti);
      break;

    }

    /**********************************************************/

    lcd.setCursor(0,0);
    lcd.print( secondario[setModeLevel] );
    lcd.setCursor(0,1);
    lcd.print( buffer );        

    /**********************************************************/

    delay( 200 );

  }

  /**********************************************************/

  lcd.clear();

}

/**********************************************************/

void reset() {

  /**********************************************************/

  #ifdef DEBUG
    Serial.println( "Menu Reset" );
  #endif

  /**********************************************************/

  lcd.clear();
  lcd.setCursor(0,0);
  lcd.print( "Menu " );
  lcd.setCursor(0,1);
  lcd.print( "Reset" );    

  /**********************************************************/

  delay( SETMODETIME );

  /**********************************************************/

  boolean resetMode  = true;
  lcd.clear();

  /**********************************************************/

  lcd.clear();
  lcd.setCursor(0,0);
  lcd.print( "LEFT antiorario" );
  lcd.setCursor(0,1);
  lcd.print( "RIGTH orario" );    

  /**********************************************************/

  while ( resetMode ) {

    /**********************************************************/

    if ( ctrlButton( analogRead( BUTTON )) == 3 )  { nFase++; }
    if ( ctrlButton( analogRead( BUTTON )) == 2 )  { nFase--; }
    if ( ctrlButton( analogRead( BUTTON )) == 1 )  { resetMode = false; }

    /**********************************************************/

    nFase = fase( nFase );

    /**********************************************************/

    delay( 10 );
  }

  /**********************************************************/

  stop();

  /**********************************************************/

  lcd.clear();
}

/**********************************************************/

void autoreset()
{
  #ifdef SSTART

    /**********************************************************/

    stop();

    /**********************************************************/

    lcd.clear();
    lcd.setCursor(0,0);
    lcd.print( "Menu " );
    lcd.setCursor(0,1);
    lcd.print( "Reset Automatico" );    

    /**********************************************************/

    delay( SETMODETIME );

    /**********************************************************/

    lcd.clear();
    lcd.setCursor(0,0);
    lcd.print( "Reset in corso" );

    lcd.setCursor(0, 1);
    lcd.write(1);        // SELECT
    lcd.setCursor(1, 1);
    lcd.write(1);        // SELECT
    lcd.setCursor(5, 1);
    lcd.write(3);        // STOP

    /**********************************************************/

    while ( analogRead( SSTART ) > TARATURA ) {
      nFase = fase( nFase );
      nFase--;
      if ( ctrlButton( analogRead( BUTTON )) == 3 ) {
        stop();

        lcd.setCursor(0, 1);
        lcd.write(3);        // STOP
        lcd.setCursor(1, 1);
        lcd.write(" ");
        lcd.setCursor(5, 1);
        lcd.write(" ");

        return;
      }
    }

    delay( 500 );
  #endif
} 

/**********************************************************/

void avvio() {

  lcd.clear();
  lcd.setCursor(0,0);
  lcd.print( "Menu " );
  lcd.setCursor(0,1);
  lcd.print( "Avvio" );    

  /**********************************************************/

  delay( SETMODETIME );

  /**********************************************************/

  lcd.clear();
  lcd.setCursor(0,0);
  lcd.print( "Go " );
  lcd.setCursor(3, 0);
  lcd.write(4);        // PAUSA

  lcd.setCursor(0, 1);
  lcd.write(3);        // STOP
  lcd.setCursor(5, 1);
  lcd.write(2);        // PLAY

  /**********************************************************/

  if ( !pausa() ) return;

  /**********************************************************/

  for ( scatto=0; scatto <= numeroScatti; scatto++ ) {

    lcd.setCursor(7, 0);
    lcd.print( "scatto:" );
    lcd.setCursor(14, 0);
    lcd.print( scatto );

    /**********************************************************/   

    for ( int passo=1; passo <= passiXscatto; passo++ ) {

      lcd.setCursor(7, 1);
      lcd.print( "passo:" );
      lcd.setCursor(13, 1);
      lcd.print( passo );  

      if ( ctrlButton( analogRead( BUTTON )) == 3 ) { if ( !pausa() ) return; }

      nFase = fase( nFase );
      nFase++;
      int _intervallo = intervalloScatto;
      if ( !ctrlDelay( _intervallo )) return;

    }

    /**********************************************************/

    int _tempo = tempoAltPrima;
    if ( !ctrlDelay( _tempo )) return;

    /**********************************************************/

    digitalWrite( SCATTO, HIGH );
    delay( TIMESCATTO );
    digitalWrite( SCATTO, LOW );

    /**********************************************************/

    lcd.setCursor(7, 0);
    lcd.print( "scatto:" );
    lcd.setCursor(14, 0);
    lcd.print( scatto );    

    /**********************************************************/   

    _tempo = tempoAltDopo;
    if ( !ctrlDelay( _tempo )) return;

    /**********************************************************/

  }

  /**********************************************************/

}

/**********************************************************/

boolean pausa() {

  lcdBlacklightOn();

  /**********************************************************/

  boolean play  =  false;

  /**********************************************************/   

  lcd.setCursor(3, 0);
  lcd.write(4);    // PAUSA

  lcd.setCursor(5, 1);
  lcd.write(2);    // PLAY

  /**********************************************************/   

  while ( !play ) {
    if ( ctrlButton( analogRead( BUTTON )) == 3 ) {
      lcd.setCursor(3, 0);
      lcd.write(2);    // PLAY

      lcd.setCursor(5, 1);
      lcd.write(4);    // PAUSA
      delay( 500 );
      play = true;
    }

    if ( ctrlButton( analogRead( BUTTON )) == 2 ) {
      stop();
      play = true;
      return false;
    }
    delay( 100 );
  }

  /**********************************************************/

  return true;
}

/**********************************************************/

boolean ctrlDelay(int tempo) {

  // lcdBlacklightOff(); // Decommenta per risparmio energetico
  timeDelay = millis();
  boolean dtime = true;

  #ifdef DEBUG
      Serial.print( "Delay: " );
      Serial.print( tempo );
      Serial.print( " Millis: " );
      Serial.print( timeDelay );
      Serial.print( " \n " );
  #endif

  while ( dtime ) {
    if ( tempo < (millis()-timeDelay)) { dtime = false; }

    if ( ctrlButton( analogRead( BUTTON )) == 3 ) { delay( 500 ); pausa(); }
    if ( ctrlButton( analogRead( BUTTON )) == 2 ) { stop(); dtime = false; return false; }
    if ( analogRead( SSTOP ) < TARATURA )         { stop(); dtime = false; return false; }

    Serial.print( (millis()-timeDelay) );
    Serial.print( "\n" );
  }

  return true;
}

/**********************************************************/

int fase( int nFase ) {

  if ( nFase > 4 ) { nFase = 1; }
  if ( nFase < 1 ) { nFase = 4; }

  #ifdef DEBUG
      Serial.print( "fase() - nFase: " );
      Serial.println( nFase );
  #endif

  switch( nFase ) {
  case 1:
    digitalWrite(DIRA, HIGH);
    digitalWrite(DIRB, LOW);
    digitalWrite(PWMA, HIGH);
    digitalWrite(PWMB, LOW);
    break;

  case 2:
    digitalWrite(DIRA, LOW);
    digitalWrite(DIRB, HIGH);
    digitalWrite(PWMA, LOW);
    digitalWrite(PWMB, HIGH);
    break;

  case 3:
    digitalWrite(DIRA, LOW);
    digitalWrite(DIRB, LOW);
    digitalWrite(PWMA, HIGH);
    digitalWrite(PWMB, LOW);
    break;

  case 4:
    digitalWrite(DIRA, LOW);
    digitalWrite(DIRB, LOW);
    digitalWrite(PWMA, LOW);
    digitalWrite(PWMB, HIGH);
    break;
  }

  //delay(TIMEFASE);

  return nFase;
}

/**********************************************************/

int stop() {
  digitalWrite(DIRA, LOW);
  digitalWrite(DIRB, LOW);
  digitalWrite(PWMA, LOW);
  digitalWrite(PWMB, LOW);
}

/**********************************************************/

leggendolo troverai che le linee che si preoccupano di farti impostare i parametri del Dolly Photo incrementa la velocità di impostazione sono quelle contenute nella funzione impostazioni() ed in particolare le linee 346-383 che riporto per approfondirle meglio:

   switch ( setModeLevel ) {

      case 0:
        if ( (ctrlButton( analogRead( BUTTON )) == 3 ) && passiXscatto <= 99999)  { passiXscatto += 10; lcd.clear(); }
        if ( (ctrlButton( analogRead( BUTTON )) == 2 ) && passiXscatto >= 1)      { passiXscatto -= 1; lcd.clear();  }

        sprintf(buffer, "%s %d", secondario[(setModeLevel+1)], passiXscatto);
      break;

      case 2:
        if ( (ctrlButton( analogRead( BUTTON )) == 3 ) && intervalloScatto <= 9999999)  { intervalloScatto += 10; lcd.clear();  }
        if ( (ctrlButton( analogRead( BUTTON )) == 2 ) && intervalloScatto >= 1)        { intervalloScatto -= 1; lcd.clear();  }

        sprintf(buffer, "%s %dms", secondario[(setModeLevel+1)], intervalloScatto);
      break;

      case 4:
        if ( (ctrlButton( analogRead( BUTTON )) == 3 ) && tempoAltPrima <= 9999999)  { tempoAltPrima += 10; lcd.clear();  }
        if ( (ctrlButton( analogRead( BUTTON )) == 2 ) && tempoAltPrima >= 1)        { tempoAltPrima -= 1; lcd.clear();  }

        sprintf(buffer, "%s %dms", secondario[(setModeLevel+1)], tempoAltPrima);
      break;

      case 6:
        if ( (ctrlButton( analogRead( BUTTON )) == 3 ) && tempoAltDopo <= 9999999)  { tempoAltDopo += 10; lcd.clear();  }
        if ( (ctrlButton( analogRead( BUTTON )) == 2 ) && tempoAltDopo >= 1)        { tempoAltDopo -= 1; lcd.clear();  }

        sprintf(buffer, "%s %dms", secondario[(setModeLevel+1)], tempoAltDopo);
      break;

      case 8:
        if ( (ctrlButton( analogRead( BUTTON )) == 3 ) && numeroScatti <= 9999999)  { numeroScatti += 10; lcd.clear();  }
        if ( (ctrlButton( analogRead( BUTTON )) == 2 ) && numeroScatti >= 1)        { numeroScatti -= 1; lcd.clear();  }

        sprintf(buffer, "%s %d", secondario[(setModeLevel+1)], numeroScatti);
      break;

il principio è descritto nel paragrafo precedente ed espresso nelle linee 04-05: noti che la prima linea controlla la pressione del bottone RIGHT mentre la linea 5 controlla la pressione del pulsante LEFT.

La pressione del pulsante RIGHT incrementa il contatore passiXscatto di 10 unità alla volta.

La pressione del pulsante LEFT decrementa il medesimo contatore di una sola unità alla volta.

Le linee 11-12: fanno la stessa operazione per il contatore intervalloScatto;

le linee 18-19: incrementano e decrementano il contatore tempoAltPrima che definisce il tempo in millisecondi da attendere prima di ciascuno scatto;

linee 25-26: agiscono sul contatore tempoAltDopo con cui definisci il tempo di attesa tra lo scatto ed il primo passo della successiva sequenza di passi del motore passo-passo;

linea 32-33: imposti i valori del contatore numeroScatti che definisce quanti scatti dovrai eseguire in tutto il progetto fotografico.

Video Dolly Photo incrementa la velocità di impostazione

Ecco il video che avrai già visto se hai seguito il blog e la serie di articoli sul Dolly Photo versione 2, se è il primo articolo che leggi su questo argomento ti consiglio di dare un occhio ai precedenti articoli dedicati all’argomento.

Buon divertimento !!!

Prima di inserire un commento, per favore, leggi il regolamento

Mauro Alfieri

Permanent link to this article: https://www.mauroalfieri.it/elettronica/dolly-photo-incrementa-la-velocita-di-impostazione.html

Lascia un commento

Your email address will not be published.

Questo sito usa Akismet per ridurre lo spam. Scopri come i tuoi dati vengono elaborati.