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.
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.
Important!
Ti ricordo infatti che questa versione del Dolly Photo si chiama così perchè studiata per lavorare con macchine fotografiche e non con telecamere, per le videocamere sto sperimentanto un nuovo progetto che chiamerò Dolly Slider o simile.
La realizzazione del Dolly Photo
Parti con il collegamento del motore:
come indicato in figura:
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
Il blog mauroalfieri.it ed i suoi contenuti sono distribuiti con Licenza
289 commenti
Vai al modulo dei commenti
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.
Autore
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
🙂 nn vedo l’ora….
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.
Autore
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
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!
Autore
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
si potrebbe inserire un fine corsa con due microswitch 🙂
Autore
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
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
Autore
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
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?
Autore
Ciao Roberto,
se stai utilizzando la Keypad ed il mio sketch senza modificarlo deve funzionarti o darti errore in compilazione.
Mauro
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 …..
Autore
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
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
Autore
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
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
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.
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
Autore
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
Autore
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
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.
Autore
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
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!
Autore
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
Autore
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
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
Autore
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
ciao
ho questo da tempo memore…. e non l’ho mai usato…
http://arduino.cc/en/Main/ArduinoMotorShieldR3
Autore
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
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
Autore
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
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
Autore
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
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
Autore
Ciao Luca,
più che gli avvolgimenti mi dovresti dire quanti fili possiede.
Mauro
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
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!
Autore
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
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…
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?
E altra domanda, ma io devo alimentare sia l’arduino che la motorshiel o basta alimentare solamente 1 dei due?
Autore
Ciao Roberto,
devi alimentare entrambi, negli articoli si vede e c’é scritto.
Mauro
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
Autore
Ciao Luca,
ok, hai un motore bipolare, per riconoscere le fasi segui questo articolo:
https://www.mauroalfieri.it/elettronica/tutorial-motore-bipolare-passo-passo-riconoscere-le-fasi.html
Mauro
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!
Autore
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
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
Autore
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
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?
Autore
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
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
Autore
Ciao Luca,
abbiamo subito un attacco 🙁
Ho lavorato tutta notte per ritirarlo su.
Grazie
Mauro
mi spiace spero non accada più!!!
Autore
Ciao Luca,
cosa ?
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
Autore
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
😀 sarebbe ancora più fiero se si potesse impostare la durata dello scatto!!!!!!!!
ciaooo
Autore
Ciao Luca,
trovo anche questa un’evoluzione interessante 🙂
Mauro
Ciao Mauro,
X il mi dispiace Intendevo l’attacco hacker al sito.
E per l’evoluzione… Potrei provarci… Ma nn so quando riusciró
Autore
Ciao Luca,
grazie per fortuna ho risolto 🙂
Prenditi tutto il tempo che ti occorre se scrivo qualcosa prima lo leggerai sul blog 🙂
Mauro
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
Autore
Ciao Luca,
si comporta allo stesso modo anche quando è alimentato?
Mauro
Ciao Mauro
Si comunque alimento arduino con un alimenttore 12v 500ma e la shield con un’altro stabilizzato 12v 3amp.
Ariciao
Luca
Autore
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
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
Autore
Ciao Luca,
mi sono perso questo commento.
Comprendo ciò che dici, potrebbe essere difettoso il motore, dove lo hai acquistato?
Piu nessuna risposta? 🙁
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 ?
Autore
Ciao Pierfrancesco,
hai separato i contatti in prossimità dei pin A0 e A1 presenti sulla Motor Shield?
Mauro
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
Autore
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
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
Autore
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
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!
Autore
Ciao, mi piace questo spirito di collaborazione tra appassionati 🙂
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
Autore
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
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!
Autore
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
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.
Autore
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
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.
Autore
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
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
Autore
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
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
Autore
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
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
Autore
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
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
Autore
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
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
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
Autore
Ciao Stefano,
si uso l’IDE Arduino, in questo momento la versione 1.0.3
Mauro
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
Autore
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
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
Autore
Ciao Pierfrancesco, si accendonoimled e funziona ?
Mauro
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
Autore
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
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
Autore
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
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?
Autore
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
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.
Autore
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
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à.
Autore
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
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.
Autore
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
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
Autore
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
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
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
Autore
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
Salve Mauro,
grazie 1000, il primo step è stato risolto
Autore
Ottimo Germano
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?
Autore
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
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
Autore
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
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
Autore
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
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
Autore
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
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
Autore
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
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
Autore
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
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
Autore
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
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…
Autore
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
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. 🙂
Autore
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
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! 🙂
Autore
Grande Simone,
Auguri di buone feste !!!
Mauro
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?
Autore
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
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 🙂
Autore
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
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?
Autore
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
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. 😉
Autore
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
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ù. 🙂
Autore
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
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
Autore
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
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
Autore
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
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
Autore
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
si si ho utilizzato il tuo sketch….cosa intendi per problema di visualizzazione? Come può essere risolto? Grazie mille
Filippo
Autore
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
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!
Autore
Ciao Filippo,
si potrebbe essere solo un problema di lunghezza della stringa.
Prova a ridurre i caratteri del testo 🙂
Mauro
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?
Autore
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
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:)
Autore
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.
Funziona 🙂 Grazie mille
Autore
Bene Riccardo, sono contento che i miei consigli ti siano stati utili.
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
Autore
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.
Grazie !
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
Autore
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?
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
Autore
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
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.
Autore
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.
Grazie Mauro. Adesso farò delle
prove e ti farò sapere.
Grazie ancora.
Autore
ok, Periglio.
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.
Autore
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.
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.
Autore
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.
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?
Autore
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
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.
Autore
Ciao Massimo,
separali in modo da escludere che possano influire sul funzionamento del progetto.
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.
Autore
Grazie Massimo per la condivisione lo aggiungeremo alle note del progetto 🙂
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
Autore
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.
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
Autore
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.
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
Autore
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.
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 ??
Autore
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
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
Autore
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.
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
Autore
Ciao Raffaele,
il problema riguarda la motor shield, leggi bene nei commenti in tutti gli articoli dedicati al dolly, è un problema già risolto.
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?
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.
Autore
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
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};
Autore
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.
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
Autore
Ciao Raffaele,
controlla che la sequenza delle fasi sia corretta con questo sketch o uno semplificato che puoi derivarti da questo.
Cioè? Cos’è un semplificato?
Autore
Ciao Raffaele,
uno sketch semplificato che puoi scriverti partendo da questo e che ti chiarisca le fasi di funzionamento del motore.
Ciao Mauro,
più che ricavarmi uno sketch semplificato, ho caricato in Arduino lo sketch del link seguente:
https://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
Autore
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.
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.
Autore
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.
Autore
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.
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.
Autore
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.
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…
Autore
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.
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
Autore
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.
è vero ok grazie poi ti farò sapere.
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?
https://www.mauroalfieri.it/elettronica/motor-shield-r3-arduino.html
Autore
Ciao Raffaele,
hai confrontato i due sistemi di movimentazione ? Sono identici ?
Ciao Mauro,
si sono identici.
Autore
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.
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.
https://www.mauroalfieri.it/elettronica/motor-shield-r3-arduino.html
Autore
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.
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.
Autore
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.
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
Ciao Giorgio,
sinceramente non capisco. Pensa che per andare sul sicuro ho comprato tutto il kit dal sito che Mauro consiglia.
Autore
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 ?
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?
Autore
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?
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
https://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.
Autore
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().
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 🙂
Autore
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ù.
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
Autore
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.
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:
https://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 :-(.
Autore
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?
Ciao Mauro,
effettivamente è un comportamento un po’ strano. Il TIMEFASE ho provato a cambiarlo. Ora ho messo 50, ma la sequenza è sempre la stessa.
Autore
Ciao Raffaele,
non il TIMEFASE ma il valore di “intervallo” tra i passi configurato da menu.
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ì.
Autore
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.
Ok,
allora ho provato a mettere 1 come intervallo tra i passi e la sequenza è identica come già ti ho scritto.
Autore
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
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
Autore
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.
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
Autore
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ì.
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.
Autore
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.
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 🙁
Autore
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.
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…
Autore
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.
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
Autore
Ciao Raffaele,
ti scrivo appena mi libero da alcuni progetti in consegna.
Ti sei dimenticato di me 🙁
Autore
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.
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?
Autore
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.
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.
Autore
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.
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
Autore
Ciao Riccardo,
mi piacerebbe ricevere tutto quanto il progetto sarà concluso e potrei scrivere un bell’articolo sul tuo dolly.
Ciao Mauro,
non preoccuparti…. aspetterò con ansia.
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.
Autore
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.
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
Autore
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.
Info necessarie per progetto
Autore
Ciao Andrea,
mi forniresti un dettaglio di cosa ti servirebbe?
Ciao mi devo scusare ma non trovo la tua email dove mandarti tutti i dettagli.
Scusa l’ ignoranza ci sono arrivato
Buon Giorno Mauro,
ho realizzato il tuo progetto, ma il display se lo monto sul Motor Shield mi fa una Riga (la Prima riga) di quadretti.
Mentre se lo smonto e lo metto direttamente su Arduino, vedo e navigo tutto il menù.
Ho provato sia un motor shield originale che uno China, e fa la stessa cosa sia con l’uno e l’altro, leggendo tutto il threed di chia ha avuto quello e l’altro problema, ho interrotto anche le connessioni SNS1 e SNS2 , come suggerito, ma non ho risolto… cosa potrebbe essere? (capisco che sia un domandone cosi) ma , anche leggendo qui non ho trovato nessuno che abbia avuto un analogo problema….
Arduino originale / motor Shield Originale / LCD KeyPad Shield “D1 Robot” (1602A)
grazie per una qualunque risposta
Francesco
Autore
Ciao Francesco,
il comportamento è molto strano, a prima lettura avevo subito pensato ai collegamenti SNS1 e 2, ma avendoli tu interrotti mi è complesso comprendere cosa stia accadendo.
Prova a collegare il display direttamente all’arduino mediante jumper e lascia connessa anche la motorshield.
Poi un pin alla volta scollega il display da Arduino e collegalo alla motorshield fino a trovare quale sia il pin che ti sta compromettendo l’utilizzo del display.
.. Mamma mia quanti commenti.. Sarebbe da fare un monumento a quest uomo (Sig. Alfieri)… Uno per la sua professionalità, due per la sua gentilezza ed altruismo nel condividere un progetto a cui avrà dedicato sicuramente molto tempo, 3 per la sua pazienza nel dare risposte anche a domande le cui risposte erano già in commenti precedenti….. Premetto di aver letto tutti i commenti (e ne sono veramente tanti) e che in alcuni di loro ho già trovato le risposte che cercavo. Sto cercando di realizzare il progetto anche io. Avendo competenze meccaniche e avendo a disposizione un officina, non ho avuto problemi per la parte meccanica (per ora sono partito con un prototipo che sulla carta sarebbe dovuto essere molto sottodimensionato ma che in pratica potrebbe anche rimanere così ) che sicuramente condividerò dettagliatamente su questo blog non appena arrivato al termine (spero di poter dare il mio contributo almeno per l’ 1% di quello che ho ricevuto). Sig. Mauro Alfieri Grazie. Grazie anche a tutti quelli che hanno scritto prima di me. È stato veramente bello imbattermi in un blog così costruttivo e così ben frequentato.
Autore
Ciao Paolo,
lusingato dalle tue parole.
Mi fa piacere che il progetto possa esserti stato utile e che i miei esperimenti invoglino persone volenterose a progettare e provare a riprodurli.
Quando vorrai pubblicare del materiale sul tuo progetto segui pure le poche direttive descritte nella sezione “collabora al blog“
Grazie mille per la risposta. Appena avrò tempo pubblicherò dettagliatamente il progetto della tavoletta equatoriale (il progetto che mi ha avvicinato ad arduino) completa di disegni quotati per la realizzazione, file . stl per la stampa 3d delle ruote dentate utilizzate e quant’ altro riterrò opportuno. Per il TUO progetto del dolly ho ancora parecchie difficoltà dai conflitti nell’accoppiare motorschield e keypad (speravo di concludere prima della fine delle ferie per poterlo provare sul campo ma la vedo dura) poi passerò al fotoaccoppiatore e finecorsa.. Speriamo bene. GRAZIE A TUTTI
Buona sera a tutti. Premetto che mi sono avvicinato al mondo dell’elettronica e di Arduino da poco e che le mie competenze in materia sono quasi pari a zero.
Da diversi giorni, stò cercando però di capire come poter fare per abbassare la luminosità del keypad lcd.
Dapprima mi ero fissato di riuscire a modificare il Santo sketch di Mauro Alfieri per far sì che dal pin 10 che accende e spegne la retroilluminazione (tramite output digitale HIGH) , esca un segnale analogico PWM ma non ci sono riuscito (ammesso che ciò sia possibile). So che molti di Voi ora diranno che senza le basi, avventurarsi tra segnali analogici, segnali digitali, variabili, impedenza e resistenze, é come aver la pretesa di buttarsi giù da un dirupo senza parapendio ma vi assicuro che prima di decidermi a disturbarVi con il mio commento ho passato davvero molte ma molte notti in bianco.
Oggi mi è venuta l’idea di provare a collegare un potenziometro al Keypad LCD. Ho tirato fuori un LCD 1602 che non utilizzo ed ho provato ad alimentarlo senza gli altri collegamenti (dati, ecc.) , tramite anodo (a) e catodo (k) con 3. 3 volt. Ho interposto una resistenza nel positivo. Visto che la retroilluminazione si accendeva, ho provato ad attaccarci un potenziometro (sono riuscito a rimediare un trimmer da 10k) e sembra funzionare.
Mi sono quindi spostato a ragionare sul tris Arduino-Motor shield-Keypad LCD.
Secondo Voi è possibile recidere i contatti alla destra del display (quelli che sono affogati alla base della plastica trasparente che diffonde la luce) e piazzarci un potenziometro nel positivo? Se si da quanto? Se misuro la tensione in quel punto, rilevo 2.86 volt con retroilluminazione accesa e ovviamente 0 volt con retroilluminazione spenta (il tutto alimentato tramite USB).
Scusate se mi sono dilungato e se ho usato termini non corretti. La prossima volta sarò più sintetico (potete giurarci che ci sarà una prossima volta).
Scusate un ultima cosa…
Volevo alimentare tutto il progetto con un unica batteria. Vorrei alimentare il motore direttamente dalla morsettiera GND Vin
della motor schield (quindi se non erro devo separare le piazzole Vin Connect confermate? ) (magari passando per un fusibile da 4 Ampere) e alimentare la logica tramite Jack. Per non stressare il regolatore di tensione di Arduino, volevo metterne uno esterno a monte che fornisca in ingresso alla scheda circa 6, 5 volt. Sbaglio qualcosa? O forse sarebbe meglio alimentare direttamente con 5 volt senza passare per il regolatore della scheda?
Se avete altre soluzioni saranno bene accette. Grazie a tutti.
Autore
Ciao Paolo,
sperando di aver compreso il problema di cui chiedi info ti chiedo quale sia la tensione di alimentazione del motore?
Se desideri usare un alimentatore esterno il mio suggerimento è di utilizzarne uno stabilizzato a 5v con almeno 1A per il solo Arduino, mi raccomando alla stabilità della tensione perché questo è un punto critico per i progetti arduino.
Grazie aver risposto. Volevo alimentare tutto con una batteria 12 volt.
12 volt diretti alla morsettiera della motor schield (se non erro devo però separare i contatti sulle piazzole vin connect, giusto?) e con la stessa batteria, vorrei alimentare anche arduino. Quindi per non abusare del regolatore di arduino, vorrei metterne un altro esterno prima di entrare nel jack. Potrei tararlo direttamente a 5 volt ed entrare saldando i fili direttamente sotto la presa usb oppure x avere piu stabilità (ditemi se sbaglio) potrei tararlo a circa 6 volt ed entrare dal jack nero. (il regolatore di arduino dovrà quindi dissipare il calore prodotto nell abbassamento di tensione da 6 a 5 volt invece che da 12volt della batteria ai 5 volt di cui necessita.
Grazie.
Autore
Ciao Paolo,
sono tutte soluzioni accettabili e possibili.
Sia i 12volt dall’ingresso sia i 5v diretti sul pin 5v di arduino possono essere una buona soluzione.
Se desideri utilizzare i 6v dal Jack nero ti ricordo che è consigliato l’utilizzo di almeno 7v per non perdere tensione sull’output de regolatore.
Geazie mille. Per quanto riguarda la retroilluminazione della schield keypad lcd, è possibile recidere i contatti alla destra del display (quelli che sono affogati alla base della plastica trasparente che diffonde la luce) e piazzarci un potenziometro nel positivo? Se si da quanto? Se misuro la tensione in quel punto, rilevo 2.86 volt con retroilluminazione accesa e ovviamente 0 volt con retroilluminazione spenta. (spero di essermi spiegato)
Autore
Ciao Paolo,
non è più semplice agire sul pin direttamente connesso al led ?
Nelle shield che ho utilizzato io, ad esempio è il pin 10, puoi mettere un potenziometro da 10K tra il pin del micro controllore e quello della shield e regolare la tensione che fai arrivare al display.
Ciao a tutti… Questa sera ho provato a non montare a castello la keypad lcd sulla motor shield ma ho provveduto a collegarla tramite cavetti. Ho provato ad interporre un trimmer da 10k nel pin addetto alla retroilluminazione (pin 10) con il risultato che il display o si illumina o si spegne… Non avendo altri potenziometri, ho provato con varie resistenze fino ad arrivare a 100 ohm con la quale il display attenua la sua luminosità. Il problema è che me lo trovo poco luminoso (come io volevo) soltanto quando dovrebbe essere spento per poi ritrovarmelo nel pieno della luminosità quando da listato è acceso. Ricapitolando: appena il programma è avviato, attesi i 2 secondi senza toccare alcun tasto,(quindi a display che dovrebbe essere spento) mi ritrovo nelle seguenti condizioni: pin 10 collegato=display spento. Pin scollegato=max luminosità. Pin collegato e passante per 100ohm=display poco luminoso ma quando ento nei menù o premo un tasto,la luminosità torna al 100%. Questo comportamento deriva dalla linea 61? Se si come faccio ad ovviare a questa cosa? Grazie
Autore
Ciao Paolo,
se ho compreso la tua descrizione sembra che il display possieda già una resistenza di pull-up che a pin scollegato porta la luminosità al 100%.
Se così fosse devi ragionare ponendo una resistenza inferiore o usare il PWM con valori tra 0 e 64 verificando a che punto il display si accende al 100%.
In ogni caso prova ad usare l’esempio “fade” presente nell’IDE Arduino cambiando il pin dello sketch in 10, quello a cui è connessa la retroilluminazione del tuo display.
Ok grazie…. Studio un po’ e poi mi rifaccio vivo