Pimp My Cam: 14 passaggi (con immagini)

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:05

Ecco da dove nasce questo progetto.

Tempo fa ho pensato di filmare alcuni time-lapse. "Come?" mi sono chiesto? La prima risposta è stata "Beh… basta filmare qualcosa e accelerarlo e basta". Ma è davvero così semplice? Innanzitutto, voglio usare la mia DSLR per questo e la mia Nikon D3100 ha un limite di tempo di 10 minuti per le riprese video. In secondo luogo, anche se avessi una videocamera senza limiti di tempo per le riprese video, cosa succederebbe se volessi fare un timelapse molto lungo, come 12 ore? Faccio un video 1080p della durata di 12 ore. Dubito che la batteria durerà così a lungo e, non è molto pratico, vero? Va bene, incrociando "l'idea di filmare il video". Bene, allora ci sono le immagini. Scattare una foto con la fotocamera a un certo intervallo e finire con centinaia di immagini che poi elaboro tramite software per fare un video.. ?

Sembrava un'idea valida, quindi ho deciso di provarci. Così ho deciso di voler creare un dispositivo in cui inserire un periodo di tempo e, in base a quel periodo, avrebbe attivato costantemente la mia fotocamera. E già che ci siamo, perché non aggiungere altre cose come l'attivazione del movimento e così via?

Fase 1: Ma.. Come?

COME? è la nostra prossima domanda a cui manca una risposta. A causa di tempistiche, trigger, sensori e cose del genere non sarà una sorpresa che il primo che mi è venuto in mente fosse, ovviamente, un Arduino. Va bene, ma ancora, dobbiamo imparare come attivare l'otturatore sulla nostra fotocamera. Hm.. servo incollato a caldo al corpo macchina? Assolutamente no, vogliamo che sia silenzioso ed efficiente dal punto di vista energetico. Efficienza energetica: perché? Perché voglio renderlo portatile e inserire una batteria, non sarò vicino a una presa di corrente ogni volta. Quindi, come lo attiviamo allora.. in realtà è piuttosto semplice.

Nikon sapeva già che vorrai un telecomando e altri accessori e hanno detto "ok, daremo loro tutto questo, ma faremo un porting speciale in modo da poter fare più soldi su quegli accessori", vergognati Nikon. Quella porta è (nel mio caso) chiamata MC-DC2, e il modo più economico per metterci le mani sopra è acquistare un pulsante di scatto remoto su eBay per 2-3 $ e usare solo il cavo.

*Alcune altre fotocamere, come Canon, hanno un semplice jack per cuffie da 3,5 mm realizzato per lo stesso uso in modo da poter utilizzare un cavo di vecchi altoparlanti/cuffie.

Passaggio 2: imparare come attivare la fotocamera

Comunque, ecco l'affare, la porta avrà 3 connessioni che saranno di nostro interesse (Ground, Focus e Shutter) e avrai quelle all'estremità del tuo cavo dell'otturatore remoto appena acquistato che hai appena distrutto. Queste tre connessioni sono importanti per noi perché se mettiamo in cortocircuito Ground e Focus, la fotocamera metterà a fuoco proprio come stai premendo il pulsante di messa a fuoco e quindi, mentre quella connessione rimane, puoi cortocircuitare Ground e Shutter e la fotocamera scatterà una foto proprio come se avessi premuto il pulsante di scatto della fotocamera.

Puoi testarlo cortocircuitando letteralmente i fili sotto tensione all'estremità del cavo per identificare quale filo è quale. Una volta fatto ciò, per facilitare l'identificazione, li coloreremo in questo modo:

Terra = NERO; Fuoco = BIANCO; Otturatore = ROSSO.

Bene, ora dobbiamo insegnare ad Arduino a farlo per noi.

Passaggio 3: modi per attivare

La cosa più semplice che possiamo dire a un Arduino di inviare nel mondo esterno è il segnale di uscita digitale. Questo segnale può essere ALTO ('1' logico) o BASSO ('0' logico), da cui il nome "digitale", o se convertito nel suo significato principale: 5 V per un ALTO logico e 0 V per un BASSO logico.

Cosa dobbiamo fare con questi segnali digitali? Non possiamo semplicemente collegarli alla fotocamera e aspettarci che la fotocamera sappia ciò che vogliamo. Come abbiamo visto, abbiamo bisogno di cortocircuitare le connessioni sulla fotocamera per farla reagire, quindi dobbiamo usare i segnali digitali di Arduino per pilotare alcuni componenti che possono cortocircuitare i loro terminali a seconda di questi segnali elettrici che gli inviamo. *Per come l'ho descritto, potresti pensare "Ah, relè!" ma no no. Il relè farebbe il lavoro, ma abbiamo a che fare con correnti così piccole che possiamo facilmente usare la magia nera dei semiconduttori.

Il primo componente che proverò è un fotoaccoppiatore. Li ho visti implementati di più per questo ed è probabilmente la soluzione migliore. L'optoaccoppiatore è un componente elettrico con il quale si controlla il circuito di uscita mentre il circuito di ingresso è completamente isolato da esso. Ciò si ottiene trasmettendo informazioni tramite luce, il circuito di ingresso accende un LED e il fototransistor sull'uscita commuta di conseguenza.

Quindi useremo l'optoaccoppiatore in questo modo: diciamo al nostro Arduino di inviare un HIGH digitale su uno se si tratta di pin digitali, quel segnale è praticamente 5V che guiderà il LED all'interno dell'optoaccoppiatore e il fototransistor all'interno di esso sarà "corto" sono i terminali di uscita quando rileva quella luce e, viceversa, "stacca" i terminali poiché non c'è luce dal LED quando inviamo un LOW digitale tramite Arduino.

In pratica, questo significa: uno dei pin digitali dell'Arduino è collegato al pin ANODE dell'accoppiatore ottico, il GND di Arduino è collegato al CATODO, il GND della fotocamera è collegato all'EMETTITORE e FOCUS (o OTTURATORE) al COLLETTORE. Fare riferimento alla scheda tecnica del fotoaccoppiatore che stai utilizzando per trovare questi pin sul tuo. Sto usando 4N35 in modo da poter seguire il mio schema alla cieca se non ti interessa davvero cosa succede all'interno del fotoaccoppiatore. Inutile dire che avremo bisogno di due di questi, dal momento che dobbiamo controllare sia FOCUS che SHUTTER della fotocamera.

Dato che abbiamo visto come funziona, con un fototransistor in uscita, perché non lo proviamo esclusivamente con un semplice transistor NPN. Questa volta, porteremo il segnale digitale direttamente (attraverso un resistore) alla base del transistor e collegheremo sia la fotocamera che il GND di Arduino all'emettitore e la messa a fuoco/otturatore della fotocamera al collettore del transistor.

Di nuovo, avremo bisogno di due di questi poiché stiamo controllando due segnali. Sto usando il BC547B e puoi praticamente usare qualsiasi NPN per questo poiché la corrente che stiamo controllando è un singolo milliampere.

Entrambi questi componenti funzioneranno, ma scegliere l'accoppiatore ottico è probabilmente l'idea migliore perché è più sicuro. Scegli i transistor solo se sai cosa stai facendo.

Passaggio 4: scrittura del codice per l'attivazione

Come abbiamo detto prima, utilizzeremo i pin digitali di Arduino per la segnalazione. L'Arduino può usarli sia per leggere i dati da esso, sia per scriverci sopra, quindi la prima cosa che dobbiamo fare è specificare nella funzione setup() che useremo due dei pin digitali di Arduino per l'output in questo modo:

pinMode(FOCUS_PIN, OUTPUT);

pinMode(SHUTTER_PIN, OUTPUT);

dove FOCUS_PIN e SHUTTER_PIN possono essere definiti con "#define NAME value" o come int prima della funzione setup() perché potresti cambiare il pin, quindi è più facile cambiare il valore su un solo punto piuttosto che l'intero codice in seguito.

La prossima cosa che faremo è scrivere una funzione trigger() che farà proprio questo quando verrà eseguita. Includerò solo una foto con il codice. Tutto quello che devi sapere è che prima teniamo il FOCUS_PIN su ALTO per un certo periodo di tempo perché dobbiamo aspettare che la fotocamera metta a fuoco il soggetto su cui lo stiamo puntando e poi solo per un momento (mentre FOCUS_PIN è ancora ALTO) metti SHUTTER_PIN su HIGH solo per scattare la foto.

Ho anche incluso la possibilità di saltare la messa a fuoco perché non ce ne sarà bisogno se stiamo riprendendo un time-lapse di qualcosa che non cambia la sua distanza dalla fotocamera nel tempo.

Passaggio 5: intervallo di classe{};

Ora che abbiamo attivato la fotocamera, dobbiamo trasformarlo in un intervallometro aggiungendo la funzionalità di manipolazione del periodo di tempo tra due scatti. Solo per farti un'idea di ciò che stiamo facendo, ecco un codice primitivo per dimostrare la funzionalità che vogliamo:

ciclo vuoto(){

ritardo(intervallo); grilletto(); }

Voglio essere in grado di modificare questo intervallo da, diciamo, 5 secondi fino a forse 20-30 minuti. Ed ecco il problema, se voglio cambiarlo da 5s a 16s o qualsiasi altra cosa nel mezzo userò l'incremento di 1s, dove per ogni mia richiesta di aumentare l'intervallo, l'intervallo aumenterebbe di 1s. È fantastico, ma cosa succede se voglio passare da 5 secondi a 5 minuti? Mi ci vorrebbero 295 richieste in incrementi di 1s, quindi ovviamente devo aumentare il valore di incremento a qualcosa di più grande e devo definire su quale valore di intervallo esatto (soglia) modificare l'incremento. Ho implementato questo:

5s-60s: incremento di 1s; 60-300: incremento di 10 secondi; 300-3600: incremento di 60 secondi;

ma ho scritto questa classe per essere regolabile in modo da poter definire le proprie soglie e incrementi (tutto è commentato nel file.h in modo da poter sapere dove modificare quali valori).

L'esempio che ho dato di manipolare l'intervallo è ovviamente fatto su un PC, ora dobbiamo spostarlo su Arduino. L'intera classe, Interval, viene inserita in un file di intestazione che viene utilizzato per memorizzare dichiarazioni e definizioni (non proprio, ma in questo esempio può essere eseguita senza causare alcun danno) delle nostre classi/funzioni. Per introdurre questo file di intestazione nel nostro codice arduino usiamo " #include "Interval.h" " (i file devono trovarsi nella stessa directory), che assicura che possiamo utilizzare le funzioni definite nel file di intestazione nel nostro codice principale.

Passaggio 6: manipolazione dell'intervallo tramite Arduino

Ora vogliamo essere in grado di modificare il valore dell'intervallo, aumentarlo o diminuirlo. Quindi sono due cose, quindi useremo due segnali digitali che saranno controllati da due pulsanti. Leggeremo ripetutamente i valori sui pin digitali assegnati ai pulsanti e li analizzeremo nella funzione checkButtons(int, int); che aumenterà l'intervallo se viene premuto il pulsante "su" e diminuirà l'intervallo se il pulsante "giù". Inoltre, se vengono premuti entrambi i pulsanti, cambierà il valore della variabile focus che controlla se mettere a fuoco o meno durante l'attivazione.

Una parte del codice ((millis() - prevBtnPress) >= debounceTime) viene utilizzata per l'antirimbalzo. Per come l'ho scritto, significa che registro la prima pressione del pulsante con la variabile booleana btnPressed e ricordo l'ora in cui è successo. Poi aspetto un certo periodo di tempo (debounceTime) e se il pulsante è ancora premuto reagisco. Fa anche una "pausa" tra ogni altra pressione del pulsante in modo da evitare pressioni multiple dove non ce ne sono.

E infine, con:

if ((millis() - prevTrigger) / 1000 >= interval.getVal()) {

prevTrigger = millis(); grilletto(); }

controlliamo innanzitutto se la quantità di tempo tra l'ultimo trigger (prevTrigger) e il tempo corrente (millis()) (tutto è diviso per 1000 perché è in millisecondi e l'intervallo è in secondi) è uguale o maggiore dell'intervallo vogliamo, e se lo è, ricordiamo l'ora corrente come l'ultima volta che abbiamo attivato la fotocamera e quindi l'abbiamo attivata.

Con questo completo, abbiamo praticamente realizzato un intervallometro, ma siamo tutt'altro che finiti. Non vediamo ancora il valore dell'intervallometro. Viene visualizzato solo sul monitor seriale e non saremo sempre vicino a un computer, quindi ora implementeremo qualcosa che ci mostrerà l'intervallo mentre lo cambiamo.

Passaggio 7: visualizzazione dell'intervallo

Qui è dove introduciamo il display. Ho usato il modulo a 4 cifre che è guidato da TM1637 perché devo usarlo solo per visualizzare l'ora e nient'altro. Il modo più semplice per utilizzare questi moduli realizzati per un Arduino è utilizzare librerie già create per loro. Sul sito Arduino c'è una pagina che descrive il chip TM1673 e un collegamento a una libreria suggerita. Ho scaricato questa libreria e ci sono due modi per introdurre queste librerie nell'IDE di Arduino:

1. dal software Arduino vai su Schizzo>Includi libreria>Aggiungi libreria. ZIP e individua il file.zip appena scaricato
2. puoi fare ciò che Arduino fa manualmente e semplicemente decomprimere la libreria nella cartella in cui Arduino memorizza le librerie, su Windows: C:\Users\Username\Documents\Arduino\libraries\.

Una volta inserita la libreria dovresti leggere il file "ReadMe" in cui troverai il riepilogo di cosa fanno le varie funzioni. A volte questo non è sufficiente, quindi ti consigliamo di approfondire ed esplorare i file di intestazione in cui puoi vedere come sono implementate le funzioni e cosa richiedono come argomenti di input. E ovviamente il modo migliore per avere un'idea di cosa è capace una libreria di solito offre un esempio che puoi eseguire dal software Arduino tramite File>Examples>LibraryName>ExampleName. Questa libreria offre un esempio che ti consiglio di eseguire sul tuo display solo per vedere se il tuo display funziona correttamente e poi ti incoraggio a modificare il codice che vedi nell'esempio e vedere di persona cosa fa ogni funzione e come reagisce il display esso. L'ho fatto e questo è quello che ho capito:

utilizza 4 interi senza segno di 8 bit per ogni cifra (0bB7, B6, B5, B4, B3, B2, B1, B0). E ciascuno di quei bit B6-B0 viene utilizzato per ogni segmento di una certa cifra e se il bit è 1 si accende il segmento controllato da esso. Questi interi sono memorizzati in un array chiamato data. L'impostazione di questi bit sul display viene eseguita da display.setSegments(data); oppure puoi naturalmente accedere a una qualsiasi delle cifre in particolare e impostarle manualmente (data[0] = 0b01111001) oppure puoi usare la funzione encodeDigit(int); e converti la cifra in cui la invii secondo bits(data[0] = display.encodeDigit(3));. Il bit B7 viene utilizzato solo dalla seconda cifra, o data[1], per l'attivazione dei due punti.

Dato che ho scritto le funzioni nella classe INTERVAL dove posso ottenere determinate cifre dell'intervallo sotto forma di M1M0:S1S0, dove M sta per minuti e S per secondi, è naturale che io usi encodeDigitFunction(int); per visualizzare l'intervallo in questo modo:

displayInterval(){

data[0] = display.encodeDigit(interval.getM1()); dati[1] = 0x80 | display.encodeDigit(interval.getM0()); data[2] = display.encodeDigit(interval.getS1()); data[3] = display.encodeDigit(interval.getS0()); display.setSegments(dati); }

Ora, ogni volta che ho bisogno di visualizzare l'intervallo sul display, posso chiamare la funzione displayInterval().

*Notare " 0x80 | … " sui dati[1]. Viene utilizzato per garantire che il bit B7 dei dati[1] sia sempre 1 in modo che i due punti si accendano.

Ultima cosa sul display, il consumo energetico. Potrebbe non essere di grande importanza poiché non lo terremo acceso per molto tempo, ma se sei interessato a renderlo ancora più compatibile con la batteria, considera di ridurre la luminosità del display poiché assorbe 3 volte più corrente alla massima luminosità che sul più basso.

Passaggio 8: mettere tutto insieme

Sappiamo come attivare la fotocamera, come manipolare l'intervallo e come visualizzare lo stesso intervallo su un display. Ora dobbiamo solo unire tutte queste cose insieme. Inizieremo, ovviamente, dalla funzione loop(). Controlleremo costantemente la pressione dei pulsanti e reagiremo di conseguenza con i checkButtons(int, int) e modificheremo l'intervallo di conseguenza e visualizzeremo l'intervallo modificato. Anche nel loop() controlleremo costantemente se è trascorso abbastanza tempo dall'ultima attivazione o pressione del pulsante e chiameremo la funzione trigger() se necessario. Per ridurre il consumo di energia spegneremo il display dopo un po' di tempo.

Ho aggiunto un led bicolore, (Rosso e Verde, catodo comune) che si illuminerà di verde mentre il grilletto() e si illuminerà di rosso insieme al display se la messa a fuoco è attiva e rimarrà spento se la messa a fuoco è spento.

Inoltre, migreremo a un Arduino ancora più piccolo, Pro Mini.

Passaggio 9: aggiungere un'ultima cosa

Finora… abbiamo creato solo un intervallometro. Utile, ma possiamo fare di meglio.

Questo è quello che avevo in mente: l'intervallometro fa le sue cose per impostazione predefinita, TRANNE quando colleghiamo una sorta di interruttore/sensore esterno che quindi arresta l'intervallometro e risponde all'input dell'interruttore/sensore. Chiamiamolo sensore, non sarà necessariamente un sensore collegato, ma lo chiamerò così.

In primo luogo, come rileviamo che abbiamo collegato il sensore?

I sensori che useremo/realizziamo avranno tutti bisogno di tre fili per collegarli all'arduino (Vcc, GND, Signal). Ciò significa che possiamo utilizzare un jack audio da 3,5 mm come jack di ingresso per il sensore. E come risolve il nostro problema? Bene, ci sono tipi di jack da 3,5 mm "con un interruttore" che hanno pin che sono in cortocircuito con i pin del connettore se non c'è un connettore maschio e si staccano quando è presente un connettore. Ciò significa che abbiamo le informazioni basate sulla presenza del sensore. Userò il resistore pull-down come mostrato (il pin digitale leggerà HIGH senza il sensore e LOW con il sensore collegato) nell'immagine o potresti anche collegare il pin digitale al pin del connettore che è normalmente collegato a terra e definisci quel pin digitale come INPUT_PULLUP, funzionerà in entrambi i modi. Quindi ora dobbiamo modificare il nostro codice in modo che faccia tutto ciò che abbiamo scritto finora solo se il sensore non è presente o quando il controllo del pin digitale è ALTO. L'ho anche ottimizzato in modo che mostri " SENS " sul display invece dell'intervallo che è inutile in questa modalità, ma la messa a fuoco è ancora rilevante per noi manterremo la funzionalità di alternare la messa a fuoco con la pressione di entrambi i pulsanti e mostrando lo stato di messa a fuoco attraverso il led rosso.

Cosa fa effettivamente il sensore?

Tutto quello che deve fare è mettere 5V sul suo pin Signal quando vogliamo attivare la fotocamera. Ciò significa che avremo bisogno di un altro pin digitale dell'Arduino per controllare lo stato di questo pin e quando registra HIGH, tutto ciò che deve fare è chiamare la funzione trigger() e la fotocamera scatterà una foto. L'esempio più semplice, e quello che useremo per verificare se funziona, è un semplice pulsante con un resistore pull-down. Collegare il pulsante tra la Vcc del sensore e il pin Signal e aggiungere un resistore tra pin Signal e GND, in questo modo il pin Signal sarà su GND quando il pulsante non viene premuto poiché non scorre corrente attraverso il resistore e quando il pulsante è premuto mettiamo il pin Signal direttamente su HIGH e Arduino lo legge e attiva la fotocamera.

Con questo abbiamo concluso scrivendo il codice.

*Vorrei segnalare alcuni problemi che ho avuto con i jack audio che ho usato. Durante l'inserimento del jack maschio nel connettore, il GND e uno degli altri due pin a volte andavano in cortocircuito. Questo accade istantaneamente e solo mentre si inserisce il connettore, ma è ancora abbastanza lungo da consentire ad Arduino di registrare un cortocircuito in modo che Arduino si riavvii. Questo non accade così spesso, ma può comunque essere un pericolo e c'è la possibilità di distruggere l'Arduino, quindi evita i connettori che ho usato.

Passaggio 10: contenere il disordine

Puoi vedere dalle immagini che la breadboard sta diventando disordinata e abbiamo finito, quindi dobbiamo trasferire tutto su una perfboard/PCB. Ho optato per PCB perché penso che ne farò altri, così in questo modo posso riprodurli facilmente.

Ho usato Eagle per progettare il PCB e ho trovato i disegni per tutte le parti che ho usato. C'è una piccola cosa nel mio progetto che avrei voluto non aver fatto e questo è un filo per il Vcc del display. L'ho visto troppo tardi e non volevo rovinare ciò che avevo progettato in precedenza e ho optato per il modo pigro di aggiungere piazzole di filo e in seguito dover aggiungere fili a queste connessioni invece di tracce di rame, quindi ricordati che se stai usando il mio design.

La scheda Arduino e il display sono collegati al PCB tramite intestazioni pin femmina anziché essere saldati direttamente sul PCB, per ragioni apparenti. In questo modo c'è molto spazio per altri componenti sotto il display per altri componenti come resistori, transistor e persino il jack audio.

Ho messo i micro pulsanti che, in base al design, dovrebbero essere saldati direttamente ma potresti anche usare i fori per le intestazioni dei pin femmina e collegare i pulsanti con il filo se vuoi che siano montati sulla custodia e non sul PCB.

Metteremo anche un altro jack audio femmina per collegare il cavo che si collega alla fotocamera. In questo modo la scheda diventa più versatile poiché in questo modo potremo collegarci ad altre fotocamere con altri connettori.

Passaggio 11: Sens0rs

Consideriamo i modi per implementare il sensore.

Quindi il sensore avrà la tensione di alimentazione di 5V e dovrà essere in grado di fornire un ALTO digitale sul suo pin di segnale quando vogliamo attivare la telecamera. La prima cosa che mi è venuta in mente è un sensore di movimento, PIR per essere precisi. Ci sono moduli venduti per Arduino che hanno questo sensore e fanno proprio quello che vogliamo. Sono alimentati a 5V e hanno un pin di uscita su cui mettono 5V quando vengono attivati, dobbiamo solo collegare i suoi pin a un jack audio da 3,5 mm e possiamo collegarlo direttamente alla scheda. Una cosa da notare però è che questo sensore ha bisogno di tempo per riscaldarsi e iniziare a funzionare correttamente, quindi non aspettarti che funzioni correttamente non appena lo colleghi, dagli un po' di tempo e poi configuralo e qualunque cosa viva entra nel suo gamma attiverà la fotocamera.

Dal momento che stiamo pensando alla direzione delle schede sensore Arduino già realizzate, ne viene in mente un'altra, il suono. Queste schede sono solitamente realizzate in modo tale da avere un pin che emette il valore analogico del suono che riceve e un altro, digitale, che emette un ALTO logico se il suono che riceve supera un certo livello. Possiamo impostare questo livello in modo tale che il sensore ignori la nostra voce ma registri un applauso. In questo modo, ogni volta che batti le mani, fai scattare la telecamera.

Passaggio 12: PoweeEeEer

Penso che il modo più semplice per alimentare questa cosa sia con un power bank e non esternamente. Manterremo la funzionalità di ricarica del nostro telefono o altro e controlleremo il flusso di corrente alla scheda tramite un interruttore. Individueremo i pin del connettore USB di uscita sulla scheda del circuito nel power bank che sono GND e Vcc (5V) e i fili di saldatura direttamente su di essi e da lì nella nostra scheda.

Passaggio 13: allegato… un po'

Ho davvero lottato con questo. Quando ho comprato la scatola in cui volevo inserire il PCB esistente, mi sono reso conto che non esiste un modo carino per adattare tutto come volevo e quindi ho deciso di progettare un nuovo PCB, questa volta con accoppiatori ottici. Volevo posizionare il PCB proprio sotto il lato su cui avrei praticato i fori per alcuni componenti che devono essere visti/toccati. Perché funzioni avrei bisogno di saldare il display e Arduino direttamente alla scheda, senza socket o header, ed è qui che sta il primo problema. È stato assolutamente orribile risolvere qualsiasi problema poiché non ero pronto a saldarlo subito fino a quando non ho verificato che tutto funzionasse, e non ho potuto testare davvero nulla poiché non potevo saldarlo e così via.. don non farlo. Problema numero dos, fare buchi sulla custodia. Immagino di aver preso le misure sbagliate perché nessuno dei fori sul case era allineato con i componenti sul PCB e ho dovuto allargarli e i pulsanti erano troppo in alto sul PCB e sarebbero sempre stati premuti quando mettevo la scheda in posizione e siccome volevo i jack audio sul lato, ho dovuto allargare anche quei fori per adattarli prima ai jack e poi abbassare la scheda per far passare il display e i pulsanti.. il risultato è terribile.

Ho reso i fori terribili meno terribili sovrapponendo la parte superiore con del cartoncino sottile in cui ho ritagliato fori più ragionevoli per i componenti e.. è ancora terribile, ma credo che sia più facile per gli occhi.

Verdetto, ti suggerisco di farlo acquistando componenti che si montano sulla custodia e non direttamente sul PCB. In questo modo hai più libertà nel posizionamento dei componenti e meno punti in cui commettere errori.

Passaggio 14: Fin

Ho finito, ma ecco alcune cose che avrei fatto diversamente:

Utilizzare jack audio da 3,5 mm di migliore qualità. Quelli che ho usato tendono a cortocircuitare i terminali durante l'inserimento o l'estrazione del jack, il che provoca il cortocircuito dell'alimentazione, ripristinando così l'Arduino o produce solo falsi trigger. L'ho detto nel passaggio precedente ma lo dirò di nuovo.. non saldare la scheda Arduino senza intestazioni/socket, rende solo qualsiasi tipo di risoluzione dei problemi o caricamento di nuovo codice e così via molto più difficile. Penso anche che avere un led di segnalazione che la cosa è accesa sarebbe stato utile perché spesso non riesco a capirlo senza premere il pulsante poiché il display si spegne. E l'ultima cosa, una funzione di pausa. Immagino che sia utile quando, ad esempio, quando si collega il sensore PIR, quindi perché ha bisogno di tempo per riscaldarsi, o semplicemente quando lo si sposta in giro non si vuole che si attivi, quindi si può semplicemente mettere in pausa tutto, ma si può anche semplicemente girare fuori dalla telecamera quindi.. qualunque cosa.

Un'altra cosa bella è quella di attaccarlo al velcro sul treppiede poiché è più probabile che venga utilizzato lì.

Sentiti libero di chiedere qualsiasi cosa su questo progetto nei commenti e mi piacerebbe sapere se lo costruisci e come è venuto fuori per te.