Se hai letto il mio articolo di Venerdì sai a quale progetto mi riferisco: il Dolly Photo è l’evoluzione del DollyII presentato alcuni mesi fa.
I motivi che mi hanno spinto a ridisegnare e scrivere nuovi sketch per questo progetto te li ho già raccontati nella prima parte del progetto ora non resta che iniziare.
Il materiale per il Dolly Photo
Per questa versione ho deciso di non utilizzare schede da assemblare, del resto è vero che sei un makers ma non è detto che tu debba possedere un’attrezzatura in grado di saldare componenti smd e simili, lascia che sia qualcun’altro a fare questa parte e dedicati alla parte meccanica e sopratutto alle foto.
La lista della spesa fino ad ora è semplice:
- n.1 arduino uno
- n.1 keypad LCD con diplay 16×2
- n.1 motor shield arduino
- n.1 motore stepper con massimo 1A per fase
- tanta voglia di fare e di sperimentare 🙂
L’ultimo punto non so consigliarti dove acquistarlo ma tutto il resto si trova su molti negozi ed ho composto anche un kit che a giorni sarà in vendita sul sito robot-domestici.it.
La scelta della motor shield arduino per il Dolly Photo
Se l’idea è semplificarti la vita sulla parte elettrica la soluzione migliore per il Dolly Photo mi è sembrata quella di scegliere una motor shield che possieda le adeguate caratteristiche elettriche ( 1A per canale ) e i pin che non vadano in conflitto con la Keypad LCD, non potendo cambiarli:
la motor shield arduino utilizza i seguenti pin per i due canali A e B destinati ai motori in corrente continua:
inoltre puoi usarla anche per realizzare il Dolly Camera o Sliders il cui progetto è tra quelli a cui sto lavorando, ti basta cambiare motore e sketch ed ecco che il Dolly Photo diventa Dolly Camera e viceversa.
Lo sketch del Dolly Photo
Lo sketch che ho scritto per il Dolly Photo è evoluzione del precedente, lo riporto tutto ma ti soffermerai solo sulle differenze, consultando la prima parte dell’articolo per le parti comuni:
/**********************************************************
* Dolly Photo Arduino
*
* Data creazione 25 febbraio 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 DEBUG
/**********************************************************/
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;
/**********************************************************/
unsigned long timeToBlacklight = 0;
unsigned long timeToSetMode = 0;
unsigned long timeSetting = 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 intervaloScatto = 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 );
/**********************************************************/
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 );
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(); }
/**********************************************************/
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) {
analogWrite( BACKLIGHT,128 );
blacklightStatus = true;
timeToBlacklight = millis();
}
return buttonPress;
}
/**********************************************************/
void lcdBlacklightOff() {
digitalWrite( BACKLIGHT,LOW );
blacklightStatus = false;
timeToBlacklight = 0;
lcd.clear();
}
/**********************************************************/
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 > 1 ) { 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 ) && passiXscatto <= 9999999) { intervaloScatto++; lcd.clear(); }
if ( (ctrlButton( analogRead( BUTTON )) == 2 ) && passiXscatto >= 1) { intervaloScatto--; lcd.clear(); }
sprintf(buffer, "%s %ds", secondario[(setModeLevel+1)], intervaloScatto);
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() {
lcd.clear();
lcd.setCursor(0,0);
lcd.print( "Menu " );
lcd.setCursor(0,1);
lcd.print( "Verifica" );
delay( SETMODETIME );
}
/**********************************************************/
void reset() {
lcd.clear();
lcd.setCursor(0,0);
lcd.print( "Menu " );
lcd.setCursor(0,1);
lcd.print( "Reset" );
delay( SETMODETIME );
}
/**********************************************************/
void avvio() {
lcd.clear();
lcd.setCursor(0,0);
lcd.print( "Menu " );
lcd.setCursor(0,1);
lcd.print( "Avvio" );
delay( SETMODETIME );
}
/**********************************************************/
ecco cosa è cambiato:
linee 58-59: aggiungi due nuove variabili di tipo array di caratteri secondario e buffer la prima di 10 elementi e la seconda di 16, sono differenti nell’uso, per adesso concentrati sulla linea 48 in cui la variabile secondario contiene le voci del menu secondario, ogni due elementi compongono il testo da visualizzare sulla prima linea del display e sulla seconda;
linee 63-67: crea 5 variabili, una per ciascuna voce di menù, in cui memorizzerai il corrispondente valore di tipo integer in fase di settaggio del Dolly Photo.
linea 250: la funzione Impostazioni() è cambiata;
linee 254-256: se la costante DEBIUG è definita scrivono sul monitor seriale il contenuto della stringa presente alla linea 255;
linee 260-264: sono sostanzialmente invariate rispetto allo sketch precedente, hanno solo cambiato numero di linea;
linea 272: definisci una variabile di tipo boolean ( true o false ) il cui valore determina se sei ancora in modalità impostazioni o se deve tornare al menu principale per attendere nuovi comandi;
linea 278: fino a quando la variabile impostazioniMode resta come impostato alla linea 272 ossia true il ciclo continua e lo sketch ti consente di effettuare tutte le impostazioni;
linea 282: controlla che il valore del pulsante premuto sia 5 ossia DOWN e allo stesso tempo che il valore dell’indice setModeLevel, che ti indica a quale livello del menu secondario sei, non sia superiore a 8, in tal caso pulisci l’LCD ed incrementa il valore di setModeLevel di 2 punti. Il motivo di questo controllo è che se il valore di setModeLevel superasse 8 sommando a questo 2, andresti oltre l’indice 9 infatti come sai se una array di caratteri è di dieci elementi il suo indice è 0-9, quindi 10 è oltre;
linea 283: esegui un’operazione simile a quella della linea precedente con la sola differenza che setModeLevel deve essere superiore a 1 in modo che sottraendo 2 a tale valore al massimo ti ritrovi 0 che il valore minimo dell’indice del menu secondario;
linea 284: questa linea ti permette di uscire dal menu infatti alla pressione del pulsante SELECT la funzione ctrlButton() ti restituisce 1 che rende vera la condizione if testata in questa linea e di conseguenza impostazioniMode diventa false uscendo dal ciclo in cui ti trovi e iniziato alla linea 268;
linee 288-291: le puoi utilizzare in fase di DEBUG per verificare che il cambio dell’indice di menu avvenga correttamente ad ogni pressione del pulsante UP o DOWN;
linea 295: grazie al comando switch puoi decidere in funzione del valore di setModeLevel che operazioni eseguire;
linee 297-302: imposta una delle condizioni da verificare, se il valore di setModeLevel è 0 lo sketch esegue il contenuto delle linee 298-301 ossia in funzione della pressione del pulsante LEFT ( valore 2 ) o RIGHT ( valore 3 ) del keypad LCD incrementa o decrementa il valore della variabile passiXscatto, che come immagini serve a memorizzare quanti passi per scatto il Dolly Photo deve eseguire. La linea 301 compone la seconda linea del display LCD essendo composta da un valore dinamico: “testo del menu secondario con indice dispari” + “valore di passiXscatto“;
linee 304-330: esegui le stesse operazioni viste alle linee 297-302 per gli altri valori definiti alle linee 64-67;
linee 336-337: scrivi sulla prima riga del display la voce di menu con indice pari prelevata dall’array secondario;
linee 338-339: scrivi sulla seconda riga del display il risultato dell’array buffer composto alle linee precedenti;
linea 339: prima di uscire dalla funzione impostazioni() pulisci il display.
Per adesso le funzioni successive restano invariate, nei prossimi articoli lavorerò su quelle e troverai come usarle nel tuo Dolly Photo.
Il video del menu impostazioni del Dolly Photo
Ecco il video di come funziona questo sketch, so che RIGHT è scritto male ma sul Keypad LCD in mio possesso è scritto così e non vorrei generare confusione tra chi legge la label sul keypad e guarda il filmato.
Buona visione !!!
Il blog mauroalfieri.it ed i suoi contenuti sono distribuiti con Licenza
26 commenti
Vai al modulo dei commenti
Ciao Mauro,
ho un problema di display dell’LCD: nelle righe di codice 57 58 59 ho sostituito alle tue voci quelle necessarie per il mio progetto, in particolare ho eliminato la voce “Reset Carrello”, quindi nel menu dovrebbero comparire solo le voci Impostazioni, Verifica ed avvio. In realtà quello che succede è che nel menu principale oltre a queste tre voci ne compare anche una che non dovrebbe esserci e che corrisponde in realtà alla prima voce del menù secondario, non so se mi sono spiegato ma secondo te dove potrebbe essere il problema? Grazie mille
Autore
Ciao Filippo,
se togli una voce di menu devi correggere anche il numero di elemanti dell’array “prncipale” e dovrai eseguire tutte le correzioni necessarie nelle funzione “menuMode”.
Se non correggi gli indici ti trovi nell’errore che hai descritto.
Mauro
Grazie mille, ho notato poi che il mio LCD a volte è come se “si addormentasse”, nel senso che i tasti non funzionano e devo premerli più volte prima che la shield prenda il comando. Inoltre noto che proprio lo schermo perde di intensità, insomma come se avesse dei cali di tensione.
Autore
Ciao Filippo,
l’apparente “sleep” del display potrebbe dipendere dalla tua velocità di pressione dei tasti.
Come hai letto ogni tasto ha un tempo di reazione o antirimbalzo, prova a premere il pulsante per qualche millisecondo in più.
I cali di tensione possono essere causati da:
– una alimentazione instabile
– eccessiva richiesta di corrente da parte del motore
Mauro
Ciao Mauro
Grazie per la tua bellissima guida per fare il dolly, sto per acquistar tutti i pezzi per creare il tuo progetto ed mi è venuto un piccolo dubbio sulla motor shield arduino
(http://store.arduino.cc/index.php?main_page=product_info&cPath=37_5&products_id=204&language=it)
vorrei collegare un motore passo passo (nema 23) che richiede 2 Amper o più, per aver maggior potenza in modo da poter utilizzare il dolly sia in pendenza che in verticale
nella guida tu raccomandi l’utilizzo di un motore con massimo 1 amper ma sul sito di arduino nelle specifiche relative alla scheda viene riportato: “Corrente massima: 2A per canale o 4A max (con alimentatore esterno)”
quindi sono un po confuso e vorrei un chiarimento
Grazie Mille
ps. ti chiedo una spiegazione semplice essendo nuovo del mondo di arduino, e non molto pratico con terminologia o altro
Autore
Ciao Max,
se devi acquistare tutto il materiale ti consiglio di acquistare direttamente il kit completo da robot-domestici.it in questo modo contribuisci anche al mantenimento del progetto e sopratutto sei certo che i componenti siano compatibili al 100% tra loro.
Sulle specifiche hai ragione la Motor Shield aruino può controllare motori fino a 2A per fase, si parla di correnti di picco che il componente supporta per limitati periodi di tempo, almeno a memoria.
Progettare un dolly che già di base assorba correnti limite è pericoloso sopratutto se puoi vuoi usare i 1/2 passi o 1/4 di passo in cui le fasi lavorano contemporaneamente.
La scorsa settimana ho provato il mio esempio di Dolly con la mia macchina fotografica ( Canon G9 ) e il motore in dotazione riuscendo a fare le riprese in verticale proprio con il 1/2 passo e il 1/4 di passo.
Mauro
Grazie mauro della tua risposta,
è gia mia intenzione acquistare il kit sul sito in modo da evitare qualsiasi problema, ma vorrei sostituire il motore con questo e non riesco a comprendere se è compatibile
http://www.robot-italy.com/it/3317-nema-17-bipolar-5-18-1-planetary-gearbox-stepper.html
(questo motore con il riduttore a mio parere sarebbe perfetto e si adatterebbe molto bene alla guida che possiedo, sempre che sia compatibile con la “Arduino Motor Shield Rev3”)
grazie per la pazienza
ps.
se fosse necessario modificare il tuo codice non dovrei avere grossi problemi, avendo un mio amico che scrive in codice c++ molto simile al codice di arduino se non sbaglio
Autore
Ciao Max,
molto interessante come motore, mi stupisce la moto riduzione su un passo-passo che potrebbe rivelarsi un vantaggio in taluni casi ma anche uno svantaggio sul controllo per passi.
Ho notato:
– 0.35 gradi passo, ma non specifica il numero totale di passi ne se la misura si riferisca al full step o alla riduzione di qualche tipo, potresti provare a chiederlo al negozio, così testi anche l’assistenza;
– 1.7A possono essere sopportati dai canali della motor shield anche se ti consiglio di raffreddarla opportunamente e di controllare con il venditore se si riferisce alla singola fase o al totale
Sarei curioso di conoscere come la motoriduzione influisce sulla vibrazione che oggi é uno dei principali problemi dei dolly per riprese, mentre non ha importanza per il time lapse.
Mauro
Ciao Mauro, ti sono davvero grato per le indicazioni datemi e come da te suggerito, ho provato a contattare il negozio per chiedergli chiarimenti e questa è stata la loro risposta:
“Salve,
360/0,35 gradi per passo indicano quanti passi deve fare per fare un giro;
lo step angle e’ un parametro standard dei motori passo passo,
normalmente la corrente si riferisce alla singola fase.
Restiamo a disposizione, grazie”
come puoi leggere non proprio esaustiva,
a breve cmq dovrei ordinarlo e poi ti faro sapere i risultati
ciao e grazie
Autore
Bene Max,
diciamo che l’informazione principale riguarda la corrente per fase e te l’anno data, il resto puoi testarlo empiricamente una volta acquistato.
Mauro
Ciao Mauro, se dovessi utilizzare per forza un motore con corrente per fase maggiore di 1A (esempio 2A) cosa mi consiglieresti di fare?
Autore
Ciao Luca,
prova a cercare tra le shield arduino un driver per motori passo-passo che supporti correnti per fase del tipo compatibile con il tuo motore.
Mauro
Salve Mauro,
Per prima cosa complimenti per quanto da te realizzato, devo dire che in passato avevo sentito parlare di Arduino ma poi non avevo mai approfondito l’argomento fin quando Arduino ha abbracciato grazie a te la mia passione per la fotografia.
Non essendo un fotografo ho sempre cercato di sperimentare le tecniche che permettono di avvicinarsi al risultato con un dispendio economico limitato, e devo dire che cercando un sistema dolly, sono atterrato sul tuo sito.
Ora viene il bello, ho una buona manualità sono un informatico votato al Web e mi piacerebbe realizzare il progetto dolly photo.
Non so da dove cominciare.. a parte il kit precostituito che voglio comprare, non so come si alimenta il sistema se il peso della macchinetta è importate e se con gli ambienti mac su cui lavoro posso fare tutto.
So anche fare qualche saldatura ma niente di complesso.
So che sono troppe pretese e poche conoscenze ma sarebbe veramente un piacere ed una enorme soddisfazione per me riuscire a realizzare un progettino come questo
Ringraziandoti anticipatamente ogni consiglio guida aiuto è ben accetto.
Autore
Ciao Flavio,
sicuramente il kit dolly photo è un ottimo punto di partenza sopratutto se sei a digiuno di elettronica.
Ho realizzato il kit proprio con lo scopo di aiutare tutti gli appassionati di fotografia ad auto costruirsi il proprio dolly o slider.
Io uso arduino principalmente dal mio Mac e posso assicurarti che è adatto alla realizzazione del progetto.
Per l’alimentazione puoi leggere gli articoli dedicati a questo aspetto e a quanto assorbe arduino.
Ciao Mauro da profano del sistema ma spinto dalla voglia di realizzare questo progetto il dolly photo, cosa mi consigli di fare? devo pensare prima alla parte meccanica del sistema o quella elettrica e di programmazione? Visto quanto già fatto da te in meritio allla seconda parte, hai anche qualche consiglio per la parte meccanica?
Ho paura di non reperire facilmente materiale leggero. Grazie mille.
Autore
Ciao Flavio,
certamente la parte meccanica rappresenta una componente non solo fondamentale per la realizzazione del dolly ma sopratutto da quella dipende la portata, in peso, della fotocamera che potrai applicare e la fluidità del movimento.
Ti consiglio di dedicarti alla realizzazione meccanica e contemporaneamente ordinare la parte elettronica.
Siccome sei pratico di programmazione non avrai problemi a modificare il mio sketch una volta compresa la logica.
ciao mauro ho cercato di leggere il tutto , ho acquistato da poco la scheda rev3 quindi ora riesco a collegare tutto a panettone, ho solo qualche domanda perché penso che mi siano sfuggite alcune parti qua e la..
io purtroppo ho una lcd keypad della dfrobot che è semi compatibile se collego l’arduino e la keypad tutto funziona perfettamente.
e se collego in serie a panettone anche l’altra scheda motori , e collego l’arduino ad un trasformatore da 12v il motore gira ma è molto debole, ho un nema17 da 0.8 ampere con un ingranaggio planetario stampato da me.
che dovrebbe dare piu coppia , in parole povere piu forza al motore,
ecco leggendo gli articoli ho rotto i ponticelli sotto la scheda del motore ( ponti per pin A _B ed sns1 ed sns0)
ho lasciato unito solo il vin connect.. ecco in pratica gli ho separati tutti ..giusto ???
se collego il tutto ad un trasformatore collegato al jack arduino il tutto gira , ma dalle immagini vedo che tu utilizzi anche ad un trasformatore collegato alla scheda del motore, é da 12 V???
poi utilizzando il tuo listato non riesco a far scattare la macchina utilizzo il pin 2 ed il gnd???
ti ringrazio scusa di tutte le domande
Autore
Ciao Andrea,
l’alimentazione del circuito devi darla attraverso i 12v della scheda motore e non passando per il Vin di arduino in quanto la pista che connette il Vin al pin centrale del connettore di alimentazione non supporta elevate correnti.
In merito al pin 2 hai provato a collegare il pin ad un led in modo da verificare che si accenda ad ogni scatto?
Un ultima richiesta, puoi evitare di inserire doppi i tuoi commenti, rischi che il blog ti classifichi come spam e non potrai più pubblicare alcuna richiesta.
ciao mauro tutto ok funziona tutto quasi alla perfezione,
alla fine come dicevi tu (le mie schede erano le stesse che hai utilizzato tu.tranne la keypad.)
purtroppo ho provato con il tester a collegate un optoisolatore, ed in seguito un led ad il pin n°2 ma nulla il tester legge dei valori (che aumentano arrivando a 4/5v subito dopo che sul display compare lo scatto ) ma ne il led che ho utilizzato per testare l’uscita ne l’optoisolatore (con resistenza da 220 hom) non hanno funzionato..
e come se ce il segnale ma non lo leggono (se li utilizzo per altro funzionano perfettamente)
secondo te qualè il problema?
potresti indicarmi che pin utilizzi tu ? io dal listato ho letto 2. ma forse mi sbaglio.
ti ringrazio molto
ho realizzato tutto alla lettera.
ovviamente parlo del pin che permette di scattare alle schede (purtroppo ti ho sempre scritto un po di fretta) ti chiedo scusa se non mi sono spiegato bene nelle scorse richiesta di aiuto.
Autore
Ciao Andrea,
la rilevazione di 5v sul pin 2 indica che lo sketch porta HIGH il pin 2 in corrispondenza dello scatto.
Il mancato ingaggio del led potrebbe essere dovuto ad un tempo di scatto troppo esiguo, prova ad incrementarlo da menu.
dal menu intendi dal listato ? o dalla keypad (durante le impostazioni)
io generalmente (in vecchi sketch mettevo tempi non inferuiori al 600 millisecondi ..)
ma ora nel listato mi potresti gentilmente dire dove trovo la riga per aumentare il tempo ? ti ringrazio di tutto il supporto..
Autore
Ciao Andrea,
in questo articolo lo sketch non presenta la funzione di scatto, come vedi, l’avvio e le altre funzioni, sono vuote.
Sposta il commento nell’articolo da cui hai copiato il mio codice e cerco di risponderti.
In ogni caso dovresti trovare nella descrizione dello sketch scritto in modo chiaro quale parametro modificare.
rieccomi ,, come al solito
ti chiedo scusa delle domande stupide con risposta ovvia che ho fatto qui nel forum , potessi cancellarle lo avrei già fatto, tante volte la fretta ti porta a sorvolare degli aspetti fondamentali..
ora tutto funziona, passi e scatto, ho risolto montando un relè’ da 5v purtroppo non so perché i led ed gli optoisolatori non funzionano , ho modificato anche il tempo , ora rimangono attivi per 3000 millisecondi..
forse sbaglierò ad utilizzare la resistenza,con i led avevo quelle da 220 hom… come ti dicevo non sono pratico e tutto quello che ho imparato lo devo a te, ed al tuo blog grazie,
p.s se hai qualche consiglio da darmi per utilizzare una resistenza giusta, lo apprezzerei molto ,,l’unica cosa negativa e che il mio stepper da0.8A e 6v scatta ed è molto debole.. ..
qualche suggerimento ?
grazie mille
Autore
Ciao Andrea,
sono contento tu sia riuscito a risolvere.
Per la resistenza hai verificato il datasheet dell’optoisolatore, magari necessita di tensioni/correnti superiori ai normali led.
Per il motore nel mio kit il motore previsto è un 1.8A se non ricordo male.
eccoci, scusami per l’insistenza mauro, ma settimana scorsa purtroppo ho provato ad alimentare la adafruit (la vecchia scheda che avevo , con il risultato che ho bruciato un driver, ricapitolando l’alimentazione avviene solo dalla motorshild rev 3 e non dalla arduino. (forse è per questo che se utilizzo l’entrata normale della arduino il motore è troppo debole) (PERO il tutto funziona correttamente)
poi in merito alla domanda di ieri
in cui chiedevo {ecco leggendo gli articoli ho rotto i ponticelli sotto la scheda del motore ( ponti per pin A _B ed sns1 ed sns0)
ho lasciato unito solo il vin connect integro.. in pratica gli ho separati tutti gli altri ..è giusto ??? oppure devo separare anche il vin???} scusa della ripetizione.
il tuo progetto è fantastico, e la cosa perfetta è che tenedo il tuo listato (con i menu e le impostazioni fatte da te è adattabile non solo al dolly ma anche ad un inseguitore stellare, basta impostarlo correttamente.sto utilizzando la versopone senza i fine corsa perchè preferisco. che giunta alla fine si spegni totalmente.
grazie mille di tutto. ho appena stampato un case per (le schede a panettone con le uscite utili. ed i pulsanti , se sei interessato ti invio qualche immagine.
Autore
Ciao Andrea,
io rispondo ai commenti partendo dall’idea che abbiate le medesime shield usate nei progetti che descrivo, se usi schede differenti devi far riferimento al produttore per capire come usarle.
Il ponticello del Vin non è necessario che tu lo separi a meno che tu non desideri alimentare arduino con un alimentatore separato.
Certo se hai voglia di mandarmi qualche foto e video del tuo progetto sono di certo interessato a vederlo applicato ad altri ambiti rispetto a quello per cui è nato 🙂