Giu 26

Dolly Photo automatizzare il ritorno carrello – seconda parte

Riprendo l’articolo di Lunedì per descriverti la nuova funzione del Dolly Photo automatizzare il ritorno carrello al punto zero:

dolly photo versione 2

questa funzionalità è molto comoda quando vuoi eseguire più volte il medesimo servizio fotografico con il Dolly Photo o quando inizi una nuova ripresa.

Non è necessario impostare nulla per utilizzare questa funzione.

Dolly Photo automatizzare il ritorno carrello

Per utilizzare questa funzione hai bisogno di due cose:

  1. i finecorsa, almeno quello di START, descritto nell’articolo precedente;
  2. la nuova funzione nello sketch

Per il punto uno puoi leggere l’articolo su come si costruisce un finecorsa di tipo ottico o meccanico e quali sono le differenze tra i due finecorsa.

Lo sketch che puoi utilizzare è il seguente:

/**********************************************************
 * 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 >=     31)   { 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);
}
 
/**********************************************************/

in cui la parte dedicata al Dolly Photo automatizzare il ritorno carrello è rappresentata dalla funzione: autoreset()

Procediamo con ordine e partiamo dal riconoscimento dei finecorsa:

/**********************************************************/
 
#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
 
/**********************************************************/

avrai notato che ci sono un po di linee in più nellaprima parte dello sketch:

linea 08: definisci un valore TARATURA che determina quando il sensore di finecorsa viene interrotto o premuto;

linee 26-27: imposta i pin a cui hai collegato i finecorsa di START ed END, ricorda che A0 non puoi utilizzarlo perchè usato dalla Keypad LCD;

in questo modo sai che il sensore di START è connesso al pin A1 e che quando leggi su questo pin un valore superiore a quello impostato alla linea 08 il carrello deve fermarsi.

Passa alle linee dedicate alla funzione autoreset(): 558-612 che riporto di seguito per descriverle:

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
}

la linea 03: controlla che il sia stato definito un parametro SSTART (vedi linea 26) se tale valore non è definito la funzione non esegue nulla ed esce;

linea 07: ferma il carrello, serve ad evitare che il carrello sia in movimento prima di eseguire l’operazione del Dolly Photo automatizzare il ritorno carrello, tale funzione è descritta in tutti gli articoli dedicati al Dolly Photo;

linee 11-15: puliscono il display e scrivono il messaggio “Menu Reset Automatico” per indicarti che sei entrato in questa fase;

linea 19: attendi il tempo impostato alla linea 19 dell’intero sketch ( vedi sopra ) prima di procedere alla vera e propria funzione;

line3 23-32: impostano il display per visualizzare le informazioni seguenti:

Dolly Photo automatizzare il ritorno carrello

linea 36: esegui un ciclo di tipo while la cui condizione di verifica è costituita dalla lettura del valore presente sul pin A1, fino a quando queto valore è inferiore al valore di TARATURA il ciclo sarà eseguito dal Dolly Photo automatizzare il ritorno carrello;

linea 37: richiama la funzione fase() e imposta nFase come valore di ritorno da tale funzione, la funzione fase() è quella che sposta il carrello alla fase indicata dal parametro nFase;

linea 38: decrementa il valore di nFase in modo che al ciclo successivo il valore di step sia di 1 inferiore a quello appena eseguito, ecco fatto il gioco del Dolly Photo automatizzare il ritorno carrello.

In pratica la fase del motore passo passo viene decrementata di 1 ad ogni ciclo for per cui il carrello si sposta indietro di un passo, questo fino a quando il valore rilevato dal comando analogRead() è inferiore a quello di TARATURA, ossia fino a quando il sensore finecorsa SSTART non dice allo sketch “ALT il carrello è arrivato” in quel momento il ciclo while si interrompe;

linee 39-50: servono a controllare che ad ogni ciclo non sia stato premuto il pulsante di STOP, utile sia per interrompere il Dolly Photo automatizzare il ritorno carrello sia per correggere eventuali errori di eseguzione dello sketch nelle prime fasi di test.

linea 53: attendi 500 millisecondi ( 1/2 secondo ) dopo il termine delle operazioni di reset del carrello prima di ritornare al menu principale.

Il video del Dolly Photo automatizzare il ritorno carrello

lo hai già visto in anteprima nel precedente articolo, ma siccome è un buon esempio di funzionamento te lo ripropongo:

Buon lavoro !!!

  • Questo sito ed i suoi contenuti è fornito "così com'è" e Mauro Alfieri non rilascia alcuna dichiarazione o garanzia di alcun tipo, esplicita o implicita, riguardo alla completezza, accuratezza, affidabilità, idoneità o disponibilità del sito o delle informazioni, prodotti, servizi o grafiche correlate contenute sul sito per qualsiasi scopo.
  • Ti chiedo di leggere e rispettare il regolamento del sito prima di utilizzarlo
  • Ti chiedo di leggere i Termini e Condizioni d'uso del sito prima di utilizzarlo
  • In qualità di Affiliato Amazon io ricevo un guadagno dagli acquisti idonei qualora siano presenti link al suddetto sito.

Mauro Alfieri

Permalink link a questo articolo: https://www.mauroalfieri.it/elettronica/dolly-photo-automatizzare-il-ritorno-carrello-seconda-parte.html

2 commenti

1 ping

    • Roberto il 2 Giugno 2017 alle 11:51
    • #
    • Rispondi

    Ciao Mauro, come stai? Volevo chiederti, questi fine corsa meccanici possono andare bene?

    [[ link rimosso in automatico ]]

    1. Ciao Roberto,
      come sai è vietato inserire link a portali di e-commerce, vedi regole in fondo ad ogni articolo.
      In merito alla richiesta di finecorsa puoi utilizzare qualsiasi tipo NO ( normalmente aperto ) o NC ( normalmente chiuso ) e poi configurare il tipo di finecorsa nel firmware MarlinKimbra o quello da te preferito.

  1. […] sketch è il medesimo pubblicato nel precedente articolo: Dolly Photo automatizzare il ritorno carrello – seconda parte di seguito ti riporto le linee specifiche per la gestione dei tempi per mostrarti dove intervenire […]

Lascia un commento

Il tuo indirizzo email non sarà pubblicato.

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