Dolly Photo – quinta parte: la conclusione

I miei progetti sono sempre in divenire quindi parlare di “conclusione” del Dolly Photo non è del tutto corretta diciamo più che si tratta di un punto fermo nello sviluppo del progetto.

Dolly Photo

Con le informazioni raccolte fino a questo punto puoi già realizzare il tuo Dolly Photo funzionante.

Ho composto anche un kit Dolly Photo che puoi acquistare sul sito robotics-3d che offrono la possibilità ad appassionati come te di vendere i propri progetti sul loro store.

Avvio del Dolly Photo

in questo articolo puoi seguire passo passo la reaizzazione della funzione “Avvio” del Dolly Photo.

L’Avvio è la fase di lavoro del Dolly Photo, quella in cui esegue il ciclo di lavoro con le pause impostate, il numero di passi e gli scatti.

Unica premessa ho usato il pin 2 per lo scatto, a questo pin devi collegare l’optoisolatore a sua volta collegato allo scatto della tua macchina fotografica.

La realizzazione del Dolly Photo

Parti con il collegamento del motore:

Dolly Photo motore

come indicato in figura:

Dolly Photo connessioni

i cavi del motore passo-passo sono colorati per aiutarti a collegarli in modo corretto, le coppie di cavi sono rispettivamente bleu/giallo per la fase A e rosso/verde per la fase B.

Lo sketch del Dolly Photo

lo sketch per la maggior parte è identico a quello visto negli articoli precedenti sul Dolly Photo, leggerai in questo articolo la spiegazione delle sole linee differenti:

/**********************************************************
 * 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 BUTTON A0
#define BACKLIGHT 10
#define MOTDTIME 2000
#define LCDTIME  3000
#define SETMODETIME 2000
#define TIMESCATTO 500
#define DEBUG

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

#define PWMA 3
#define PWMB 11
#define DIRA 12
#define DIRB 13
#define TIMEFASE 35
#define SCATTO 2

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

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

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

int SELECT[]     =  {720,760};
int LEFT[]       =  {480,520};
int RIGTH[]      =  {0,20};
int UP[]         =  {120,160};
int DOWN[]       =  {300,350};

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[4]   =  {"Impostazioni","Verifica","Reset Carrello","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  = 0;
int tempoAltPrima     = 0;
int tempoAltDopo      = 0;
int numeroScatti      = 0;

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

LiquidCrystal lcd(8,9,4,5,6,7);

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

void setup() {

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

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

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

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

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

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

  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( " TimeToSetHour " );     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 < 3 ) { 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 ) { 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++; lcd.clear(); }
        if ( (ctrlButton( analogRead( BUTTON )) == 2 ) && passiXscatto >= 1)      { passiXscatto--; lcd.clear();  }
        
        sprintf(buffer, "%s %d", secondario[(setModeLevel+1)], passiXscatto);
      break;
      
      case 2:
        if ( (ctrlButton( analogRead( BUTTON )) == 3 ) && intervalloScatto <= 9999999)  { intervalloScatto++; lcd.clear();  }
        if ( (ctrlButton( analogRead( BUTTON )) == 2 ) && intervalloScatto >=     1)    { intervalloScatto--; lcd.clear();  }

        sprintf(buffer, "%s %ds", secondario[(setModeLevel+1)], intervalloScatto);
      break;
      
      case 4:
        if ( (ctrlButton( analogRead( BUTTON )) == 3 ) && tempoAltPrima <= 9999999)  { tempoAltPrima++; lcd.clear();  }
        if ( (ctrlButton( analogRead( BUTTON )) == 2 ) && tempoAltPrima >=     1)    { tempoAltPrima--; lcd.clear();  }

        sprintf(buffer, "%s %ds", secondario[(setModeLevel+1)], tempoAltPrima);
      break;
      
      case 6:
        if ( (ctrlButton( analogRead( BUTTON )) == 3 ) && tempoAltDopo <= 9999999)  { tempoAltDopo++; lcd.clear();  }
        if ( (ctrlButton( analogRead( BUTTON )) == 2 ) && tempoAltDopo >=     1)    { tempoAltDopo--; lcd.clear();  }

        sprintf(buffer, "%s %ds", secondario[(setModeLevel+1)], tempoAltDopo);
      break;
      
      case 8:
        if ( (ctrlButton( analogRead( BUTTON )) == 3 ) && numeroScatti <= 9999999)  { numeroScatti++; lcd.clear();  }
        if ( (ctrlButton( analogRead( BUTTON )) == 2 ) && numeroScatti >=     1)    { numeroScatti--; 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 %ds", secondario[(setModeLevel+1)], intervalloScatto);
      break;
      
      case 4:
        sprintf(buffer, "%s %ds", secondario[(setModeLevel+1)], tempoAltPrima);
      break;
      
      case 6:
        sprintf(buffer, "%s %ds", 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( 100 );
  }
  
  /**********************************************************/
  
  stop();
  
  /**********************************************************/
  
  lcd.clear();
}

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

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 * 1000);
      if ( !ctrlDelay( _intervallo )) return;
      
    }
    
    /**********************************************************/
    
    int _tempo = (tempoAltPrima * 1000);
    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 * 1000);
    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 ) {
      return false;
      stop();
      dtime = 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);
}

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

Ho riportato tutto lo sketch per completezza e pubblicato su GitHub

Le principali differenze riguardano:

linea 32: definisci la costante SCATTO impostata a 2 il pin che utilizzi per inviare alla macchina fotografica il segnale di scatto;

linee 49-50: definisci due nuove variabili di tipo integer in cui memorizzare il numero di passi e di scatti eseguiti nella fase di Avvio;

linea 57: definisci la variabile di tipo unsigned long timeDelay il cui uso lo comprenderai quando leggerai la funzione ctrlDelay();

linee 103-104: imposta il pin 2 ( SCATTO ) come modalità di OUTPUT e impostalo a LOW;

linee 188-192: definisci la funzione lcdBlacklightOff() il cui scopo è spegnere il display quando viene richiamata e impostare a false il valore di blacklightStatus che potrai controllare per conoscere lo stato della retroilluminazione del display;

linee 196-200: definisci la funzione lcdBlacklightOn() che ha funzione inversa alla lcdBlacklightOff() ossia accende la retroilluminazione del display quando richiamata e imposta a true il valore della variabile blacklightStatus di controllo;

linea 534: definisci la funzione “Avvo”;

linee 536-540: pulisci il display e scrivi sulla prima linea “Menu” e sulla seconda “Avvio” ( vedi video );

linea 544: attendi il tempo definito nella costante SETMODETIME prima di passare oltre nell’eseguzione della funzione Avvio del Dolly Photo;

linee 548-557: imposta dei messaggi sul display, scrivi nella posizione 0 della riga 0 “Go” e nella posizione 3 della riga 0 il simbolo PAUSA. Sulla riga 1 scrivi in posizione 0 il simbolo STOP e in posizione 5 il PLAY;

linea 651: richiama la funzione pausa() e valuta il suo valore di ritorno, se è false esci dalla funzione Avvio del Dolly Photo. E’ un passaggio semplice ma importante, la funzione pausa() oltre a mettere in pausa il Dolly Photo valuta anche i tasti che premi, lo vedrai nelle linee dedicate alla funzione, e se ritorna il valore true indica che devi proseguire nel ciclo di Avvio, se ritorna false ti dice di uscire dal ciclo;

linea 565: inizia un ciclo for basato sul numero di scatti impostati ed esegue il codice contenuto tra le {} per ciascuno scatto, ricorda che scatto parte da 0;

linee 567-570: scrivi sul display il testo “scatto:” ed il numero di scatto corrente;

linea 574: per ogni ciclo del for scatti, imposta un nuovo ciclo basato sui passi da eseguire per ciascuno scatto;

linee 576-579: scrivi sulla seconda riga del display ( riga 1 ) il testo “passo:” ed il numero di passi eseguiti;

linea 581: controlla se il pulsante RIGHT è stato premuto ed in tal caso richiama la funzione pausa() che come già visto ritorna un valore true o false che ti dice se continuare dopo la sua esecuzione o uscire;

linea 583: è la linea che esegue il passo vero e proprio, richiama la funzione fase() passandole il numero di fase a cui portarsi, essendo richiamata ad ogni ciclo for dei passi esegue un passo per ciclo;

linea 584: incrementa il valore di nFase dopo averlo eseguito;

linea 585: calcola l’intervallo di tempo da attendere tar un passo ed il successivo. Poiché l’intervallo è impostato in secondi e Arduino ragiona in millisecondi ti è sufficente molyiplicare il valore di intervallo per 1000 per ottenere gli effettivi secondi di pausa tra un passo ed il successivo;

linea 586: potresti impostare il tempo di attesa con un semplice delay( _intervallo ); tuttavia questa soluzione ti impedirebbe nella fase di attesa di inviare comandi ad Arduino, ad esempio non potresti mettere in pausa lo sketch o stoppare la sequenza in corso. Ho deciso quindi di realizzare la funzione ctrlDelay( tempo ) il cui scopo è proprio attendere il tempo definito e controllare la pressione dei pulsanti anche durante l’attesa;

linee 592-593;

: calcola ed imposta il tempo di attesa prima dello scatto, questo tempo ti garantisce che il carrello si sia fermato e che la macchina fotografica sia effettivamente ferma;

linee 597-599: porta a livello HIGH il pin 2 ( SCATTO ), attendi il tempo TIMESCATTO definito alla linea 22 e riporta a LOW il pin SCATTO. Se vuoi aumentare questo tempo puoi farlo modificando il valore 500 alla linea 22;

linee 603-606: scrivi sul display il vaolore di scatto raggiunto sulla prima riga ( 0 );

linee 610-611: imposta il tempo di attesa dopo lo scatto calcolandolo come alle linee 592-593;

linea 623: definisci la funzione pausa() come di tipo boolean ossia una funzione in grado di restituire un valore di tipo booleano ( true o false ) userai il valore true per indicare allo sketch di proseguire dopo la pausa e false per interrompere il ciclo di Avvio, vedi linea 561;

linea 625: accendi la retro illuminazione del display;

linea 629: imposta una variabile di tipo booleano chiamata play;

linee 633-637: scrivi sulla prima riga alla posizione 3 il simbolo PAUSA ed alla seconda riga posizione 5 il simbolo PLAY;

linea 641: fino a quando il valore della variabile play definita alla linea 629 sarà false il ciclo continuerà all’infinito;

line642-650: controlla, per ogni ciclo, se è stato premuto il pulsante RIGHT, quello che hai definito per uscire dalla modalità PAUSA e tornare alla modalità PLAY. In caso venga premuto inverti i simboli play e pausa sulle rispettive righe, imposta a true il valore della variabile play e attendi 500 millisecondi per evitare che il tempo in cui rilasci il pulsante sia considerato come nuova pressione. In elettronica questo comportamento si chiama anche anti-rimbalzo;

linee 652-656: sono simili alle linee appena viste, con la differenza che il Dolly Photo reagisce alla pressione del pulsante LEFT, designato a STOP. La pressione di tale pulsante richiama la funzione stop(), imposta a true il valore di play e ritorna false alla funzione che ti aveva chiamato;

linea 657: imposta un tempo di 100 millisecondi tra un ciclo while() ed il successivo, serve a limitare il numero di cicli eseguiti in un secondo a 10;

linea 662: se tutte le condizioni descritte sopre sono verificate ed hai premuto il pulsante RIGHT, arrivi a questa linea che restituisce true alla funzione chiamante;

linea 667: definisci la funzione booleana ctrlDelay( tempo ) il cui funzionamento è simile alla funzione pausa() ma non identico, infatti il ciclo contenuto termina dopo un tempo stabilito e non alla pressione di un pulsante;

linea 669: puoi decommentare questa linea se desideri che durante la fase di attesa il display resti spento, resterà spento anche durante tutto il tempo di esecuzione della modalità “Avvio” a meno che tu non prema il pulsante RIGHT che mette in pausa il tutto;

linee 670-671: assegna alla variabile timedelay il valore corrente di millis() ti serve per verificare quanto tempo è passato dall’inizio del ciclo di controllo. Definisci anche una variabile di controllo dtime su cui basi il ciclo while( dtime ) successivo;

linea 681: fino a quando il valore di dtime sarà true il ciclo continuerà all’infinito;

linea 682: controlla quanto tempo è passato. Con la formula matematica ( millis() – timedelay ) sai quanto tempo è passato dall’impostazione della variabile timedelay, se questo tempo è maggiore del tempo che hai impostato nella variabile tempo allora imposta dtime a false: questo comporta l’uscita dal ciclo while();

linea 684: se premi il pulsante RIGHT questo richiama la funzione pausa;

linee 685-689: sono simili alle linee 652-656, cambiano solo le variabili utilizzate;

linea 694: ha la stessa funzione della linea 662;

Il video del Dolly Photo

ho preparato anche un video demo del Dolly Photo:

Buon divertimento

Permanent link to this article: http://www.mauroalfieri.it/elettronica/dolly-photo-conclusione.html

275 comments

Skip to comment form

    • Mirko on 15 marzo 2013 at 17:31
    • Reply

    Ciao complimenti per il lavoro svolto. Vorrei sapere se con questo progetto posso utilizzare anche la funzione per controllare uno slider camera e non solo per fare il time lapse.

    1. Ciao Mirko,
      so che qualche Makers lo sta usando come slider on qualche difficoltà dettata dai passi che fanno vibrare la videocamera.
      Io sto progettando un kit per slider che é già in vendita su robot-domestici.it e di cui tra qualche giorno inizierò a pubblicare degli articoli.

      Mauro

        • luca on 22 marzo 2013 at 14:18
        • Reply

        🙂 nn vedo l’ora….

  1. Ciao, volevo sapere un’informazione la quale non sono riuscito a trovare nessun riferimento (o mi è sfuggito) sullo Sketch. Dove si inseriscono i parametri che indichino al motore passo-passo quando fermarsi perchè la corsa della rotaia è finita? non son riuscitoa trovare la parte dove si inserisce il numero massimo di step. Grazie mille per queste utilissime guide.

    1. Ciao Roberto,
      per indicare al Dolly Photo quando fermarsi devi conoscere il numero di passi massimi che la tua slitta può supportare
      ed impostarlo come ultimo valore del menu: “numero di passi”

      Mauro

      1. Ok, ti ringrazio, ero convinto che si dovesse inserire il massimo degli step in modo da far fermare il motore. Scusami, ti faccio un’altra domanda, quando il carrello arriva in fondo alla guida e si ferma perche ho inserito il numero degli steps, per farlo ripartire nel senso opposto risolvo il tutto eseguendo un azzeramento? Spero di essermi spiegato bene. Non vedo l’ora di finire la realizzazione di questo dolly perche sta diventando un’impresa folle per me che mastico poco di elettronica ma riesco a pappa in un sol boccone la parte meccanica!

        1. Ciao Roberto,
          si, quando sei a fine corsa puoi usare la funzione Reset carrello e sposarlo all’inizio o dove preferisci.
          Dai che sei alla conclusione 🙂

          Mauro

            • luca on 22 marzo 2013 at 14:20

            si potrebbe inserire un fine corsa con due microswitch 🙂

          1. Ciao Luca,
            allora mi leggi nel pensiero o hai letto molto bene i miei articoli 🙂
            Sto lavorando all’estensione del kit con dei finecorsa ottici, più sensibili di quelli meccanici e meno soggetti ad usura.

            Leggi l’ultimo articolo sul sensore SHARP di mercoldì 🙂
            Tu hai già acquistato il kit del dolly su robot-domestici.it ?

            Mauro

            • Roberto on 22 marzo 2013 at 15:04

            Si, ma conoscendo la lunghezza della tua guida e sapendo quanti mm fa ad ogni step è piu facile (credo) inserire una voce nello sketch dicendogli guarda che puoi fare questo (tot) di passi. Cmq, ritornando al mio discorso precedente, ho caricato il tutto ma nulla, si accende lo schermo, mi esce la scritta di benvenuto, mi dice in attesa di comandi e poi nulla, non fa più niente…mi vien il dubbio di aver saltato qualche cosa o meglio ancora, di non aver capito alcune cose sullo sketch e caricamento su arduino! Bha

          2. Ciao Roberto,
            se leggi anche gli altri articoli vedrai che per entrare nel menu devi tener premuto il pulsante di select per più di 2sec.
            Ti consiglio di leggere tutti i miei articoli sul Dolly, sono solo 5, capirai un sacco di cosa sul prodotto 🙂

            Mauro

            • Roberto on 22 marzo 2013 at 17:12

            Ciao Mauro, ho gia eseguito la procedura. Anche tenendo premuto per più di 2 secondi mi rimanda alla schermata di benvenuto.Provo a riguardare il tutto e al limite ti ricontatterò! Mi è venuto il dubbio, potrei aver saltato qualche campo da compilare nel tuo sketch?

          3. Ciao Roberto,
            se stai utilizzando la Keypad ed il mio sketch senza modificarlo deve funzionarti o darti errore in compilazione.

            Mauro

            • luca on 22 marzo 2013 at 19:16

            Ciao

            D:allora mi leggi nel pensiero o hai letto molto bene i miei articoli 🙂
            R:solita fortuna del principiante 🙂

            Tu hai già acquistato il kit del dolly su robot-domestici.it ?
            no xke avevo gia’ un arduino uno e lo stesso motor shield del progetto dolly cam…

            mi e’ appena arrivato l’LCD e non riesco a farlo funzionare :(((( nel senso si accende e rimane in attesa di comandi… va beh… butto via tutto …..

          4. Ciao Luca,
            va bene anche se hai i componenti separati, l’importante é che siano gli stessi per essere sicuro che lo sketch funzioni.

            L’LCD a cui ti riferisci é la Keypad, giusto?

            Mauro

  2. buon pomeriggio
    Finalmente ho trovato un progetto simile a quello che voglio ottenere,
    purtroppo di professione faccio il disegnatore ed di elettronica mi intendo ben poco.
    ho acquistato l’arduino 2009 con la Motor shield per arduino per motori dc stepper servo.
    lo sketch chredo che sia perfetto.
    ora dovrei acquistare un keypad lcd ma purtroppo non so come collegare il tutto al motore passo passo, finchè si tratta di inserire il codice nel arduino e fare il sandwic di hardwere mi va tutto bene .
    ma ora che mi ritrovo con i fili in mano non so in che pin connetterli ,mi dispiace per la mia richiesta stupida ma non si potrebbe avere uno schema, o delle foto dei collegamenti dei cavetti dove vanno le resistenze, ecc,?
    purtroppo in rete non ho trovato altri progetti .
    il più completo e ragionato è il suo
    la ringrazio
    cordiali saluiti
    andreglo

    1. Ciao Andre,
      leggi tutti gli articoli dedicati al Dolly Photo sono 5 e troverai passo passo tutto quello che ti occorre.
      Per il motore passo passo se non hai lo stesso motore che presento io puoi leggere gli articoli sui motori passo-passo come riconoscere le fasi del tuo e come collegarli.

      Mauro

    • Luca on 23 marzo 2013 at 10:15
    • Reply

    Ciao Mauro
    Si e’ il lcd keypad della df robot. Ma guardando nel dettaglio e’ leggermente diverso da quello che usi tu. Il mio e’ quello senza le i jumper vicino agli ingressi analogici.
    Eccolo in foto:
    http://tutorial.cytron.com.my/wp-content/uploads/2011/08/dfrobot-lcd-keypad-shield-arduino.jpg

    Ciao ciao

    1. E lo stesso che ho acquistato io. Da lo stesso errore anche a me.
      X Mauro, ho caricato il tuo sketch senza modifiche e mi da sempre lo stesso problema. Arduino e motor shield sono uguali ai tuoi, ma il Keypad LCD e come quello di Luca.

      1. ciao e buona domenica…
        son riuscito a farglielo digerire!! 🙂 tagliando i jumper SNS0 e SNS1 (usa un cutter)

        ora la domanda viene spontanea… senza controllo della corrente di assorbimento c’e’ da fidarsi? 🙂 🙂 🙂
        ciaooo

        1. Ciao Luca,
          ottimo, che stana situazione io sulla mia motor shield originale non ho dovuto far nulla.
          Se vuoi usare il controllo corrente puoi sempre spostare i comandi che arrivano su A0 della Keypad LCD al pin A2, ad esempio.

          Mauro

      2. Ciao Roberto,
        il problema sembra essere la motor shield che nella versione da voi acquistata ( Luca e tu ) ha qualche differenza sul pin A0 rispetto alla mia.
        Il kit lo hai acquistato sul sito robot-domestici.it dove è in vendita quello che ho costruito io per il Dolly Photo?

        Mauro

        1. Ciao Mauro, allora io ho acquistato sia l’arduino che il motor shield su Robot italy e sono gli stessi che hai preso tu mentre per il keypad LCD l’ho acquistato su ebay ed è lo stesso modello di Luca. Sinceramente non sarei tanto propenso a tagliare i pin 01 e 02 (p.s. non capendono nulla di elettrronica gli SNS0 e SNS1 sono i pin 0 e 1?) E possibile sostituirli con altri pin? E sopratutto, ricordo che lo scatto lo avevi attaccato proprio al pin 2. Non e che si fa qualche conflitto? Vi ringrazio nuovamente per tutto il supporto dato, non saprei come fare senza il vostrro aiuto.

          1. Ciao Roberto,
            purtroppo ti rispondo al buio non possedendo le stesse tue shield, probabilmente differiscono le versioni rispetto alle mie.
            Devo verificare se esistono gli schemi delle schede.

            Mauro

            • Roberto on 25 marzo 2013 at 19:09

            Umh, forse mi spiego male io. Allora, io ho l’Arduino UNO R3, Arduino Motor Shield R3 che sono quelli che hai tu, mentre il Keypad LCD è quello che ha anche Luca cioè quello della DF Robot e che ha postato il link del pdf. Boh, non so più che pesci pigliare, ho caricato e ricaricato lo sketch, ho provato con quelli precedenti, ho tagliato come diceva Luca gli SNS0 e SNS 1 sulla motor shiel e quando arrivo a attesa comandi mi rimanda all’inizio. Son tentato ad acquistare LCD che hai tu cosi porca miseria andrà bene!

          2. Ciao Roberto, non arrenderti 🙂
            So che a volte è dura non pensare che a me venga tutto semplice, non è affatto così.
            Per realizzare il Dolly ci ho impiegato una settimana a sbattere la testa di continuo.

            Ti consiglio di leggere bene il listato e l’output seriale e capire cosa succede, magari aggiungendo dei punti di DEBUG in più, fino a capire cosa accade. Io l’ho fatto per tutto il tempo in cui ho scritto il codice del Dolly ed ancora adesso se avessi delle difficoltà farei così.

            Mauro

    2. Ciao Luca,
      è solo una versione differente della stessa scheda.
      Prova lo sketch di esempio del primo articolo sul Dolly Photo, e verifica che funzioni allo stesso modo.

      Mauro

  3. ciao Mauro

    L’LCD a cui ti riferisci é la Keypad, giusto?

    si esatto e’ il DF ROBOT LCD KEYPAD SHIELD

    ho notato che sia il LCD KEYPAD e Il MOTOR SHIELD hanno il condivisione il pin A0

    e’ esattamente quello che e’ a pagina 8 del seguente pdf

    http://droboticsonline.com/ebaydownloads/ArduinoShieldManual.pdf

    grazie infinite

    ciao

    1. Ciao Luca,
      a cosa server il pin A0 alla motor shield che hai?
      Ma sopratutto che Motor Shield possiedi?

      Non tutte possono essere utilizzate con il mio progetto,
      ho fatto una ricerca accurata per comporre questo Kit.

      Mauro

      1. ciao

        ho questo da tempo memore…. e non l’ho mai usato…

        http://arduino.cc/en/Main/ArduinoMotorShieldR3

        1. Ciao Luca,
          è la stessa che uso nel progetto 🙂
          Se guardi la foto nel link che mi hai inviato vedrai che SNS0 ed SNS1 sono già scollegati.

          Mauro

            • luca on 25 marzo 2013 at 21:34

            boh provando con il tester, le due piazzole di stagno davano corto… dopo aver tagliato il corto circuito con il cutter, si sono potuti usare i sotto menù dopo il messaggio di benvenuto.

            Domanda il motore passo passo di una stampante (4 fili) e’ simile ai motori passo passo normali?

            grazie

            ciao
            luca

          1. Ciao Luca,
            magari sono piccole differenze di produzione.
            I motori passo passo esistono in tante forme, potenze ed avvolgimenti ma un 4 fili è sempre un bipolare, sia esso nella stampante o acquistato altrove.
            Se sei curioso di conoscere meglio questi motori ti consiglio di leggere i miei primi articoli sul blog sono dedicati proprio ai motori passo-passo.

            Mauro

  4. Ciao Roberto

    Strano che non riesvi ad entrare nel menu di configurazione. Prova a togliere il motor shield e vedi se cosi ci entri. Poi assicurati che siano interrotti i jumper saldati con un cutter ( a me funge cosi)
    Ora sono arenato sul motore passo passo… Ho guardato il tutorial di Mauro ma nn riesco a capire i 4 cacetti come si collegano…
    Ciaooo

    1. Ciao Luca,
      Grazie per il supporto che stai dando anche a Roberto.
      Per il motore passo-passo prova a leggere gli articoli su come riconoscere le fasi e i tipi di motore.
      Vedrai che tutto sarà semplice dopo.

      Mauro

      1. buongiorno Mauro

        ho smontato il motore passo passo, e ho visto che ha 6 avvolgimenti invece che 4 e’ lo stesso? e’ sempre bipolare? funziona con il nostro motor schield?
        Ho provato a seguire il tuo tutorial sui motori, ma il mio o scatta a dx o sx!!!! nn riesco a farlo andare in un verso solo !!! le ho provate tutte!!! 😀 booh

        grazie mille
        buon lavoro
        luca

        1. Ciao Luca,
          più che gli avvolgimenti mi dovresti dire quanti fili possiede.

          Mauro

        2. Dal mio punto di vista Luca hai fatto molto male a smontare il motore passo passo, in questo modo hai dimezzato la coppia.
          http://www.motoripassopasso.it/MotoriPassoPasso_Precauzioni.aspx

    2. Ciao Luca e grazie mille per il supporto che mi date tu e e mauro. Allora, ho provato a fare come hai detto tu ma nulla, anche togliendo il motor shiel. In teoria adesso dobremmo avere la stessa configurazione io te perche abbiamo l’Arduino UNO R3, Arduino Motor Shield R3 e il Keypad LCD della DF Robot che è uguale a quello che hai postato tu. Io son ancora convinto che sbaglio qualche cosa nel caricare lo sketch oppure ho fottuto la scheda arduino. Vi do una breve descrizione di come inserisco lo sket. Attacco arduino alla porta usb, apro l’IDE di arduino, ho laversione 1.5.2. Ho settato su strumenti la versione di arduino UNO e la porta COM che nel mio caso è la 16. Copio lo sketch di mauro e lo copio all’interno del programma arduino, faccio la verifica che non mi da nessun errore e poi carico, anche qua nessun errore. Quando vado ad attaccare sia il motorshield della arduino, sia l’lcd mi mostra continuamente la scritta in attesa di comandi e nulla più. Può essere che l’LCD abbia qualche pulsante rotto? tipo il Select? Vi ringrazio infinitamente per l’aiuto. Che brutta cosa non capirci nulla di elettronica quando ci si ha a che fare!

      1. Ciao Roberto,
        la versione dell’IDE attuale dal sito Arduino è la 1.0.4, la tua non mi risulta esitere.
        Per verificare i pulsanti segui il tutorial dalla prima parte,
        provando lo sketch indicato come ho suggerito già in precedenti commenti.

        Mauro

        1. Ciao, allora ho provato a caricare lo sketch dell’LCD dove c’è la prova comandi e funzina tutto ok.. Ho ricontrollato la versione ed è la 1.04, avevo scaricato tempo fa la versione beta che è la 1.5.2. Non mi resta che andare per tentativi…

    3. X Luca, ho provato con il tester su SNS0 e SNS1 e mi da che c’è passaggio di corrente. Come faccio a tagliarli? Son gia passato con la lama del cutter ma da sempre passaggio. Info?

      1. E altra domanda, ma io devo alimentare sia l’arduino che la motorshiel o basta alimentare solamente 1 dei due?

        1. Ciao Roberto,
          devi alimentare entrambi, negli articoli si vede e c’é scritto.

          Mauro

  5. Ciao Mauro

    Il motore ha 4 fili e 8 avvolgimenti. I 4 polari e gli intermedi. Scusa ma stamattina ero ancora addormentato!!!! 😀

    X Roberto: hai anche provato a cliccare una volta e poi ripremere il pulsante select x 5 secondi? Se hai dubbi sul funzionamento dei tastini, io avevo provato uno prg ufficiale dal sito df robot per testare i tastini.

    Ciao ciao

    1. Ciao Luca,
      ok, hai un motore bipolare, per riconoscere le fasi segui questo articolo:

      http://www.mauroalfieri.it/elettronica/tutorial-motore-bipolare-passo-passo-riconoscere-le-fasi.html

      Mauro

    2. Ciao Luca, si si ho provato e riprovato, ho fatto il test trovato sul sito della Df Robot e i tasti funzionano completamente. Bha ci lavorerò su. Per il momento ho anche un altro problema, trovare una ditta che mi faccia le lavorazioni meccaniche di cui ho bisogno. Ho come l’impressione che il progetto al quale sto pensando sia troppo ambizioso!

      1. Ciao Roberto,
        io sto lavorando con una ditta in partnership che mi fornirà anche la arte meccanica per realizzare il Dolly, se sei interessato quando lo avrò terminato ti posso procurare la meccanica.

        Mauro

        1. Sto pensando ad una scatola che contenga il tutto, però ci son delle lavorazioni a macchina da fare e la maggior parte delle ditte non ha tempo per far certi lavori se non in grandi quantità.Per il momento sono fermo con tutto il progetto. Il sistema di schede arduino non ne vuole sapere proprio di andare, i componenti funzionano tutti quindi è solo un problema di programmazione e settaggio pin. Grazie mille per tutto l’aiuto che mi hai dato in questo periodo. E ancora complimenti per i tuoi progetti. Ciao

          1. Ciao Roberto,
            come contenitore puoi utilizzare sia una scatoletta plastica di quelle in commercio nei negozi di elettronica, sia una scatoletta ad uso elettrico per impianti esterni, le bianche per capirci.

            Siamo Makers in fondo.

            Per il tuo rigetto non demordere, controlla che non facciano contatto i pin in prossimità di A0, quasi certamente é quello il solo problema.

            Mauro

            • Roberto on 28 marzo 2013 at 23:50

            Ho notato che sulla motor shield R3 arduino, non è saldato il pin GDN sui morsetti blu dove si attacca il motore passo passo. Per quanto riguarda le saldature sul Keypad LCd mi sembrano tutte ok. Hai qualche info da darmi su una modalità di verifica migliore per il pin A0? Mi consigli di ripassare le stagnature?

          2. Ciao Roberto,
            non so in che stato siano le tue shield ma eviterei di ripassare le saldature se non sei più che sicuro.
            Se la shield non è funzionante è il caso che tu chieda al tuo fornitore di sostituirtela, e per farlo non devi manometterla.

            Mauro

  6. Buongiorno Mauro
    Ho visto che ieri il sito era giu!!!

    Ho pensato… Una volta che ho trovato un blog serio viene chiuso!!!

    Roberto nn mollare!! Anche a me capita ma poi magari dopo qualche gg riprendo…
    Ciao Luca

    1. Ciao Luca,
      abbiamo subito un attacco 🙁
      Ho lavorato tutta notte per ritirarlo su.

      Grazie
      Mauro

      1. mi spiace spero non accada più!!!

        1. Ciao Luca,
          cosa ?

  7. ciao Mauro e a tutti
    se posso dare un consiglio: sarebbe veramente fiero se ci fosse la possibilità di impostare gli scatti totali settando le cifre singolarmente in unità, decine e centinaia.

    cosa ne pensate?
    ciao
    luca

    1. Ciao Luca,
      é una bella evoluzione del software, mi piace.
      Prova a svilupparla e riporre la tua soluzione, io ho già in mente come la farei 🙂

      Mauro

  8. 😀 sarebbe ancora più fiero se si potesse impostare la durata dello scatto!!!!!!!!

    ciaooo

    1. Ciao Luca,
      trovo anche questa un’evoluzione interessante 🙂

      Mauro

  9. Ciao Mauro,
    X il mi dispiace Intendevo l’attacco hacker al sito.
    E per l’evoluzione… Potrei provarci… Ma nn so quando riusciró

    1. Ciao Luca,
      grazie per fortuna ho risolto 🙂
      Prenditi tutto il tempo che ti occorre se scrivo qualcosa prima lo leggerai sul blog 🙂

      Mauro

  10. Ciao Mauro
    Mi e’ arrivato un nuovo motore passo passo. Mod sm42byg011-25 della mercury motor (sembra essere uguale a quello che usi!!)
    Mi sa xo che nn ha molta forza nei suoi step. Basta una leggera pressione per nn farlo girare. Eppure dovrebbe essere un. 2.3 kg di copppia! Secondo te come mai?grazie e ciao
    Luca

    1. Ciao Luca,
      si comporta allo stesso modo anche quando è alimentato?

      Mauro

  11. Ciao Mauro
    Si comunque alimento arduino con un alimenttore 12v 500ma e la shield con un’altro stabilizzato 12v 3amp.
    Ariciao
    Luca

    1. Ciao Luca,
      il motore quando é alimentato ed in rotazione sviluppa la coppia indicata dal produttore.
      Quel valore non vale se il motore non è alimentato o se é fermo.

      Questa é una caratteristica dei motori passo-passo, diversa dai motori con moto riduzione in quanto in quelli la forza é in massima parte sviluppata dagli ingranaggi, e quindi anche a motore non alimentato oppone resistenza alla rotazione manuale dell’albero no.

      Mauro

  12. Buongiorno Mauro
    Forse mi son spiegato male,
    Il motorino quando gira e fa i suoi step (configurati sul display), basta applicare una leggera pressione con le dita per fermarlo. Posseggo anche diversi motori e servi sia analogici che digitali, e quelli con caratteristiche minori di coppia sembrano piu ardui a farli fermare mentre ruotano

    Ciao
    Luca

    1. Ciao Luca,
      mi sono perso questo commento.
      Comprendo ciò che dici, potrebbe essere difettoso il motore, dove lo hai acquistato?

  13. Piu nessuna risposta? 🙁

  14. Buona sera Mauro, i miei complimenti per i progetti che illustri nel tuo sito e la pasienza per seguire i problemi di chi li realizza, come fotografo mi piacerebbe realizzare il dolly, cosi ho acquistato il kit per dolly foto che consiste nella scheda arduino uno rev3, motor shield rev3 e il display LCD shield, ho assemblato le tre schede e caricato il programma, da te compilato nella versione 5, ma non riesco ad andare oltre la schermata “in attesa di comandi” ho tolto la motor shield e riassemblato arduino con display LCD shield, ma la situazione rimane invariata, in più la retoilluminazione si accende solamente premendo i pulsanti right e reset, come se non sentisse la pressione degli altri 4 pulsanti, con il multimetro, a scheda scollegata, ho misurato la contunuità dei pulsanti incriminati, ma funzionano correttamente, non saprei cosa altro fare, potresti illuminarmi ?

    1. Ciao Pierfrancesco,
      hai separato i contatti in prossimità dei pin A0 e A1 presenti sulla Motor Shield?

      Mauro

        • Pierfrancesco on 18 aprile 2013 at 15:05
        • Reply

        Buongiorno Mauro, la separazione dei contatti in prossimità di A0 e A1cioè SNS0 e SNS1, la ho appena fatta, ma la scheda display continua a non sentire la pressione dei pulsanti select,left, up, down, e quindi non si attiva nemmeno la retroilluminazione, mentre vanno bene i pulsanti right e reset, ti ringrazio anticipatamente se puoi dirmi come risolvere questa situazione buona serata

        1. Ciao Pierfrancesco,
          potrebbe essere un problema elettrico, prova con uno sketch semplice che ti legga il valore sul pin A0 alla pressione di un pulsante.
          Fai il medesimo test per tutti i pulsanti.

          Mauro

            • Pierfrancesco on 18 aprile 2013 at 20:59

            buona sera Mauro, come semplice tecnico elettronico hardware non saprei da dove iniziare nel compilare lo sketch che tu mi suggerisci, potresti darmi una indicazione? grazie 1000

            Pierfrancesco

          1. Ciao Pierfrancesco,
            leggi i primi articoli del mio corso on-line, troverai e é davvero semplice e se vuoi iniziare un progetto con Arduino almeno le basi ti saranno utili.

            Mauro

        2. Ciao Pierfrancesco, benvenuto nel club! Io ho le tue stesse problematiche, stessi tuoi sintomi. Cerchiamo di risolvere assieme sto problema che da parte mia mi sta snervando!

          1. Ciao, mi piace questo spirito di collaborazione tra appassionati 🙂

  15. Ciao Mauro
    L’ho comprato su ebay. Ti informo xo ke provandolo con lo stesso shield e un programma per testare i motori pp, funziona bene e applica una discreta forza…
    Ahh aggiungo anche che il venditore suebay e’ un negozio e non un privato e il motore era venduto come nuovo.
    Luca

    1. Ciao Luca,
      prova a verificare le differenze tra lo sketch di test e quello del Dolly, non faccio cose particolari nel dolly per inviare il comando al motore, tuttavia potrebbe essere lo sketch.

      Mauro

    • Roberto on 19 aprile 2013 at 19:59
    • Reply

    Ciao mauro, allora son di nuovo qua a chiederti aiuto per il Dolly, ho provato di tutto ma nulla non riesco a ca pire cosa ci sia che non funziona. Son riuscito a capire che i pin che possono avere conflitto sono A0 e il pin 8-9-10. Ma sinceramente non so come operare ne per verificare quale sia quello che ha problemi ne dove metter mano sullo sketch per risolvere. Ho capito anche che sono liberi i pin 2, 3 e A2, A3, A4 e A5 che posso usarli come digitali rinominandoli in 16, 17, 18 e 19. Ma altro non so. Disperazione e avvilimento!

    1. Ciao Roberto,
      Vorrei aiutarti ma non so come.
      Partiamo re ordine:
      – il kit é quello di robot-domestici o ci sono delle differenze?
      – la motor shield é originale?
      – hai interrotto le piste in corrispondenza di A0 ed A1?
      – hai verificato che non ci sia continuità ?

      Iniziamo con queste risposte 🙂

      Mauro

      1. Allora il kit non è quello di robot domestici ma i conponenti sono gli stessi, cioè, Arduino Uno Rev 3, il motor shield arduino Rev 3 e LCD Keypa pad della Robot domestici è diverso. Il motor shiedl è originale arduino ed è quello che hai utilizzato tu nel tutorial parte 5.
        Ho interrotto le corrispondenze SNS0 e SNS1 sul motor shield e ho verificato con un voltimetro che non ci sia passaggio di corrente. Per il resto ho le stesse problematiche di Pierfranco, scritta in attesa di comandi su lcd. ho provato uno sketch di verifica tasti per LCd e funzionano tutti ma quando attacco tutte le schede in sequenza mi funzionano solo i tasti right e reset.

        1. Ciao Roberto,
          Ok, prova lo sketch di test dei tasti con tutto montato e verifica se funziona ancora tutto.
          Mi sorge il dubbio che il problema siano dei pin in conflitto tra motor shield e Keypad.

          Ti chiedevo del kit xchè quello l’ho composto io ed ho fatto fatica a trovare componenti e versioni di shield che potessero convivere.

          Mauro

            • Roberto on 22 aprile 2013 at 18:02

            Allora ho fatto un test per i pulsanti trovato al seguente indirizzo
            http://www.dfrobot.com/wiki/index.php?title=Arduino_LCD_KeyPad_Shield_%28SKU:_DFR0009%29
            e i tasti funzionano anche con il motor shield colllegato. Quasi sicuramente come dicesti tu in un precedente post potrebbe essere un conflitto sul pin A0 ma data la mia ignoranza in materia non son riuscito a capire cosa fare per risolvere.

          1. Ciao Roberto,
            se i tasti funzionano con la motor shield inserita, collegata ed alimentata escludo il conflitto sul pin A0.
            Non ti resta che provare con un Debug ossia carichi il mio sketch e ci aggiungi dei comandi di Serial.println dove controlli la pressione dei pulsanti, e verifichi che accetti tali comandi.

            Verifica anche che i valori letti alla pressione di usa un pulsante corrispondano a quelli da me impostati, trovi tutto descritto nei primi articoli del dolly Photo.

            Mauro

  16. Buona sera Mauro, sono di nuovo a chiederti “lumi”, misurando con il multimetro sulla LCD shield disalimentata, in funzione continuità, ho notato che i pulsanti hanno ovviamente un estremo collegato in comune e fanno capo alla fila di Jamper maschi di colore nero, l’altro capo del contatto del pulsante “right” fa capo ad A0, quindi premendo il pulsante “right” il contatto si chiude, l’altro estremo dei contatti dei rimanenti pulsanti “Select, left, up, down”, presumo che debbano arrivare anche loro ai restanti ingressi Analogici, siccome, testando sempre in continuità, questi collegamenti non ci sono, mi potresti dire ad ogni pulsante che ingresso analogico è stato attribuito?

    Grazie 1000

    1. Ciao Pierfrancesco,
      nei precedenti tutorial sul Dolly trovi un’esauriente spiegazione su come funzionano i puldanti della KeyPad LCD.
      Ho scritto anche un tutorial proprio su tale shield e su come utilizzarla e testarla.

      Tutti arrivano ad A0, ma con resistenza differenti.

      Mauro

  17. Buona sera Mauro, ti ringrazio tantissimo del suggerimento (anche se stò per buttare tutto dalla finestra) ho visionato e salvato la pagina dedicata al “Keypad LCD con Arduino – prima parte” che rintengo molto utile, difatti ho effettuato le misure delle resistenze seguendo lo sachema illustrato, anche se con alcune differenze, considerando le tolleranze, i valori si discostano un tantino, tipo a posto della R da 330ohm c’è ne una da 500, a posto della R da 1K c’è ne è una da 1K8, a posto della R da 3K3 c’è ne è una da 4K7, comunque ho caricato lo sketch relativo per il test dei pulsanti il display visualizza alla prima riga: “hai premuto:est” alla secondariga: “0auroalfieri.it” e l’unico valore rilevato è solo quello del pulsante RIGHT che mi visualizza “3” ed il reset che effettivamente resetta il display, per gli altri pulsanti il valore rilevato è sampre “0”.
    Sincerament pensavo che nella produzione di queste schede ci fosse un minimo di controllo di qualità con test relativi prima di metterli in commercio…..
    Ti chiedo di nuovo un aiuto, per uscire da questo tunnell….. grazie Pierfrancesco

    1. Ciao Perfrancesco,
      sul minimo di test io non ci conterei, di tutte quelle che mi sono capitate, circa 45 x un progetto commissionato, ho dovuto lavorare su un buon 20% per correggere lo sketch.

      I valori che rilevi sui pulsanti suggeriscono che tu debba ricalibrare lo sketch nella parte che controlla i pulsanti.

      Se leggi bene tutti gli articoli troverai certamente come testare e modificare i valori dei range pulsanti e tutto funzionerà.
      É un’operazione che puoi fare solo tu in quanto i valori che rilevi sono relativi alla tua shield, la mia ne ha degli altri 🙂

      Mauro

  18. Ciao Mauro, vediamo se ho capito bene, dovrei modificare i valori minimo e massimo relativi ad ogni pulsante, tranne quello che funziona, ho visto che la differenza è circa 40 quasi per tutti tranne RIGTH, ma di quanto devo modifire il valore, come faccio? mi regolo a occhio? per esempio per il pulsantre SELECT impostato con min 720 e massimo 760 modifico prima il massimo carico lo sketch verifico che fuziona …. se contunua a non funzionare dandomi valore “0” ? non sò come devo operare, puoi darmi un suggerimento?

    grazie di nuovo Pierfrancesco

    1. Ciao Pierfrancesco,
      per rilevare il valore alla pressione di ciascun pulsante puoi utilizzare uno sketch semplice son il Serial Monitor di arduino.

      In pratica scrivi:

      void setup() {
      Serial.begin(9600);
      Serial.println(“Start”);

      pinMode( A0,INPUT );
      }

      void loop() {
      Serial.println( analogRead(A0) );
      delay( 500 );
      }

      Caricalo su Arduino, aprì il monitor seriale e intanto che vedi scorrere i valori sul video premi alternatamente i pulsanti leggendo il valore, lo segni su un foglio di carta e poi li scrivi nello sketch del dolly.

      Ricordati di mantenere un +/- 100 valori di margine quando li riporti nello sketch, es.: se leggi 300 metterai valore minimo 200 e massimo 300 facendo attenzione che due range non si sovrappongano.

      Mauro

      1. Ciao Mauro, il suggerimento che mi hai dato è molto interessante ( mi ha anche incoraggiato) dopo aver caricato lo sketch sopra descritto e aprendo il monitor seriale appare il nome della porta, nel mio caso com 3, e uno sotto l’altro dei valori sempre uguali come 1023, tenendo premuto un pulsante alla volta i valori cambiano come segue:

        select –> 816

        left –> 625/626

        up –> 205

        down –> 407

        right –> 0

        Quindi per modificare i valori nello sketch del dolli foto, per esempio al pulsante select sostituisco a 720,760 i valori 716,816 ?

        ancora Grazie Pierfrancesco

        1. Ciao Pierfrancesco,
          ottimo lavoro.
          Io consiglio di mantenenti in un +/- 20 dal punto rilevato:
          per il SELECT hai rilevato 816 imposta minimo 790 e max 826 in modo che 816 cada al centro.

          Ti avevo suggerito +/- 100 ma é troppo come intervallo.

          Fai lo stesso per gli altri a meno del RIGHT che essendo 0 sarà:

          min 0 e max 20

          Prova e dimmi se funziona, sono curioso.

          Mauro

          1. Buona sera Mauro,

            Perfetto !!! caricando il programmino per il test dei pulsanti della KeyPad LCD, opportunamente modificato, dietro tuo suggerimento, alla pressione del pulsante select visualizza valore 1
            left visualizza valore 2
            up visualizza valore 4
            down visualizza valore 5
            right visualizza valore 3 e questo era l’unico che funzionava poiche l’unico valore programmato che coincide.
            Non ho parole per ringraziarti, ora aggiungo la scheda motori, provo ad impostare i dati poi ti faccio sapere.

            PIerfrancesco

    • Stefano Finotto on 30 aprile 2013 at 17:09
    • Reply

    Ciao Mauro,
    Complimenti per il tuo sito e gli argomenti trattati veramente in maniera professionale.
    Ho cominciato a lavorare con la piattaforma Arduino da qualche mese.
    Ho notato la pulizia e presentazione delle tue righe di codice. Volevo chiederti, cortesemente, che editor stai usando: l’IDE di Arduino oppure altro editor.
    Ti ringrazio già fin ora per la tua attenzione.
    Buon lavoro!!!

    Stefano Finotto

    1. Ciao Stefano,
      si uso l’IDE Arduino, in questo momento la versione 1.0.3

      Mauro

  19. Ciao Mauro,

    Ho provato le tre schede unite per pilotare il motore p.p. impostando i primi parametri, ma il motore non si muove come ci si aspetta, compie un passo avanti e uno indietro, solo se lo accompagno gira in senso orario, ti volevo anche fare alcune domande:
    si potrebbe isolare l’alimentazione della sheda motori con quella di arduino ? per poter alimentare arduino a 8 o 9V ed il resto a 12V ? poiche sento che lo stabilizzatore a 5V a bordo della scheda arduino scalda un po, circa 30°C.
    I fili del motore in dotazione al kit sono colorati per riconoscere le fasi, se li collego come tu hai fatto seguendo gli stesi colori sulla morsettiera cioè verde -B, rosso +B, giallo -A, blu +A, può andar bene?
    grazie ancora se poui illuminarmi per questo, speriamo ultimo, problema buona giornata

    Pierfrancesco

    1. Ciao Pierfrancesco,
      Il motore si muove male perché hai invertito i colori, se li colleghi come nel mio esempio e foto ti funzionerà.

      Puoi isolare le alimentazioni se vuoi, non ho ancora provato ma dovrebbe essere possibile.

      Mauro

      1. Ciao Mauro,

        Difatti i collegamenti li ho effettuati come segue: verde -B, rosso +B, giallo -A, blu +A, seguendo l’immagine all’inizio di questa pagina, i led che indicano la fase attiva si accendono, non so se la sequenza è corretta ma si accendono, può dipendere dal motore P.P.?

        grazie ancora per l’aiuto buona giornata Pierfrancesco

        1. Ciao Pierfrancesco, si accendonoimled e funziona ?

          Mauro

          1. Ciao mauro,

            Cercando nei tuoi interessanti tutorial per motori P.P. ho trovato quello “riconoscere le fasi” dove spieghi, anche con il video, come misurare con multimetro in ohm le fasi del motore e testarle poi alimentandole ad impulsi con un alimentazione a 5V, ho effettuato queste prove, pensando che il motore abbia dei problemi, dalle prove si comporta come ci si aspetta, ma collegandolo alla scheda motori, rispettando i colori come nella foto inizio pagina, il risultato non cambia, compie un passo avanti, uno indietro e a volte se imposto, esempio, 20 passi per scatto ne compie solo alcuni, non so cosa altro provare, se puoi darmi una idea ti ringrazio,

            buona serata Pierfrancesco

          2. Ciao Pierfrancesco,
            dalla tua descrizione sembra un problema di sketch, tuttavia io l’ho provato e riprovato e funziona, inoltre altri appassionati hanno realizzato lo sketch e funziona a tutti.

            Mi viene in mente che il problema possa essere la forza di opposizione del carrello, hai provato con il motore a vuoto? Ossia non collegato ad alcuna parte meccanica?

            Mauro

  20. Ciao Mauro,

    Anche se ho una precisa idea di come realizzare la slitta, prima di realizzare la parte meccanica volevo portare a termine quella elettronica, pensando che fosse più semplice, comunque dimenticavo di dirti che i led si accendono in sequensa, non so se è quella giusta comunque si accendono, farò altre prove….
    grazie per l’assistenza

    buona serata Pierfrancesco

    1. Ciao Pierfrancesco,
      Controlla nuovamente i cavi ed i colori, so che lo avrai già fatto, ma se il motore é senza carico io cercherei nei collegamenti il comportamento errato.

      In un mio articolo sui motori passo passo ti mostro anche come provare il motore senza controller, alimentando a mano le fasi, provalo per capire se il tuo motore funziona come ti aspetti.

      Mauro

    • Attilio on 9 luglio 2013 at 00:01
    • Reply

    Ciao Mauro complimenti per il tuo esauriente lavoro. Sono alcuni giorni che sto lavorando per realizzare il dolly, ho riscontrato anche io il problema di conflitto sulla motorshield sul pin A0 risolto utilizzando il pin A5. Ora funziona accedo correttamente a tutte le funzioni del menu ma riscontro un problema con motore passo passo, quando parte si muove vibrando con una coppia quasi nulla ho verificato i cottatti e sono corretti provado infatti il tuo sketch motor shield r3 il motore si muove correttamente in modo fluido senza vibrazioni. Il motore è un nema 23 3V 2A unipolare, ma leggendo le indicazioni della casa produttrice puo essere utilizzato come bipolare. Ho provato anche con un motor bipolare piu piccola e si comporta nello stesso modo. Se provo il comando reset carrello il motore si muove fa dei piccoli scatti avanti e indietro sia su left che su right. Qualche suggerimento?

    1. Ciao Attilio,
      da come lo descrivi sembra un problema di carico del motore, se stai provando il dolly con motore a vuoto, ossia non connesso a nessuna meccanica, potrebbe essere eccessiva la richiesta di 2A per fase alla motor shield, considerando che quel dato si riferisce all’uso come unipolare e in bipolare assorbe di più.

      Il funzionamento con l’altro sketch mi fa dedurre che il problema siano i tempi di pausa tra un passo ed il successivo, prova a verificare se aumentando li il problema si risolve.

      Mauro

    • Attilio on 9 luglio 2013 at 23:10
    • Reply

    Ciao Mauro, le prove le sto facendo con motore a vuoto, ho cambiato motore ora uso un nema 23 bipolare 3v 2A ma il problema persiste anche aumentando i tempi di pausa. Ho fatto un ulteriore verifica con i due schetch che hai fatto per la motor shiels r3 e motor shield FE e ho notato che nel primo esempio se cambio in eseguiStep( 50, true); in false non cambia il senso di rotazione mentre sul secondo esempio quello per la scheda FE la rotazione avviene sia in senso orario e antiorario.

    1. Ciao Attilio,
      in questo sketch non c’è una funzione eseguiStep, quale sketch sai utilizzando?
      Puoi inserire il tuo commento nell’articolo che stai seguendo, mi aiuti a comprendere i tuoi passi e seguirei meglio.

      Mauro

        • Attilio on 10 luglio 2013 at 09:35
        • Reply

        Lo sketch che utilizzo è questo che stiamo commentando, “eseguiStep” era una citazione di un altro sketch utilizzato da me come verifica del corretto funzionamento del mio motore. E ti confermo che il motore funziona, mentre con lo sketch del Dolly Photo no, che altre verifiche potrei fare per individuare la causa del mal funzionamento? Ho provato a semplificare il tuo sketch per mantenere lo la parte di gestione del motore ma di confesso di avere qualche difficoltà.

        1. Ciao Attilio,
          prova a sostituire nella loop() la sola chiamata alla funzione di movimento del passo-passo presente in questo sketch e verifica se il problema è la funzione o il motore con la shield.

          Mauro

    • Attilio on 11 luglio 2013 at 02:08
    • Reply

    Ho inserito la sola chiamata alla funzione di movimento nella loop() il motore gira ma senza coppia lo fermo con una leggera pressione delle dita ma se tolgo il debug funziona bene con una buona coppia. Se mantengo lo sketch originale togliendo il debug il motore perde nuovamente la coppia.

    1. Ciao Attilio,
      il debug non ha effetto sulla coppia al massimo può rallentare il motore.
      hai provato anche con un driver per motori passo-passo ?

      Mauro

    • Angel on 11 agosto 2013 at 02:03
    • Reply

    Ciao Mauro!
    Io sono nuovo all’elettronica. Voglio costruire il arduino dolly timelapse e video, la mia domanda è: con passaggi di cilindrata può fare video o bisogno di cambiare motore?

    Un’altra query di fare timelapse con piattaforma ad angolo inclinato di 45 blocchi motore ° ogni passo appendere? motore passo ha ingranaggi interni in modo che nessun gravità per far scorrere la base con la fotocamera?
    Spero di essere chiaro nella mia spiegazione e anche cogliere l’occasione per congratularmi con voi per questo grande progetto e per condividere le vostre idee

    1. Ciao Angel,
      il progetto Dolly per timelapse è uno dei miei progetti più seguiti e che mi da sempre grandi soddisfazioni.
      Non ho capito alcune domande:

      1. cosa intendi con “passaggi di cilindrata”, vorresti sostituire il motore?
      2. vuoi poter inclinare a 45° la slitta e mi chiedi se è possibile?

      Il motore passo passo non ha ingranaggi interni che si oppongono alla forza di gravità per cui se vuoi lavorare con la slitta inclinata dovrai mantenere il motore in tensione non mandando a LOW i pn del motore per lo stop, ti consiglio di utilizzare un sistema con bilanciamento in modo che il peso della macchina fotografica o telecamera sia compensato da un contrappeso e non incida sul motore.

      Mauro

    • Angel on 12 agosto 2013 at 12:55
    • Reply

    Ciao Mauro!
    Scusate per la mia lingua. Ho tradotto in Google. Io parlo solo spagnolo. e un po ‘di inglese.

    Grazie per la vostra pronta risposta e spero che tu capisca la mia ricerca:

    1 per timelapse con guida scorrimento inclinato a 45 °:
     motoriduttore che uso,
    sostituire il motore passo-passo e sistema a contrappesi?

    2 Voglio fare oltre a sequenze video timelapse:
    è possibile fare timelapse e video nello stesso progetto?

    3 Se si può fare timelapse e video nello stesso progetto:
    motore e di programmazione che uso?

    Attentamente
    Angel

    • germano on 5 novembre 2013 at 12:04
    • Reply

    Salve Mauro,
    per cercare di non incorrere in insuccessi, visto che è la prima volta che mi cimento con Arduino ho acquistato il kit del dolly da Robot Domestici, purtroppo una volta assemblato e caricato il programma l’LCD si comporta diversamente da come mostri nel video.
    Il pulsante che fa partire la scritta ” in attesa comandi… “è il quarto e il tutto non si muove da li’ e non compare null’altro
    Cosa devo fare?, vorrei superare questo primo insuccesso.
    Comunque complimenti per la caratteristica costruttiva

    grazie

    1. Ciao Germano,
      controlla la versione della keypad LCD, alcuni kit hanno la versione 1.0 ed altri la 1.1, negli articoli più recenti dedicati al dolly slider ho descritto le differenze e come correggere lo sketch.

      Un altro sintomo di malfunzionamento è legato alla motor shield arduino, in quanto alcune vesioni presentano due piste in corrispondenza dei pin A0 ed A1 che sono da separare, basta un taglierino, e le riconosci perchè sono composte da due semicerchi.

      Mauro

        • germano on 5 novembre 2013 at 17:55
        • Reply

        Salve Mauro,
        grazie 1000, il primo step è stato risolto

        1. Ottimo Germano

    • Carlo on 3 dicembre 2013 at 17:14
    • Reply

    Ciao Grande Mauro,
    ci siamo sentiti oggi per E-mail.
    Ho tagliato i piedini dei PIN A0, A!1 nella motor shield come hai suggerito. Ma il problema non si è risolto (disperazione più nera).
    Sul visorino LCD) dopo alcuni secondi anche la scritta “in attesa di comandi” sparisce e nessun tasto funziona.
    Mi sembra lo stesso problema – o simile – che ha Germano.
    Puoi suggerirmi qualcosa?

    1. Ciao Carlo,
      hai già letto l’articolo in cui spiego la differenza tra la Keypad LCD usata in questo sketch e la versione 1.1?
      Potrebbe dipendere dalla versione della Keypad LCD che ha valori dei pulsanti differenti tra la ver. 1.0 e la ver. 1.1

      Prova inoltre a caricare lo sketch SerialRead che trovi tra gli esempi dell’IDE arduino o nell’articolo in cui descrivo la differenza tra le due versioni della LCD shield e scrivimi i valori che leggi senza premere nulla e premendo un pulsante alla volta.

      Mauro

        • Carlo on 3 dicembre 2013 at 19:12
        • Reply

        E’ una cosa che ho già fatto seguendo i tuoi consigli ad un altro tuo allievo.
        La mia LCD shield è la versione 1,1 della DFROBOT.
        Le letture Arduino + Lcd shield sono:

        nessun tasto premuto = 1023 ora con le tre schede inserite 365.

        SELECT = 815 ho impostato 800-900
        LEFT = 625 ho impostato 600-650
        RIGHT = 0 ho lasciato 0-20
        UP = 205 ho impostato 150-250
        DOWN = 407 ho impostato 350-450

        1. Ciao Carlo,
          controlla bene la pista in corrispondenza del pin A0 sembra sia ancora collegata.
          Deduco questa informazione dal fatto che senza la motorshield hai 1023 con i tasti non premuti ed aggiungendo la shield leggi solo 365.

          La condizione corretta è la prima.

          Mauro

            • Carlo on 4 dicembre 2013 at 12:56

            Ciao Grande Mauro,
            ti ringrazio per la disponibilità che stai dimostrando.
            Avevo tagliato i piedini dei collegamento sotto la motor shield e A0 ed A1 in corrispondenza delle scritte SNS0 e SNS1.
            Controllando, non vi è più collegamento tra Arduino e la Motor Shield (Anche le saldature mi sembrano OK).
            Ho poi rimisurato ottenendo i valori:
            solo Arduino 330
            Arduino + motor Shield 340
            Arduino + motor shield + LCD shield 340
            E’ corretto pensare che vi è una resistenza che interferisce?
            Grazie ancora per l’aiuto, Carlo

          1. Ciao Carlo,
            perdona la mia domanda ma da quello che scrivi mi sorge il dubbio che tu abbia troncato i pin A0 ed A1 della motor shield è corretto?
            Questo sarebbe un errore in quanto io ti ho suggerito di interrompere le connessioni sulle piste dalla motor shield in corrispondenza dei pin A0 ed A1 e non di recidere i pin.

            Recidendo i pin hai interrotto il collegamento tra la keypad lcd e arduino.

            Mauro

    • Carlo on 4 dicembre 2013 at 13:57
    • Reply

    Ciao Mauro,
    Hai capito bene.
    l’ignoranza mi ha fatto fare una stupidaggine, anche se il dubbio l’avevo.
    Vedrò di riparare in qualche modo.
    Però, scusa sono un poco tonto, non capisco bene cosa intendi per “interrompere le connessioni sulle piste della motor shield in corrispondenza dei pin A0 ed A1”.

    Carlo

    1. Ciao Carlo,
      per risolvere il problema puoi usare un cavetto di quelli per breadboard, da un lato lo inserisci al pin A0 di arduino e l’altro capo lo saldi sul pin A0 della Keypad, in questo modo risolvi anche il primo problema delle piste.

      Per il quesito sulle piste in corrispondenza di A0 ed A1 devi partire dal pin A0 sul lato inferiore della motor shield e seguire la pista elettronica stampata sul circuito, ad un certo punto trovi una piazzola tonda divisa in 2 ( sembrano due semisfere ) il taglio da praticare è in mezzo alle semisfere.

      Mauro

    • Carlo on 4 dicembre 2013 at 19:26
    • Reply

    Ciao,
    sempre lo scocciatore che spera di uscirne fuori e che abusa della tua pazienza.

    Risolto e verificato che funzioni con i cavetti come hai suggerito.

    Per il secondo punto, per ovviare altre scemenze, intendi con un bisturi incidere verticalmente tra le piazzole sopra SNS0 e SNS!1 sotto la scritta disable?

    Abbi pazienza, Carlo

    1. Ciao Carlo,
      sei fantastico e non preoccuparti gli errori li commettiamo tutti il bello é riuscire a ripararli.
      Se hai fatto il ponte tra A0 arduino ed A0 Keypad non c’è bisogno di incidere le piste in quanto il taglio dei pin sulla motor shield interrompe di fatto la connessione tra arduino e la Keypad per i pin A0 ed A1.

      Considera che l’unico pin che ti serve per il progetto Dolly é il pin A0 a cui sono collegati i pulsanti, se un giorno aggiungerai i finecorsa dovrai usare anche gli altri pin analogici.

      Mauro

    • Filippo on 13 dicembre 2013 at 13:19
    • Reply

    Ciao Mauro,
    per il progetto che sto facendo mi piacerebbe inserire il valore della variabile nelle impostazioni tramite un tastierino numerico. Come consiglieresti di fare in questo caso? E’ possibile farlo senza sconvolgere il tuo codice? Grazie mille

    1. Ciao Filippo,
      interessante evoluzione.
      Per farlo dovrai far in modo che ad ogni richiesta di inserimento dati l’impostazione sia recepita dal tastierino.
      Ti consiglio di utilizzare una funzione che recepisca l’input da tastierino e imposti la variabile.

      Mauro

    • Gerard on 13 dicembre 2013 at 14:05
    • Reply

    Bonjour
    J’ai enfin trouvé une réalisation complète, super travail et bravo pour le partage auprès de la communauté.
    Je vais tenté de la réaliser.
    Mais je n’ai pas trouvé le schéma complet du montage, en particulier la commande de déclenchement de l’AP.
    j’apprécierais d’avoir une vue d’ensemble des connections.

    Merci

    Gérard

    1. Bonjour Gérard,
      merci.
      Le projet est décrit dans plusieurs articles.
      Il est un kit que vous pouvez acheter des robot-domestici.it et assembler avec mes instructions.

      Mauro

    • Simone82 on 18 dicembre 2013 at 20:04
    • Reply

    Ciao Mauro,
    sono un fotografo che da tempo vuole estendere le possibilità dei suoi timelapse senza però potersi permettere le cifre iperboliche dei dolly professionali. Ho provato, seguendo i tuoi tutorial, a configurarmi il mio controller, ma temo di aver completamente sbagliato componenti. Infatti ho preso
    Arduino UNO SMD edition
    Motor Shield V2 della seeed studio con chip L293
    Wantai motor da 1,7A e 2,8V

    Mi sono voluto buttare in questo mondo senza avere particolare dimestichezza con le questioni di corrente, pensando che alla fine il modo di funzionare lo si trovava in caso di problemi. La scelta del motore era legata alla necessità di movimentare un grosso carico di attrezzatura professionale, diciamo almeno 3Kg.
    Rimani di fatto la mia ultima speranza di poter terminare il progetto.
    Sulla Arduino UNO SMD posso montare il Motor Shield R3 con il display LCD del progetto “Dolly Photo”? O devo comprare per forza la UNO tradizionale? Che poi mica ho capito qual’è la differenza, ignorante come sono… 😕
    Un ultimo consiglio, conosci un motore compliant con le caratteristiche che ti ho indicato e la shield? Oppure posso usare anche la mia? E in caso contrario, quali sono le caratteristiche dei motori che devo guardare? Perché girovagando sul web pare che a prezzi decenti o l’amperaggio è troppo alto o il voltaggio è troppo basso, e spendere centinaia di euro per i motori giusti non mi pare che valga la pena…
    Attendo con impazienza la tua risposta, sarebbe per me un grande regalo di Natale poter terminare questo progetto che trascino oramai da mesi…

    1. Ciao Simone,
      il Dolly è senza dubbio uno dei progetti più seguiti, come vedi anche dai commenti.
      L’Arduino UNO SMD non ho mai avuto modo di provarla quindi baso la mia risposta sulla lettura del Data Sheet pubblicato sul sito ufficiale.

      Per il progetto Dolly non dovrebbero esserci differenze tra l’una e l’altra scheda.
      Se dovessi consigliarti una shield per il controllo motori ti indicherei la BigEasy driver che è un driver specifico per motori passo-passo a cui ho dedicato un articolo e che potresti adattare al tuo scopo.

      Il motore che uso nel kit Dolly distribuito dalla robot-domestici.it mi sembra abbia caratteristiche che possono soddisfare le tue, tuttavia la scelta del motore dovresti farla in funzione della coppia che ti occorre sviluppare in trazione; movimentare 3Kg è un informazione insufficiente in quanto dipende dal tuo carrello, dalla meccanica che hai scelto, dallo sviluppo delle forze in gioco, tutti parametri che io valuto in modo empirico non avendo le competenze per farlo meccanicamente, ti consiglio di rivolgerti ad un perito o ing. meccanico.

      Se proprio non dovessi riuscire a realizzare il tuo progetto posso valutare il tempo ed il costo che mi occorrerebbe se mi inviasi tutti i tuoi componenti e provvedessi io a realizzarlo per te.

      Mauro

        • Simone82 on 19 dicembre 2013 at 19:23
        • Reply

        Grazie Mauro per la risposta. Allo stato del mio progetto mi piacerebbe di più trovare la “pappa pronta”, lo so non fa parte dello spirito di queste comunità ma un neofita come me farebbe fatica a contribuire, e ho paura che parlare di mettere mano al codice per riadattarlo sia per me operazione troppo complessa.
        Ho visto che Robot Domestici da cui si prende il Dolly Photo ha tutti i componenti disponibili, potrei provare sempre a chiedere a loro se possono indicarmi qualche cosa. Anche contattando un ing. meccanico potrei ben poco spiegargli le caratteristiche meccaniche dei miei dolly: nell’un caso è una base di legno che tramite ruote per rollerblade scorre su un tubo in PVC, nel secondo caso è un prodotto preconfezionato, devi pensare ad una cosa come questa che vuol dire poco ma che è il massimo che posso fornire
        http://www.linkdelight.com/P0003228-Pro-39-/100cm-Linear-Camera-Track-Dolly-Slider-for-Photography.html

        Penso che se la SMD non ha problemi come dici, prenderò le componenti che mancano per costruire il dolly secondo il tuo progetto, con tanto di sbattitori per la corsa. A questo punto dovrei andare tranquillo, immagino che quel motore nel kit del progetto sia sufficiente per fare ciò che mi serve anche qualora inclinassi leggermente il dolly. In ogni caso la Big Easy potrebbe essere compatibile con il mio attuale motore da 2,8V? Perché potrei provare in quel caso a sperimentare, avendo però un dolly funzionante con cui poter completare i miei progetti fotografici. 🙂

        1. Ciao Simone,
          comprendo che non tutti possano sbattere la testa sull’elettronica ed arduino 🙂 avrai già i tuoi muri su cui farlo.
          In anteprima poso dirti che sto ultimando con un ing. elettronico e un regista professionista un Dolly con caratteristiche semiprofessionali che metteremo in vendita tra gennaio e febbraio con elettronica basata su arduino e meccanica semplificata.

          I test meccanici e la scheda elettronica è in fase di ritocchi in questi giorni.

          Se sei interessato iscriviti alla newsletter del blog o segui il blog perchè annunceremo il prodotto appena pronto per la vendita.

          Mauro

            • Simone82 on 30 dicembre 2013 at 10:01

            Ho già chiamato i muratori per il restauro in effetti 😀
            Sono già iscritto e grazie per l’annuncio, termino la mia versione pezzotta e appena disponibile il vostro comincerò a farci un pensierino… A presto allora, verrò certamente a romperti le scatole di nuovo.
            Nel frattempo Buone Feste e Buon Anno! 🙂

          1. Grande Simone,
            Auguri di buone feste !!!

            Mauro

    • Simone82 on 8 gennaio 2014 at 01:09
    • Reply

    Ciao Mauro,
    eccomi come promesso a romperti le scatole di nuovo… E anche stavolta senza aver cominciato ancora. Naturalmente ho visto il codice aggiornato alla versione 2, ma per continuità proseguo le mie domande in questo post. Oggi ho ritirato i pezzi da Robot Domestici… Corro a casa, collego tutto e magicamente… non funziona! 🙁
    In pratica, se collego il keypad alla UNO tutto regolare, se collego il keypad alla motor shield che è collegata alla UNO, tutto si blocca in “attesa dei comandi” e non c’è nulla da fare… Problemi di alimentazione? Qualcos’altro? Per di più il motore non ne vuole sapere di girare: fa uno strano fruscio ma niente altro. Ergo ho scollegato tutto nella speranza di non aver bruciato nulla. Il mio alimentatore switcher garantisce fino a 12V e 5A, quindi non credo di essere sottodimensionato… Qualche suggerimento?

    1. Ciao Simone,
      se leggi nei commenti degli altri utenti troverai due possibili cause:
      1. in corrispondenza dei pin A0 ed A1 sulla motor shield troverai due piazzole che devi tagliare con un taglierino perché creano conflitto con i pulsanti;
      2. verifica la versione della Keypad in quanto tra la v1.0 e la v1.1 i valori per rilevare la pressione dei pulsanti varia ed ho scritto un articolo in cui spiego come modificare lo sketch.

      Mauro

        • Simone82 on 8 gennaio 2014 at 21:20
        • Reply

        Grande Mauro, se non esistessero i nerd evoluti (non ti offendi vero? 🙂 ), noi nerd appena nati ci schianteremmo subito contro un muro… Grazie anche per la pazienza di rispondere sempre alle stesse domande perché gli internettiani non sono usi a leggere decine di commenti dove trovano tutte le risposte…
        Allora vado per gradi: leggendo i commenti avevo interpretato che la mia scheda avesse già le piazzole tagliate… Errore, con il tester ho controllato il passaggio di corrente, ho “scartavetrato” con taglierina e ora funziona correttamente anche tramite motor shield… E 1 problema è andato 🙂
        Sistemato questo, ricaricato lo sketch, funziona tutto perfettamente!!! Evviva, posso cominciare a far muovere il mio dolly manuale!!! 😀
        Fatto questo, potrò passare alla costruzione dei fermacorsa… Ma già so che a saldare tutti quei componenti diventerò scemo, ma prometto che per questo ti verrò a rompere le uova nel paniere nel post dedicato 🙂

        1. Ciao Simone,
          non mi offendo, ma non mi ritengo un evoluto 🙂 ci sono milioni di cose che vorrei saper fare e ancora ho tanta strada davanti.

          Per i finecorsa c’è un post specifico per il dolly con i finecorsa ottici che trovo davvero pratici da saldare con la loro basetta dedicata, prova.

          Mauro

            • Simone82 on 9 gennaio 2014 at 19:19

            Già acquistati infatti, aspetto che mio padre mi porti il saldatore così posso cominciare a metterci mano. Ho già visto tutto quanto e messo i componenti nella posizione corretta.
            Una domanda che avrà trovato risposta nelle centinaia di commenti a questi post dedicati al dolly photo, ma che ti chiedo di poter chiarificare magari con un post apposito: come lo alimento l’aggeggio? Voglio dire, in casa a corrente, ma nei prati? Allora pensavo ad una batteria da 9V da collegare via power plug ad Arduino, più una batteria al piombo da 12V da 1,2A o 2,2A da collegare al motor shield per alimentare il motore. Quest’ultima al piombo perché vorrei che tutto funzionasse per almeno 6 ore di fila (sempre che una comune alkalina da €2 duri 6 ore).
            In più vorrei riuscire ad alimentare una ventolina da PC (classica 40×40, 12V e <0,1A in genere) con relativo fan controller tipo Zalman Fan Mate 2, dici che ci rientro tranquillamente? Questo per fare una evoluzione ulteriore del progetto di raffreddamento di cui parli a proposito del Dolly di Francesco e che mi è stato di ulteriore ispirazione.

            Ah segnalo un problema: il reset del carrello non funziona. Ovvero gli dico di "riavvolgersi" ma dopo pochi step il motore si blocca, come se arrancasse senza riuscire a girare. Da cosa può dipendere?

          1. Ciao Simone,
            l’alimentazione dei progetti é un argomento sempre un po’ complesso sopratutto quando ti trovi in presenza di parti meccaniche e condizioni ambientali variabili come può essere un prato.

            Il consiglio migliore che posso darti é di montare tutto il progetto, elettronica+meccanica, far partire un ciclo di lavoro simile a quello che vorresti realizzare in esterno e misurare l’assorbimento di tutto il progetto mentre é in funzione, anche con la macchina fotografica montata.

            In questo modo avrai una simulazione attendibile del consumo orario per dimensionare la batteria.

            In merito al reset carrello automatico funziona solo in presenza dei finecorsa, questa funzione senza i finecorsa non deve essere utilizzata perché può causare un malfunzionamento di tutto il progetto.

            Mauro

    • Simone82 on 10 gennaio 2014 at 10:31
    • Reply

    Grazie Mauro per il chiarimento sui reset, non lo toccherò più fino al montaggio dei finecorsa.
    Capisco la complessità del problema dovuta a svariate variabili in gioco, che dovrebbero essere misurate molto attentamente per definire una dimensione certa del progetto. Purtroppo non ho le competenze e gli strumenti per fare queste misurazioni, quindi devo cercare di affrontare il problema per via un po’ empirica.
    Approfondendo meglio online, anche leggendo alcuni tuoi post, ho capito che per Arduino serve almeno una batteria da 9V e 1A per garantire un funzionamento di una ventina di ore, per tutto il resto del pacco serve almeno una batteria da 7,2A se non anche 9A per garantire le 6 ore di funzionamento in full load che vorrei. Chiaro che tra passo e passo ci saranno delle pause che lasceranno il progetto in idle, consumando di conseguenza meno batteria allungandone al contempo la vita utile. L’unica domanda a cui non saprei dare risposta è la seguente: il keypad LCD da chi viene alimentato e quanto consuma? Non sono riuscito a trovare questi dati online purtroppo, oppure non li ho compresi. Teoricamente, essendo il keypad collegato al motor shield, prende l’alimentazione da quest’ultimo e quindi “grava” sulla batteria ad esso collegato. Ma magari sbaglio, e le due shield sono alimentate entrambe da arduino, mentre la batteria collegata al motor alimenta soltanto il passo-passo. È questo concetto di chi alimenta chi che mi sfugge in realtà e che vorrei capire anche per applicazioni future. 🙂
    La macchina fotografica non la considero, poiché ha una sua batteria e grazie al Magic Lantern il timelapse lo faccio integrato interno: non sarà perfettamente sincrono, ma allo stato attuale non ho le capacità per costruirmi il connettore necessario e programmare alcune delle funzioni che mi servono oltre il semplice timer di scatto. Magari per questo ci si potrà risentire in futuro. 😉

    1. Ciao Simone,
      tutte le shield sono alimentate attraverso arduino.
      Non saprei dirti quanto assorbe la keypad LCD, dovrai fare dei test empirici.

      La macchina fotografica incide con il suo peso sul lavoro che dovrà fare il motore per questo va considerata nel complesso della corrente necessaria.

      Mauro

        • Simone82 on 11 gennaio 2014 at 01:16
        • Reply

        Hai ragione, questo parametro della macchina lo dovrò verificare in varie posizioni, purtroppo solo quando avrò tutto montato e funzionante. In ogni caso mi sono orientato dopo queste “rivelazioni” sul seguente sovradimensionamento che penso regga sufficientemente.
        Per Arduino e le shield una batteria da 12V e 7,2A via power plug, è compatibile giusto? Facendo due rapidi calcoli, Arduino 0,05A, motor shield 0,15A, la keypad accesa mettiamo anche 0,2A (tanti imho), posso lavorare per 10 ore di fila tranquillamente (tenendo sempre presente che questo è un calcolo in full load, condizione che non è costante in un dolly photo).
        Per il motore e una ventola di raffreddamento che vorrei montare per totali 0,4A di picco il già citato 12V e 12A.
        Dovrei essere ampiamente nei margini sia in termini di durata che in termini di lasciare un abbondante 20% di carica residua sulla batteria, come consigliato in tutti i manuali. Anche qualora in futuro dovessi passare ad un motore magari più potente che assorbe di più. 🙂

        1. Ciao Simone,
          la certezza l’avrai solo dal test finale 🙂 ma i margini mi sembrano buoni.
          Informami sul risultato che magari pubblichiamo la tua esperienza se ti va.

          Mauro

    • Luca Massagrande on 17 gennaio 2014 at 18:19
    • Reply

    Ciao Mauro ho costruito uno slider e ho acquistato il kit da robot domestici, montato tutto e avevo il problema dell lcd shield ho separato i pin e questo è risolto.
    Però mi è spuntato fuori un nuovo problema, premetto che il motore è collegato nel modo giusto ma non ha il minimo di forza da scarico figuriamoci a pieno carico, inoltre quando vado a fare il reset manuale fa uno step avanti e uno indietro vai a sapere il perchè.
    Grazie per l’aiuto 😀

    Luca

    1. Ciao Luca,
      dalla descrizione che mi ha i dato sembra che tu abbia invertito le fasi e questo causa esattamente il problema che evidenzi.
      Per fare un test puoi invertire le coppie tra loro e verificare se il problema si risolve.

      Mauro

    • Max on 28 gennaio 2014 at 19:12
    • Reply

    Ciao Mauro
    scusami ancora il disturbo, vorrei chiederti un’ultima informazione,
    in un futuro (molto vicino) vorrei integrare il progetto dolly con una testa girevole, (movimento pan) mi chiedevo quale soluzione potrei adottare,
    sempre mantenendo un solo controller che gestisca i due movimenti slide + pan in modalità Shoot-Move-Shoot con questo motore per la testa girevole
    http://www.emmeshop.it/product.php?id_product=326
    secondo te potrebbe bastare l’inserimento di un’ ulteriore motor shield arduino integrando il codice, ma forse non ci sono più “pin” disponibili !!!
    ciao e grazie

    1. Ciao Max,
      hai centrato il punto, i pin 🙂 sono quella cosa che non basta quasi mai.
      Per aggiungere un secondo motore di controllo ti consiglio di togliere la motor shield e di costruirti una tua shield con doppio driver della pololu per passo-passo, non mi sembra ne esistano in commercio per cui dovrai autocostruirtela come ho fatto io per alcuni Dolly ( vedi Matteo )

      In alternativa sarà a breve disponibile un controllo per dolly già dotato di Arduino e controlli per due motori passo-passo e due DC proprio per il controllo della slitta e della testa remotata, l’ho progettato insieme ad un Ing. elettronico e lo stiamo producendo.

      Mauro

    • Filippo on 31 gennaio 2014 at 15:39
    • Reply

    Buongiorno mauro,
    ho un problema: quando vado ad impostare un mio parametro nelle impostazioni posso scrivere numeri fino a quattro cifre. Per esempio se voglio scrivere 86400 fin quando arrivo a 8640 tutto ok ma poi non mi da più il numero voluto su display: che tipo di problema può esserci secondo te? Grazie mille per l’aiuto

    Filippo

    1. Ciao Filippo,
      ti riferisci a questo sketch?
      Se la tua risposta è si, è possibile che sia solo un problema di visualizzazione che ti nasconde l’ultima cifra.

      Mauro

        • Filippo on 1 febbraio 2014 at 04:53
        • Reply

        si si ho utilizzato il tuo sketch….cosa intendi per problema di visualizzazione? Come può essere risolto? Grazie mille

        Filippo

        1. Ciao Filippo,
          semplicemente che il numero di caratteri visualizzati sia 4 e quindi numeri di 5 cifre vengono visualizzati oltre la linea di 16 caratteri.

          Mauro

            • Filippo on 4 febbraio 2014 at 13:28

            Ho capito….quindi è un problema del codice? cioè si può modificare il numero di caratteri visualizzati? Grazie e scusa se le domande possono sembrare un po’ stupide!

          1. Ciao Filippo,
            si potrebbe essere solo un problema di lunghezza della stringa.
            Prova a ridurre i caratteri del testo 🙂

            Mauro

    • Riccardo on 21 febbraio 2014 at 14:01
    • Reply

    Ciao Mauro, bel lavoro! Finalmente sono riuscito a trovare tutti i pezzi necessari per questo fantastico progetto, purtroppo la keypad lcd che ho trovato non è della dfRobot ma ITEAD studio . I pin non sono in conflitto (identici alla dfRobot) e i valori letti dal pin A0 quando impilo la keypad SOLO con arduino sono identici a quelli della shield che hai usato (1023, 490 ecc). Il problema si pone quando impilo Arduino, Motor Shield e Keypad: invece di leggere 1023 legge SEMPRE 32, e premendo i tasti il valore cambia di pochissimo e a volte non cambia proprio (non riesco a fare nulla ). Guardando i due schemi delle Key Pad :
    dfRobot –> http://www.dfrobot.com/image/data/DFR0009/LCDKeypad%20Shield%20V1.0%20SCH.pdf
    ITEAD–> http://itead-europe.com/pm/platform/shield/1602%20lcd%20shield/SCH_IM120417018_Arduino1602LCDShield.pdf
    nei due schemi ho notato delle differenze nel collegamento dei pulsanti, ma non riesco a capire per quale motivo solo con arduino i valori siano corretti e il menù funzionante ma se aggiungo la motorshield i valori sono praticamente fissi e non riesco a fare nulla . Cosa ne pensi?

    1. Ciao Riccardo,
      da quello che scrivi il problema sembra lo stesso descritto da tanti utenti proprio su questo progetto ossia la motor-shield ha due piste in corrispondenza di A0 ed A1 che servono solitamente per misurare l’assorbimento del motore.
      Come avrai intuito se il pin A0 è quello con cui leggi i valori ed una shield si intromette inviandoti altri valori il risultato è quello che verifichi tu.

      Taglia quelle piste ed il problema si risolverà da solo 🙂

      Mauro

        • Riccardo on 21 febbraio 2014 at 19:36
        • Reply

        Grazie per la risposta ultra rapida 🙂 Premetto che non sono esperto in questo campo, ho imparato a usare arduino grazie ai tuoi vari progetti:) La prima cosa che ho pensato era il conflitto tra i pin (strano però perchè sono gli stessi utilizzati dalla keypad della dfRobot), allora con dei jumper M\F ho collegato i pin della mia keypad con la motorshield con una piccola modifica -> la lettura avviene tramite il pin A2 (non più A0 )
        Ovviamente modificando i collegamenti dovevo modificare lo sketch. Ho quindi modificato la voce #define BUTTON A0 con #define BUTTON A2 ma purtroppo nulla, stesso identico problema.
        Adesso vorrei provare a connettere la motorshield con dei jumper escludendo il pin A0 e poi collegare la keypad alla motor shield sempre tramite jumper collegando direttamente il pin A0 ad arduino senza passare per la motor. Potrebbe funzionare? Grazie:)

        1. Ciao Riccardo,
          é tutto più semplice se interrompi la piazzola in corrispondenza A0, io lo faccio con un taglierino, se domani vorrai ripristinarla basta una punta di stagno, sono fatte proprio per far questo.

            • Riccardo on 22 febbraio 2014 at 17:14

            Funziona 🙂 Grazie mille

          1. Bene Riccardo, sono contento che i miei consigli ti siano stati utili.

    • Gianluca on 30 giugno 2014 at 18:01
    • Reply

    In tanto complimentissimi per la realizzazione. io la sto copiando papale papale ma purtroppo no ho lcd con i pulsanti come il tuo quindi come porei fare per utilizzare dei pulsanti esterni? Grazie e ancora complimenti
    Gianluca

    1. Ciao Gianluca,
      io consiglio l’uso del kit in vendita da robot-domestici in quanto l’ho creato proprio per semplificare il lavoro elettronico.
      Puoi sostituire i pulsanti costruendoti una serie di pulsanti e resistenze come descritto in altri articoli sul blog, dovrai riscrivere tutta la parte relativa al controllo degli input e applicarli allo sketch.

    • Gianluca on 16 luglio 2014 at 13:11
    • Reply

    Grazie !

    • Periglio on 26 luglio 2014 at 22:33
    • Reply

    Ciao Mauro, innanzitutto grazie per il supporto che ci dai. Ho preso il kit per il dolly photo e dopo qualche giorno di prove sono arrivato a montare il tutto e a caricare lo sketch. Va tutto bene, riesco a entrare nei vari menu e a programmare il dolly solo che al momento dell’avviamento il motore non gira. Sia se vado su reset carrello che in modalità automatica il motore tende a fare dei micro spostamenti in avanti e indietro.
    Come posso risolvere il problema?
    Ho alimenteto arduino da pc e la motor shield con alimentatote esterno a 5V (4,47V)
    Ti ringrazio anticipatamente.
    Periglio

    1. Ciao Periglio,
      sono contento che tu sia riuscito a montare il kit.
      Ti chiedo se questa anomalia si verifica sia che il motore si trovi collegato alla tua meccanica sia a vuoto?

        • periglio on 30 luglio 2014 at 11:16
        • Reply

        Ciao Mauro il problema si verifiva a vuoto.
        Non ho ancira la parte meccanoca.
        Ho provato a cambiare motore(entrambi di recupero)
        ma la situazione non cambia.
        Grazie

        1. Ciao Periglio,
          non stai usando il motore presente nel mio kit, ora mi è chiaro il motivo del comportamento errato.
          Se usi motori differenti devi collegare correttamente le fasi e la sequenza così come descritto nel progetto per il motore passo-passo.

          Se non sai come riconoscere le fasi dei tuoi motori trovi degli interessanti articoli corredati da video nel blog che ti spiegano come fare.

          Mauro

            • periglio on 30 luglio 2014 at 14:31

            Grazie Mauro. Una curiosità, ho testato la shield motor control provando il progetto presente nel blog e funziona correttamente. Utilizzando gli stessi collegamenti alle fasi ma traspotrando la scheda sul progetto del dolly presenta il problema che ti ho descritto. La soluzione è comunque da ricercare nella giusta individuazione delle fasi?
            Grazie ancora e scusami per il disturbo.

          1. Ciao Periglio,
            usando la stessa motor shield ed il medesimo motore?
            Non dovrebbe accadere, controlla tra i due sketch quale sia la differenza nella polarizzazione delle fasi, se sono identiche ( e di solito lo sono perché io utilizzo quasi sempre la medesima sequenza ) il problema é da ricercare in qualche conflitto tra le shield che stai utilizzando per il dolly, anche se avendo acquistato il mio kit da robot domestici é la prima volta che mi capita xchè io i kit li assemblo e testo tutti più volte prima della vendita.

    • periglio on 31 luglio 2014 at 12:25
    • Reply

    Grazie Mauro. Adesso farò delle
    prove e ti farò sapere.
    Grazie ancora.

    1. ok, Periglio.

        • Periglio on 1 settembre 2014 at 18:01
        • Reply

        Ciao Mauro scusa per il mega ritardo ma solo oggi ho trovato un po di tempo. Ho controllato le fasi del motore e il progetto funziona. Devo solo capire come impostare bene i parametri. Che alimentatore hai usato per alimentare la motor shield?
        Grazie e buona serata.

        1. Ciao Periglio,
          io per i miei progetti uso un alimentatore da banco che eroga 0-30v 0-10A in quanto spesso restano progetti da laboratorio.
          Ricorda che Arduino è meglio non alimentarlo oltre i 12v.

    • Massimiliano on 6 gennaio 2015 at 20:44
    • Reply

    Ciao Mauro oggi ho montato il kit del dolly da te consigliato, dopo aver fatto alcune modifiche al codice (buona parte prese dai tuoi articoli), di mio ho implementato il sottomenu di impostazioni aggiungendo la voce per il reale tempo di posa della reflex e tutte le stringhe di codice necessarie alla gestione e esecuzione di questo tempo, così da poter governare il pin 2 e di conseguenza la reflex in BULB e far gestire tutta la sincronizzazione movimenti/scatto da Arduino, il menu funziona perfettamente gestisco i tempi in millesimi di secondi (come da tuo articolo) solo che invece di incrementare con i pulsanti di 1 o 10 milli secondi ho deciso che per me era più comodo incrementare di 100 ms e decrementare di 10 ms, fin qui tutto ok funziona tutto scatta come e quando dico io ma il motore non si muove.

    Il motore è un SM-42BYG011-25 (credo che sia uguale a quello del kit visto che dalla spedizione invece di mandarmi un passo passo mi hanno mandato un moto-riduttore dc da 12 volt.) ho identificato le fasi utilizzando utilizzando il datasheets, ho permutato i fili sulle uscite della motor-shield in tutti i modi possibili ma il motore il massimo del movimento che fa è 1 passo avanti 1 passo indietro, alla fine ho anche provato a collegare una sola fase per volta e ho riscontrato che sull’uscita A della motor-shield entrambe le fasi del motore creano questo movimento di un passo avanti un passo indietro mentre se le collego all’uscita B della motor-shield il motore non da segni di vita, il codice delle fasi non l’ho toccato e alimento tutto con un alimentatore 12 volt 2 A, cosa devo fare? ricomprare la motor-shield? ho sbaglio ancora qualcosa.

    1. Ciao Massimiliano,
      puoi provare la shield con uno sketch differente per motori cc e con il motoriduttore a 12v per verificare che sia funzionante su entrambi i canali A e B. Se la shield non presenta problemi con uno sketch per motori cc non dovrebbe averne neppure con un passo-passo.
      Un’altra verifica che puoi eseguire è che le piazzole in corrispondenza di A0 ed A1 siano correttamente separate.

        • Massimiliano on 7 gennaio 2015 at 11:03
        • Reply

        Ciao Mauro grazie della risposta sono prove che cercherò di fare al più presto per quanto riguarda le piazzole SNS0 E SNS1 le avevo già separate perché come per altri avevo il problema della pulsantiera della scheda lcd che non funzionava, ho anche separato il come ultima spiaggia il ponticello del VIN per separare le alimentazioni di Arduino motor-shield.

        Mentre leggevo la tua risposta mi è sorto un altro dubbio le piazzole in corrispondenza dei piedini 8 e 9 quelle del brake disable come devono essere?

        1. Ciao Massimiliano,
          le piazzole “brake disable” dovrebbero essere già separate dalla fabbrica, controlla che lo siano.
          Io nello sketch non uso il brake della scheda

            • Massimiliano on 7 gennaio 2015 at 14:13

            Si vero infatti nello sketch non ci sono ma sulla scheda sono ponticellati (passa corrente) tra loro non vorrei che fossero loro ad interferire sul funzionamento creando dei conflitti hardware.

          1. Ciao Massimo,
            separali in modo da escludere che possano influire sul funzionamento del progetto.

    • Massimiliano on 8 gennaio 2015 at 19:41
    • Reply

    Buona sera Mauro Grazie per i consigli dati il problema è stato risolto tagliando i ponticelli del “brake disable” in corrispondenza dei piedini 8 e 9, ora funziona tutto correttamente.

    1. Grazie Massimo per la condivisione lo aggiungeremo alle note del progetto 🙂

    • Paolo on 18 marzo 2015 at 14:26
    • Reply

    Salve per prima cosa davvero tanti complimenti per il lavoro svolto e per condividere tutto!

    La mia domanda è questa, vorrei cimentarmi nella costruzione di uno slider utilizzando questa guida. Ma vorrei che fosse anche uno slider video. E possibile poi modificare il programma?

    Ad esempio, accendendo il tutto il menu potrebbe essere una cosa del genere:

    – Photo
    –come da guida
    – Video
    –Impostare timer percorrenza completa della slider

    1. Ciao Paolo,
      tutto è possibile effettuando le dovute modifiche, è il bello di arduino e dei progetti realizzati con questo micro controllore.
      Io sono un paio d’anni che lavoro a questa versione ed ad una versione con slider video e spero presto di riuscire a proporre un prodotto completo.

    • Giorgio on 21 ottobre 2015 at 18:49
    • Reply

    Ciao Mauro
    ti scoccio ancora e sempre io, ho montato tutto il kit che consigli e ho interrotto tutti i collegamenti sotto alla motor shield ma il motore quando faccio partire il programma vibra solamente e non si muove, alimento arduino con alimentatore e shield con batteria 12v 7Ah… è possibile sia la scheda difettata ?
    Non so davvero come risolvere, adesso provo a ricomprare la motor shield
    ti viene in mente qualcosa ?

    grazie

    Giorgio

    1. Ciao Giorgio,
      la vibrazione del motore dipende, spesso, dalla eccessiva velocità con cui fai succedere le fasi, se diminuisci quella dovrebbe risolversi.
      Mi sembra strano che si verifichi questo comportamento del motore, il kit venduto da robotics-3d.com è stato testato da me con quel motore.

    • Giorgio on 22 ottobre 2015 at 13:16
    • Reply

    Infatti mi sembra molto strano.. Per diminuire il tempo tra le fasi lo faccio dalle impostazioni prima dell’avvio ? Solo una cosa può essere successa, tagliando i collegamenti sotto ho rigato la scheda.. È possibile che abbia interrotto qualche collegamento ?
    Grazie ancora Mauro , sei il numero 1

    Giorgio

    1. Ciao Giorgio,
      controlla di non aver interrotto altre piste oltre a quelle necessarie, tuttavia il comportamento descritto mi sembra più simile ad un errore di timer su fase che ad un interruzione elettrica.

        • Giorgio on 26 ottobre 2015 at 23:32
        • Reply

        Ciao Mauro, Niente ho provato di tutto, ho variato il timer su 25 35 45 60 ma niente, ho notato anche un’altra cosa che forse ti farà pensare a qualcosa, quando muovo tutte le shield il motore vibra o fa movimenti strani, muovendo proprio fisicamente le schede si accendono random le fasi del motore i led lampeggiano ed il motore vibra…
        NON MOLLO !

        Ho appena provato anche il tuo schetch per motori passo passo e la motor shield funziona.. quindi sarà l’lcd che mi fa impazzire il tutto ??

        1. Ciao Giorgio,
          da come lo descrivi sembra un problema elettrico delle shield, non saprei dirti quale in particolare senza una analisi.
          Posso consigliarti di ripulire il codice di tutte le parti che riguardano il display, impostare solo la parte relativa alla rotazione del motore in modo fisso e provare staccando l’LCD

    • Raffaele on 10 novembre 2015 at 18:49
    • Reply

    Ciao Mauro,
    complimenti per il progetto ma io ho un piccolo problema.
    Quando carico lo sketch mi vengono restituiti i seguenti errori:
    D:\Documenti\Arduino\Blink\dolly\dolly.ino:71:77: warning: deprecated conversion from string constant to ‘char*’ [-Wwrite-strings]
    char* principale[4] = {“Impostazioni”,”Verifica”,”Reset Carrello”,”Avvio”};

    D:\Documenti\Arduino\Blink\dolly\dolly.ino:72:151: warning: deprecated conversion from string constant to ‘char*’ [-Wwrite-strings]

    char* secondario[10] = {“Numero passi”,”per scatto”,”Intervallo tra”,”i passi”,”Tempo di ALT”,”prima”,”Tempo di ALT”,”dopo”,”Numero scatti”,”totali”};
    to ‘char*’ [-Wwrite-strings]

    Sinceramente non so dove mettere le mani…..
    Grazie

    1. Ciao Raffaele,
      devi convertire il tipo di variabile utilizzata nello sketch in modo che funzioni con la nuova versione dell’IDE.
      Curiosità: che versione di IDE stai utilizzando ? Io ho provato a ricompilare lo sketch 1 secondo fa con la 1.6.5 senza problemi.

        • Raffaele on 11 novembre 2015 at 20:32
        • Reply

        Ho messo l’IDE 1.6.4 è viene compilato senza errori.
        Però sto avendo problemi con il Keypad LCD della SainSmart. Collegato direttamente ad arduino senza lo shield dei motori, funziona tranquillamente. Se invece monto anche il motor shield, il keypad non risponde ai comandi. Sapresti darmi una dritta? seconde te cosa cambia di un altra marca?
        Grazie

        1. Ciao Raffaele,
          il problema riguarda la motor shield, leggi bene nei commenti in tutti gli articoli dedicati al dolly, è un problema già risolto.

            • Raffaele on 17 novembre 2015 at 19:49

            Ciao Mauro,
            ho letto tutti i commenti e le descrizioni delle tue 5 parti per la costruzione del dolly. Ho lo stesso problema che ti ha descritto Roberto. Nonostante abbia isolato A0 e A1 sulla motor shield, il keypad non risponde ad alcun comando. Se premo sul tasto right si illumina il display ma rimane sempre in attesa di comandi. Il kit l’ho acquistato su robot domestici come tu consigli. Ho controllato anche con il tester la mancanza di continuità lì dove ho reciso i collegamenti. Che devo fare?

            • Raffaele on 17 novembre 2015 at 19:55

            Ah un ultima cosa…. se utilizzo il KEYPAD della SainSmart, funge tutto a meraviglia. Ti ricordo che il Keypad con cui non funziona è quello DFROBOT che esce dal kit.

          1. Ciao Raffaele,
            verifica le tolleranze dei valori restituiti dai pulsanti.
            Spesso la DfRobot aggiorna/modifica le versioni di schede ed è necessario modificare i valori letti sul pin A0.

            Ho anche scritto un articolo con le differenze tra la Ver. 1.0 e la Ver. 1.1 della Keypad Lcd

            • Raffaele on 20 novembre 2015 at 20:37

            Ciao Mauro, ho seguito il tuo consiglio. Ho cambiato lo sketch nel modo seguente e il KEypad funge 🙂

            int SELECT[] = {649,850};
            int LEFT[] = {450,649};
            int RIGTH[] = {0,49};
            int UP[] = {50,249};
            int DOWN[] = {250,449};

          2. Ciao Raffaele,
            ottimo lavoro.
            grazie per la condivisione dei tuoi valori, sai dirmi che versione di KeyPad possiedi così legliamo i valori alla versione per chi ha lo stesso modello.

            • Raffaele on 24 novembre 2015 at 22:51

            La versione del Keypad è 1.1
            Mauro però ho un altro problema che non riesco a risolvere. Quando vado nel reset del carrello, alla pressione ripetuta di left o right il alcuni passi del motore sono il contrario rispetto a quello che ho premuto. Sai aiutarmi?
            Considera che ho provato a vuoto, quindi senza alcun peso di trascinamento. Inoltre tutto il kit è quello che si acquista da robot-domestici.it. Aggiungo che sulla shield del motore ho isolato solo il pin A0 per il keypad.
            Ciao e grazie

          3. Ciao Raffaele,
            controlla che la sequenza delle fasi sia corretta con questo sketch o uno semplificato che puoi derivarti da questo.

            • Raffaele on 25 novembre 2015 at 19:06

            Cioè? Cos’è un semplificato?

          4. Ciao Raffaele,
            uno sketch semplificato che puoi scriverti partendo da questo e che ti chiarisca le fasi di funzionamento del motore.

            • Raffaele on 27 novembre 2015 at 14:13

            Ciao Mauro,
            più che ricavarmi uno sketch semplificato, ho caricato in Arduino lo sketch del link seguente:
            http://www.mauroalfieri.it/elettronica/motor-shield-r3-arduino.html

            Il motore con questo sketch funge perfettamente. Inoltre aumentando il valore TIMEASE a 3000, ho costatato che la sequenza dei led del motor shield è molto diversa dallo sketch del dolly.
            Cosa posso fare?
            Grazie

          5. Ciao Raffaele,
            ho compreso quello che avevi eseguito, prova a fondere i due sketch per capire come mai la sequenza motore su questo funziona e sull’altro no.
            Leggendo le descrizioni di entrambi linea per linea puoi capire come funzionano e quindi le differenze.

            • Raffaele on 29 novembre 2015 at 20:08

            Ciao Mauro,
            più che estrapolare lo sketch per la gestione del motore (cosa che non so fare dallo sketch del dolly), ho controllato le fasi dai LED delle uscite del motor shield. Le fasi che non funzionano sono la 2 e la 4. quando nfase=2 i LED accessi sono entrambi del canale B, mentre con nfase=4 i LED sono tutti spenti. Con lo sketch di esempio che ti ho linkato precedentemente, con nfase=2 è acceso solo il LED B+, mentre con nfase=4 l’unico LED acceso è B-. Non so dove mettere le mani.

          6. Ciao Raffaele,
            se ti suggerisco una strada è perché nel blog trovi tutte le spiegazioni che ti servono per seguirla, a patto di averne voglia e di voler imparare e sperimentare per risolvere il problema.
            Dalla tua descrizione sembra che i pin (PWMA, DIRA, PWMB, DIRB) configurati nello sketch e sulla motor shield siano differenti, puoi controllare questo dettaglio, tuttavia è strano che accada in quanto la motor shield ufficiale arduino non mi risulta abbia cambiato i pin di connessione.

          7. Ciao Raffaele,
            verifica che la sola shield e pressione dei pulsanti restituisca i valori inseriti nello sketch, potrebbe trattarsi solo di una differente tolleranza delle resistenze che non permettono allo sketch di comprendere la corretta ricezione della pressione.

    • Raffaele on 20 novembre 2015 at 23:01
    • Reply

    Ciao Mauro
    ecco un nuovo problema strano….
    Ho risolto il problema di compatibilità del keypad assegnando i valori per ogni pressione dei tasti, ma collegando il motore del kit di robot-domestici.it, mi succedono cose strane. Da premettere che il motore con arduino, motor-shield e keypad funge perfettamente caricando lo sketch per provare il motore passo passo che hai postato in uno dei tuoi articoli.
    Quando però carico lo sketch del dolly, anche se non ho programmato alcun che dal tastierino, il motore vibra in maniera del tutto randomica. Quando imposto tutti i parametri dal menu e avvio l’esecuzione, il motore impazzisce vibrando e spostandosi in maniera del tutto casuale.

    1. Ciao Raffaele,
      inizio a pensare che il sito da cui hai acquistato i componenti non stia rispettando le mie indicazioni e stia inviando materiale differente pensando che non ci siano differenze ma senza un test reale.
      Purtroppo non ho il controllo sui kit che spediscono, io do delle direttive e poi mi fido che le rispettino.

      Dal comportamento potrebbe essere un problema di tempi tra le fasi, prova ad aumentarli.

        • Giorgio on 23 novembre 2015 at 21:08
        • Reply

        Ciao Mauro,
        ti avevo scritto qualche settimana fa perché avevo gli stessi problemi di Raffaele, ho quindi ricomprato l’LCD Shields ma oggi ho riprovato ed il motore vibra come prima, non ricompro la motor shield perché il listato del motore passo passo funziona, quindi deduco che anche la scheda funzioni correttamente a questo punto abbandono il progetto perché non so davvero come risolvere, volevo chiedere se magari Raffaele aveva risolto…
        grazie comunque

        PS ho fatto anche le prove con diverse tipi di fasi…

        1. Ciao Giorgio,
          posso solo suggerirti di modificare la parte di movimentazione del motore con quella dello sketch che funziona cercando poi di verificare le differenze per comprendere come modificare le fasi di rotazione.

    • Alessandro on 22 novembre 2015 at 02:32
    • Reply

    Ciao Mauro volevo chiederti se su questo progetto dolly II dell’unione a sandwich di tre schede dove posso prendere il contatto per lo scatto della fotocamera sempre cablato con relativo fotoaccoppiatore. ho girato tutte e cinque le pagine ma vedo che non ne parla. grazie

    1. Ciao Alessandro,
      se leggi la descrizione dello sketch, che scrivo proprio per aiutarvi a trovare tutte le info che vi servono a realizzare il progetto, troverai il pin a cui è connesso lo scatto.
      Inoltre la lettura e comprensione dello sketch ti aiuterà in seguito se qualcosa non funziona come vorresti o se vuoi apportare delle modifiche.

        • Alessandro on 25 novembre 2015 at 22:49
        • Reply

        è vero ok grazie poi ti farò sapere.

    • Raffaele on 4 dicembre 2015 at 11:38
    • Reply

    Ciao Mauro
    certo che ne ho voglia di risolvere il problema ma non ci riesco!
    Se i pin fossero cambiati l’esempio del link sottostante non dovrebbe funzionare… O sbaglio?
    http://www.mauroalfieri.it/elettronica/motor-shield-r3-arduino.html

    1. Ciao Raffaele,
      hai confrontato i due sistemi di movimentazione ? Sono identici ?

        • Raffaele on 19 dicembre 2015 at 00:29
        • Reply

        Ciao Mauro,
        si sono identici.

        1. Ciao Raffaele,
          allora l’errore di rotazione deve essere dovuto ad un differente valore di TIMEFASE, varialo, per capire se il tuo motore necessita di un tempo superiore tra una fase e la successiva.
          Prossimo passo è verificare le impostazioni che dai alla centralina in fase di funzionamento potrebbero essere errate e causare come effetto la mancata rotazione del motore.

            • Raffaele on 6 gennaio 2016 at 15:39

            Ciao Mauro
            nulla da fare….. con lo sketch per provare il motore, il timefase lo posso scendere fino a 2 senza problemi. La cosa che non riesco a capire è che con lo sketch del dolly, la sequenza dei led relative alle fasi del motore, sono completamente diversi rispetto allo sketch seguente nonostante i case 1, 2 3 e 4 siano identici.
            http://www.mauroalfieri.it/elettronica/motor-shield-r3-arduino.html

          1. Ciao Raffaele,
            l’ultima cosa che mi viene in mente, e non ricordo se te la hai già provata, è di usare il motore a vuoto, non collegato alla meccanica non vorrei fosse un eccessiva richiesta di coppia che il motore non riesce a fornire a causare il problema.

    • Raffaele on 7 gennaio 2016 at 19:30
    • Reply

    Ciao Mauro
    Il motore non è collegato alla meccanica. Ho letto che anche altre persone hanno avuto lo stesso problema è mi piacerebbe sapere se è come lo hanno risolto.

    1. Ciao Raffaele,
      ho scritto molto tempo fa questo articolo ed al tempo l’ho provato, come faccio per tutti i miei progetti verificandone il funzionamento.
      Non so cosa altro ipotizzare sul malfunzionamento che rilevi.
      Come ti ho suggerito nell’ultima mia risposta ti chiederei di provare senza il motore collegato se la sequenza dei led è corretta.

      • Giorgio on 8 gennaio 2016 at 23:18
      • Reply

      Ciao Raffaele
      io ho fatto tutte le prove del mondo ma niente,
      a mio avviso sono diverse le schede che abbiamo comprato, mi da solo fastidio il fatto che con lo sketch dei motori funziona tutto e con questo no. Comparando i due programmi sono identici per quanto riguardano le fasi

        • Raffaele on 9 gennaio 2016 at 12:22
        • Reply

        Ciao Giorgio,
        sinceramente non capisco. Pensa che per andare sul sicuro ho comprato tutto il kit dal sito che Mauro consiglia.

      1. Ciao Giorgio,
        se avete acquistato il kit venduto da robotics-3d.com potete scrivere loro indicando che le schede non vi risultano conformi al mio kit e chiedere una verifica e sostituzione.
        Per altri siti non posso rispondere delle loro azioni in quanto non ho accordi commerciali per i miei kit.

        In ogni caso mi spiace non riusciate a farlo funzionare, avete verificato con i semplici led, senza motore collegato ?

          • Raffaele on 12 gennaio 2016 at 01:40
          • Reply

          Ciao Mauro,
          ho provato senza il motore ma la sequenza dei led è la stessa. Non so se può indicarti qualcosa ma
          nel opzione di reset del carrello, la sequenza dei led premendo il tasto RIGHT è la seguente:
          4°led
          1°led e 2°led
          3°led
          nessuno
          4°led
          1°led e 2°led
          3°led
          nessuno
          e così via

          Il 4°led è quello più vicino alla connessione Vin sulla morsettiera. Naturalmente se premo il tasto LEFT la sequenza è a ritroso.

          Giorgio la sequenza è la stessa anche a te?

          1. Ciao Raffaele,
            la sequenza che mi hai inviato mi dice che c’è un comportamento anomalo sulla 2° fase perché i led 1 e 2 non dovrebbero accendersi insieme e lasciare un buco dopo l’accensione del led 3, da codice questo non è indicato, sei certo del corretto collegamento dei led?
            Tuttavia la sequenza è giusta perché è 1:2:3:4.
            L’esempio inviato, scrivi, si riferisce alla funzione reset e mi era sembrato di capire che quella non funzionante fosse la fase di “avvio” mi chiarisci questo punto per poter eseguire una analisi più dettagliata?

    • Raffaele on 12 gennaio 2016 at 23:17
    • Reply

    I led sono quelli saldati sulla motor shield. La sequenza che ti ho inviato e relativa alla funzione di reset ma anche nella funzione di avvio avviene la stessa cosa.
    Se carico lo sketch che seguente
    http://www.mauroalfieri.it/elettronica/motor-shield-r3-arduino.html
    la sequenza dei led è questa:
    4°led
    2°led
    3°led
    1°led
    4°led
    2°led
    3°led
    1°led
    e così via.

    Con questo sketch che ti ho linkato il motore funziona perfettamente.

    1. Ciao Raffaele,
      la sequenza, come vedi è differente, cosa che non dovrebbe avvenire visto che il codice è il medesimo per il movimento dei motori in entrambi gli sketch.
      ho notato che l’unica significativa differenza è la presenza nella setup() dello sketch che ti funziona delle seguenti linee:

      pinMode(PWMA, OUTPUT);
      pinMode(PWMB, OUTPUT);
      pinMode(DIRA, OUTPUT);
      pinMode(DIRB, OUTPUT);

      che puoi aggiungere allo sketch del dolly nella setup().

        • Raffaele on 13 gennaio 2016 at 22:46
        • Reply

        Ciao Mauro, ho scoperto ulteriori cose che spero potrà permetterti di risolvere questo problema.
        Nello sketch già avevo inserito i sequenti parametri nella setup () e così come ti ho già scritto la sequenza dei LED è risultata essere la seguente nello spostamento RIGHT:

        4°led
        1°led e 2°led
        3°led
        nessuno

        Dunque ho provato a togliere questi parametri e la sequenza è cambiata:

        3°led e 4°led
        2°led
        3°led
        nessuno

        Tale sequenza rimane invariata se inserisco pinMode(PWMA, OUTPUT); o inserisco pinMode(PWMB, OUTPUT); o se metto entrambi.

        Invece se inserisco solo pinMode(DIRA, OUTPUT); la sequenza diventa
        4°led
        2°led
        3°led
        nessuno

        e se inserisco solo pinMode(DIRB, OUTPUT); la sequenza diventa
        3°led e 4°led
        1°led e 2°led
        3°led
        nessuno

        Se metto entrambi mi da la prima sequenza che ti ho scritto.

        Quindi in conclusione pinMode(PWMA, OUTPUT); e pinMode(PWMB, OUTPUT) non fanno cambiare la sequenza dei LED cosa invece diversa se inserisco pinMode(DIRB, OUTPUT); o pinMode(DIRA,OUTPUT); .
        Speriamo che ti possa aiutare ad aiutarmi 🙂

        1. Ciao Raffaele,
          c’è qualcosa di estremamente strano nelle sequenza che invii, hanno in comune che sono tutte sbagliate.
          Il mio prototipo non si comporta affatto in questo modo.
          Sei sicuro che i valori dei pin siano corretti?
          La motor shield è quella ufficiale arduino.cc ?
          La stai alimentando con 12v esterni ?

          Il comportamento che descrivi non mi permette di comprendere cosa accada.
          Solitamente non è possibile farlo, tuttavia ti chiedo delle foto del tuo progetto e del dettaglio delle schede via email all’indirizzo info del blog.
          Cercherò di comprendere qualcosa in più.

            • Raffaele on 15 gennaio 2016 at 00:05

            Ciao Mauro,
            ti ho inviato tutto alla tua email. Cosa intendi per i valori dei pin?
            La motor shield è quella ufficiale e l’alimentazione avviene a 12v cc.
            Ciao e grazie

          1. Ciao Raffaele,
            ho visto le immagini ed il video e l’unica differenza è la scheda arduino, io uso solo schede ufficiali arduino.cc
            Ipotizzo che non può essere colpa della scheda anche se non possedendone non posso eseguire un test.

            Per i valori dei pin mi riferisco alle definizioni alle linee 27-30.

            Verifica, per favore, la versione dell’IDE che deve essere la 1.6.7 scaricato dal sito arcuino.cc e non da altri siti.

    • Raffaele on 15 gennaio 2016 at 21:18
    • Reply

    Ciao Mauro,
    sinceramente ho acquistato per non avere problemi il materiale dal sito che consigli. Per quanto riguarda i valori alla linea 27-30 sono, gli stessi del progetto seguente e quindi non vedo il motivo perché in questo sketch dovrebbero essere causa di errori:
    http://www.mauroalfieri.it/elettronica/motor-shield-r3-arduino.html

    La versione dell’IDE che usavo era la 1.0.6, ma istallando la 1.6.7 durante la compilazione mi dava un warning sul comando ‘char*’ che ho prontamente sostituito con ‘const char *’.
    Ad ogni modo non è cambiato nulla :-(.

    1. Ciao Raffaele,
      sono giorni che ripenso agli errori che mi segnali e non riesco a comprendere cosa li causi.
      Come mai a me non si verificano e perché l’altro sketch funziona e questo no, deve essere una modifica in qualche componente che compromette il funzionamento di tutto il progetto.

      Come intervallo tra i passi cosa imposti?

        • Raffaele on 18 gennaio 2016 at 19:35
        • Reply

        Ciao Mauro,
        effettivamente è un comportamento un po’ strano. Il TIMEFASE ho provato a cambiarlo. Ora ho messo 50, ma la sequenza è sempre la stessa.

        1. Ciao Raffaele,
          non il TIMEFASE ma il valore di “intervallo” tra i passi configurato da menu.

            • Raffaele on 20 gennaio 2016 at 00:11

            Ciao Mauro
            il difetto oltre a farlo durante l’avvio del timelapse programmato, lo fa anche nella sezione del reset del carrello dove, l’intervallo non c’entra. O sbaglio?
            Per semplicità tutte le prove le faccio sempre lì.

          1. Ciao Raffaele,
            scusa il ritardo della risposta i era sfuggito il tuo commento.
            Preferirei che tu eseguissi le prove come te le chiedo e mi dessi le risposte alle domande che ti pongo per poterti aiutare.
            Sto cercando di comprendere il comportamento anomalo del tuo progetto, senza vederlo, e se mi aiuti proviamo a comprendere cosa ci sia di fferente tra il tuo modello, il mio e quello di tanti altri che lo hanno acquistato.

    • Raffaele on 27 gennaio 2016 at 22:58
    • Reply

    Ok,
    allora ho provato a mettere 1 come intervallo tra i passi e la sequenza è identica come già ti ho scritto.

    1. Ciao Raffaele,
      grazie per la risposta.
      Il motore si muove? L’anomalia nella sequenza ha come effetto un errato movimento ma cmq un movimento deve esserci.
      Ciò che mi lascia perplesso è che il motore restii cmq fermo al di la dell’anomalia.
      Per correggere l’anomalia prova a invertire una delle coppie di comandi relativi ad una delle fasi doppie.
      Es.: se la sequenza è
      3°led e 4°led
      2°led
      1°led
      nessuno

      inverti la prima coppia della sequenza 4° nel codice e verifica la correttezza della sequenza che deve diventare:
      3°led
      4°led
      2°led
      1°led

        • Raffaele on 30 gennaio 2016 at 18:13
        • Reply

        Ciao Mauro,
        ho provato qualsiasi combinazione affinché funzionasse, ma nulla. A questo punto credo che il problema sia la motor shield che è uscita dal kit che ho comprato da http://www……com/
        Ad ogni modo ho acquistato su amazon la motor shield ufficiale di arduino. Appena mi arriva, la monto e ti faccio sapere.
        Grazie

        1. Ciao Raffaele,
          dalle foto che mi hai inviato la motor shield è ufficiale e il sito che ti ho indicato è un rivenditore autorizzato.
          Oramai hai fatto l’acquisto e aspettiamo che ti arrivi, tuttavia se fosse la motor shield penso che non avresti alcun problema a chiederne la sostituzione.

            • Raffaele on 6 febbraio 2016 at 00:04

            Ciao Mauro,
            nuova scheda nuovo comportamento. Premettendo che ho interrotto i ponticelli A0 e A1, questa motor shield presenta sempre i led 1 e 2 accessi, di conseguenza il motore funge per soli due fasi delle 4.
            Cosa posso fare?
            Ciao

          1. Ciao Raffaele,
            stesso sketch ? in tal caso c’è qualcosa che va analizzato più a fondo e non posso farlo da remoto io, puoi farlo tu per capire se ci siano differenze tra le due schede e quali. Dovresti approfondire come mai questa scheda presenta sempre 2 led accesi, se si tratta di un malfunzionamento,un collegamento errato e/o di un differente collegamento dei pin al chip.
            Io ovviamente parto sempre dall’idea che stiamo parlando di schede originali, della prima mi hai inviato le foto, di questa mi fido che sia così.

    • Raffaele on 9 febbraio 2016 at 22:48
    • Reply

    Ciao Mauro, stesso sketch e con la motor shield ufficiale.Dopo che ho letto il tuo messaggio mi sono fatto prestare un’altra motor shield e presenta la stessa cosa: il led1 e 2 accessi.

    1. Ciao Raffaele,
      la cosa che non riesco a comprendere è come mai con lo sketch del solo motore stepper, che è praticamente identico nella componente di controllo, funzioni tutto.
      Inizio a dubitare delle altre shield ma non voglio che tu acquisti altro materiale, ti invito a fare una analisi più dettagliata controllando i pin di connessione e controllo, eventuali cali di tensione sui pin ecc..
      So che sono prove complesse e che richiedono l’uso e la conoscenza di strumenti come tester e oscilloscopio che non so se possiedi, tuttavia mi viene in mente solo questa strada.

    • Raffaele on 10 febbraio 2016 at 22:48
    • Reply

    Ciao Mauro, l’unica cosa che posso provare è un altro LCD della Sainsmart. Provo e ti faccio sapere.
    Grazie.

    P.S.:
    ma se ti spedissi tutto naturalmente pagando la tua consulenza? Mi dispiace davvero tanto buttare tutto all’aria 🙁

    1. Ciao Raffaele,
      l’LCD di cui mi hai inviato le foto è quello della DFRobot non della Sainsmart, giusto?
      Mi spiace doverti far pagare ulteriormente ed in questi giorni avrei poco tempo per le verifiche, tuttavia non è una strada che in estremo possiamo seguire.

    • Raffaele on 11 febbraio 2016 at 21:26
    • Reply

    Ciao Mauro, l’LCD che ho usato sempre è quello della DFRobot. Ho un altro della Sainsmart che potrei provare. Questo fine settimana faccio qualche prova e ti scrivo. Per quanto riguarda il fatto di mandarti tutto, se risolvo mi fa piacere, naturalalmente sempre se mi dici quanto mi costerebbe. Per il tempo io non ho fretta…

    1. Ciao Raffaele,
      se già possiedi il display e non devi acquistarlo, puoi fare i test.
      Verifica prima che i pulsanti inviino i valori attesi dallo sketch e che il display funzioni sui medesimi pin di quello della DFRobot.
      I display, solitamente, usano molti pin per funzionare e non ne restano molti per la motor shield, se anche solo uno dei pin si sovrappone devi trovare un modo alternativo per collegare le schede.

        • Raffaele on 14 febbraio 2016 at 12:23
        • Reply

        Ciao Mauro
        ho montato l’LCD sainsmart ma comunque ho gli stessi problemi? Sinceramente non so più cosa fare… se mi mandi una mail con i tuoi costi e indirizzo di spedizione, ti mando tutto.
        Grazie infinite

        1. Ciao Raffaele,
          ti scrivo appena mi libero da alcuni progetti in consegna.

            • Raffaele on 29 febbraio 2016 at 23:55

            Ti sei dimenticato di me 🙁

          1. Ciao Raffaele,
            non mi sono dimenticato ma non riesco a dedicarti tempo in questo periodo sto consegnando dei progetti e non mi sono ancora liberato, se dovessi darti una previsione ti direi metà/fine aprile come possibile data.

    • Riccardo on 24 febbraio 2016 at 15:29
    • Reply

    Salve, mi chiamo Riccardo e sono un appassionato un astrofilo, stavo guardando il tuo bel progetto per il time laps Arduino.

    Innanzitutto complimenti per la realizzazione, sto compilando due programmi, Abdroid, Vb.net, che mi permettano di programmare i parametri senza usare la tastiera del LCD shiel, ma si dovrebbe implementare una comunicazione seriale molto più evoluta pensi si possa fare?

    Volevo chiederti inoltre una cosa. Io realizzo spesso Time Laps astronomici (es: https://www.youtube.com/watch?v=gjWtLm-fybo), dove i tempi di esposizione sono molto lunghi, nell’ ordine dei 15 sec. di pausa e 20 ma anche 30 secondi di apertura del diaframma.

    Mi pare che questa soluzione non tenga presente di questa necessità, o sono io che ho mal interpretato lo sketch?.

    Esempio, se voglio realizzare un time laps del tramonto luna che dura 4 ore e farò 1500 foto con intervallo di 15 secondi di pausa e 25 secondi di scatto (ott. aperto) come devo comportarmi?

    1. Ciao Riccardo,
      mi definiresti meglio la frase “implementare una comunicazione seriale molto più evoluta” non ho compreso che tipo di comunicazione tu abbia in mente.
      Sui tempi lo sketch alla linea 305 ti permette di impostare intervalli di scatto da 1 fino a 9999999 millisecondi = che se non ho sbagliato i calcoli sono 9999 secondi = 2,77 ore.
      Per il tempo di apertura dell’otturatore puoi modificare lo sketch per inserire un ulteriore tempo impostabile, le istruzioni riga per riga servono proprio a spiegarti lo sketch e insegnarti a fare la modifica.

        • Riccardo on 24 febbraio 2016 at 19:17
        • Reply

        Si parlo di aggiungere nello sketch i comandi di gestione seriale in arrivo dal programma e per lo stesso…
        Ho fatto alcune prove e per l’impostazione dei valori (numero scatti, pause ecc) non ci sono problemi, l’avrei risolto in modo molto semplice visto che poi il programma passera valori corretti.

        Ti passo una bozza della modifica allo skletch:

        [ codice rimosso in automatico ]

        Questa è la funzione che monitora la seriale… per i valori non ho trovato problemi, ma per i comandi è tutta un’altra storia.

        1. Ciao Riccardo,
          innanzitutto ti chiedo la cortesia di rispettare le regole riportate in fondo ad ogni articolo che leggi.
          Se sei interessato a pubblicare delle modifiche allo sketch o mostrare il codice del tuo progetto completo di foto,video,sketch e documentazione puoi seguire la pagine “collabora al blog” in cui è descritto tutto.

          Per l’ultima frase temo di non aver compreso.

            • Riccardo on 28 febbraio 2016 at 19:36

            Salve…. Sorry… in questi giorni ho lavorato un po sul codice del Dolly. Ho ottenuto una buona interfaccia in vb.net, ancora un po acerba, ma funzionale.
            Se possibile volevo mandare uno ScreenShot della app…
            Grazie

          1. Ciao Riccardo,
            mi piacerebbe ricevere tutto quanto il progetto sarà concluso e potrei scrivere un bell’articolo sul tuo dolly.

    • Raffaele on 2 marzo 2016 at 22:16
    • Reply

    Ciao Mauro,
    non preoccuparti…. aspetterò con ansia.

    • Gaetano La Braca on 18 luglio 2016 at 20:21
    • Reply

    Ciao Mauro,

    innanzitutto complimenti per i tuoi progetti,

    possiedo un arduino R3, una motor shield R3 ed una lcd button shield, tutto collegato ad un nema prelevato da una stampante epson. Leggendo il tuo Codice e le specifiche delle varie shield, ho notato la condivisione dei pin A0, A1, D8 e D9 fra la motor e lcd. Ho provveduto ad interrompere il collegamento fra il brake A-B e fra SNS1 e SNS2.
    A questo punto pensavo che tutto sarebbe andato per il verso giusto, ma purtroppo il motore non esegue i movimenti desiderati. Pensando ad un problema del motore, ho caricato uno sketch di un mio precedente progetto e tutto fila liscio. Potresti indicarmi una possibile soluzione, considerando che allo stato attuale non utilizzo il cavo per comandare la camera e potresti anche aiutarmi nell’inserimento, nel tuo sketch, del codice (che già utilizzo) per comandare via infrarosso la mia Eos M?
    Grazie mille e nuovamente complimenti per la passione e ì’impegno che dedichi ai progetti e a tutti noi.

    1. Ciao Gaetano,
      verifica i collegamenti del motore e che le piste in corrispondenza di tutti i pin arduino, non solo Brake e A0 ed A1 siano interrotte.
      Ho dedicato un articolo proprio all’uso della motor shield come Dolly qualche mese fa per tutti coloro che, come te, non riuscivano a far funzionare il motore.

    • Andrea on 26 aprile 2017 at 22:24
    • Reply

    Ciao, Mauro, sono Andrea dalla provincia di Lucca. Come appasionato di fotografia mi sono cimentatato nel fare timelapse e dopo un po di tempo mi è venuto in mente di autocostruirmi una slitta la voglia aumentava e con il passare del tempo ho deciso di farmi un dolly motorizzato: E giorno dopo giorno e tante notti quasi senza dormire sono arrivato alla fine. Ma i problemi quelli più grossi dovevano ancora venire. Come si programma questo arduino?
    Ho iniziato a leggere e rileggere tutti i tuoi corsi copia e incolla elimina riprova e riprova ma sono arrivato al punto che la programmazione non riesco a farla. Come posso Fare mi puoi aiutare?
    Io ti ringrazio anticipatamente già del fatto che hai letto questo messaggio e ti ho fatto perdere del tempo.
    Se non è chiedere tropppo aspetto tue notizie

    Andrea

    1. Ciao Andrea,
      se ti occorre qualche consiglio su parti di codice che ho descritto e non ti sono chiare puoi utilizzare i commenti, rispettando le regole in fondo ad ogni articolo.
      Se l’aiuto che chiedi è per la scrittura di un codice adatto al tuo progetto lo classificherei come progetto su commissione e ti chiedo di inviarmi una email alla casella info del blog, la medesima da cui ti arriva questo messaggio, per ricevere le info necessarie a commissionarmi un progetto.

    • Andrea on 28 aprile 2017 at 16:37
    • Reply

    Info necessarie per progetto

    1. Ciao Andrea,
      mi forniresti un dettaglio di cosa ti servirebbe?

        • Andrea on 28 aprile 2017 at 17:30
        • Reply

        Ciao mi devo scusare ma non trovo la tua email dove mandarti tutti i dettagli.

          • Andrea on 28 aprile 2017 at 18:27
          • Reply

          Scusa l’ ignoranza ci sono arrivato

Lascia un commento

Your email address will not be published.

This site uses Akismet to reduce spam. Learn how your comment data is processed.