Portachiavi Arduino Guitar Jack con riconoscimento jack e OLED: 7 passaggi

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

Introduzione:

Questa istruzione descriverà in dettaglio la costruzione del mio portachiavi plug-in Guitar Jack basato su Arduino

Questa è la mia prima istruzione in assoluto, quindi per favore abbi pazienza con me perché potrei apportare modifiche / aggiornamenti lungo la strada

Passaggio 1: parti e strumenti

La maggior parte delle parti che ho acquistato da Amazon.co.uk o eBay, alcune le avevo già in giro - Ecco un elenco di ciò di cui avrai bisogno.

I link di Amazon sono tutti link di affiliazione, potresti trovarli più economici altrove: io uso molto Amazon Prime, quindi Amazon è semplicemente il mio punto di riferimento.

Volevo mantenere questa build abbastanza economica e conveniente. Potresti usare uno schermo TFT più grande se lo desideri, così come un Arduino diverso. Non utilizzare un NANO, poiché si bloccherà a causa dell'elevato utilizzo della memoria. Il codice utilizza circa il 72% della RAM di Pro Micro ed è stabile, ma dai test, un NANO si bloccherà e si bloccherà.

(Maggiori dettagli nel passaggio Codice.)

PARTI

1x Arduino Pro Micro -

1x OLED da 0,96 con display giallo e blu -

4x WS2812 "Pixel" -

1x DS3231 RTC -

4x jack mono da 1/4 (o quanti ne vuoi) - Amazon (oro) o Amazon (argento) o eBay.co.uk

1x pacchetto di resistori misti -

4 jack per chitarra da 1/4 -

1x cavo di prolunga per cavo micro USB -

4x viti M3

STRUMENTI E MATERIALI

- Saldatore (questo è quello che ho comprato - un TS100 - poiché è arrivato con punte aggiuntive

- Saldare

- Pistola per colla a caldo (https://amzn.to/2UTd9PN)

- Filo (https://amzn.to/2VK2ILU)

- Tagliafili/spelafili (https://amzn.to/2KzqUzp)

- Stampante 3D o servizio di stampa 3D

FACOLTATIVO - Questi elementi sono opzionali, a seconda di come si sceglie di collegare tutto

- Veroboard / Stripboard (https://amzn.to/2KzMFPE)

- Connettori terminali a vite (2 poli | 3 poli | 4 poli)

- Intestazioni PCB (https://amzn.to/2X7RjWf)

Passaggio 2: stampa 3D della custodia

Ho stampato il mio sul mio Creality CR-10S, utilizzando Black PLA+ (https://amzn.to/2X2SDtE)

Ho stampato ad un'altezza di 0,2 strati, con il 25% di riempimento.

Passaggio 3: mettere tutto insieme + schema

Il modo in cui scegli di collegare il tuo Arduino dipende interamente da te: personalmente ho scelto di farmi uno "scudo" per così dire. Per realizzare lo scudo, ho saldato le intestazioni femminili al veroboard per abbinare il Pro Micro, quindi ho aggiunto un binario di +5v e GND, alle estremità opposte. Ho usato il ponticello per collegare il +5v alla mia "guida" ora 5v e ho fatto lo stesso per il GND. Ho quindi aggiunto i miei 4 resistori da 100k, un'estremità collegata a +5v per tutti loro, quindi l'altro lato si collega rispettivamente a A0, A1, A2 e A3. Ho quindi aggiunto terminali a vite ai pin analogici A0, A1, A2 e A3 e anche ai pin 2 (SDA), 3 (SCL) e 4

Misura il cablaggio e taglialo alla lunghezza appropriata. Ho iniziato prima con i LED Pixel WS2812: il PRIMO LED WS2812 si collega a +5v da Arduino, GND da Arduino e DIN si collega al Pin 4. Dopodiché, i restanti 3 sono concatenati insieme, concatenando tutti i 5v > 5v, GND > pin GND e DOUT di un Pixel, si collega al DIN del successivo. Una volta saldati, premerli delicatamente nei fori quadrati nella parte superiore e incollare a caldo in posizione e anche per proteggere la parte posteriore da eventuali collegamenti accidentali o cortocircuiti.

Dopo i LED, ho avvitato le prese jack per chitarra. Un pin di ciascuno si collega a GND, quindi il secondo pin di ciascuno si collega a A0, A1, A2 e A3 di conseguenza. Quindi è presa 1, ad A0, presa 2 ad A1, presa 3 ad A2 e presa 4 ad A3.

Successivamente ho saldato 4 fili alle connessioni OLED e ho ridotto il più possibile la saldatura in eccesso. Vuoi collegare i fili dalla parte posteriore dello schermo, quindi stai saldando alla parte anteriore dello schermo.

Attenzione ai pin! Alcuni OLED hanno GND all'esterno, quindi VCC, alcuni hanno VCC all'esterno e quindi GND

Una volta saldato e tagliato o appiattito il più possibile la connessione di saldatura, premere delicatamente lo schermo nella sua posizione. È un po' stretto in base al design, ma tieni presente che tolleranze di stampa diverse possono influire su questo e quindi potresti dover eseguire alcune piccole operazioni di post-elaborazione per adattarlo. Una volta posizionato, metti della colla a caldo su ciascuno dei 4 angoli per tenerlo in posizione.

Collega tutto in modo che corrisponda allo schema e alle immagini e, una volta soddisfatto, puoi incollare a caldo anche Pro Micro e RTC Clock in posizione, quindi collegare l'estensione USB a Pro Micro.

Ho usato un'estensione micro USB in modo che a) l'USB possa essere utilizzato per fornire alimentazione, ma soprattutto, b) in modo che fosse possibile riprogrammare il Pro Micro, se necessario, senza smontare tutto

Una volta soddisfatto, avvita la custodia usando le 4 viti

Passaggio 4: le spine

Il modo in cui funziona è che, a tutti gli effetti, parte del design funziona come un "ohmmetro". Un ohmmetro è uno strumento per misurare la resistenza elettrica. La maggior parte dei multimetri ha questa funzione per cui si seleziona la scala e quindi si misura un resistore per trovarne il valore. Il principio di funzionamento è che si collega un resistore CONOSCIUTO al +ve, che viene quindi collegato a un resistore SCONOSCIUTO, che si collega a -ve. Il giunto tra i 2 resistori si collega al pin analogico di Arduino in modo che possa leggere la tensione e calcolare la resistenza.

Funziona come un partitore di tensione e calcola la resistenza del resistore sconosciuto.

Come una rete divisore di tensione di resistori R1 e R2, Vout = Vin * R2 / (R1 + R2) - Stiamo usando 100k per il nostro noto resistore (R1). Questo ci dà la "caduta di tensione"

Da questo, possiamo ora calcolare la resistenza del resistore sconosciuto (R2), R2 = Vout * R1 / (Vin – Vout) - dove R1 è il nostro resistore da 100k (100.000 ohm)

Utilizzando un resistore diverso in ogni presa jack che si desidera utilizzare, è possibile regolare il codice di conseguenza in base alla presa in uso.

Sto usando 4 prese jack. ho scelto di usare:

Resistenza conosciuta (x4) - 100k

Spina jack 1 - 5,6 k

Spina Jack 2 - 10k

Spina Jack 3 - 22k

Spina Jack 4 - 39k

Ovviamente potresti espanderlo e codificarne quanti ne desideri.

Passaggio 5: il codice

Innanzitutto, avrai bisogno dell'IDE Arduino, disponibile da qui:

Dovrai anche assicurarti di avere anche alcune librerie Arduino:

Adafruit NeoPixel:

u8g2:

Adafruit RTCLib:

Adafruit SleepyDog (opzionale):

Una nota sulla scelta della giusta tavola "Arduino". Originariamente ho iniziato questo progetto con un Arduino Nano, perché sono super economici a circa £ 3- £ 4 nel Regno Unito, o fino a £ 1,50 se acquisti da AliExpress (ma non preoccuparti dell'attesa di 30-50 giorni). Il problema con il Nano è che la sua SRAM è di 2 KB (2048 byte). Questo schizzo utilizza 1728 byte di memoria dinamica con variabili globali. Questo è l'84% della SRAM, lasciando solo 320 byte liberi per le variabili locali. Questo era insufficiente e avrebbe causato il blocco e il congelamento del Nano.

Il Pro Micro (Leonardo) ha 2,5K SRAM (2560 byte), il che significa che ci sono 694 byte liberi per le variabili locali (lo schizzo utilizza il 72% della SRAM di Pro Micro). Finora questo si è dimostrato perfettamente adeguato e stabile per il mio utilizzo. Se intendi utilizzare molte prese jack, potresti prendere in considerazione l'utilizzo di qualcosa con più SRAM.

Per quanto riguarda l'archiviazione Flash, questo sketch utilizza l'88% (25252 byte) di 30k (ATMega328p [Nano] e ATMega32u4 [Pro Micro] hanno entrambi 32k, ma 2k sono riservati al bootloader)

Ho scritto centinaia di schizzi Arduino nel corso degli anni, ma sono un hobbista, quindi tieni presente che alcune parti del codice potrebbero essere inefficienti o potrebbero esserci scenari "migliori per farlo". Detto questo, funziona perfettamente per me e sono soddisfatto. Ho usato librerie che DOVREBBE funzionare sulla maggior parte delle schede, che si tratti di AVR (la maggior parte degli Arduino di base) o SAMD21 (ho una manciata di dispositivi Cortex M0)

Volevo visualizzare una grafica diversa anche in base al jack utilizzato. Se vuoi crearne uno tuo, questa è una guida semplice e geniale su come creare l'array C per le immagini da utilizzare con questo display:

sandhansblog.wordpress.com/2017/04/16/interface-displaying-a-custom-graphic-on-an-0-96-i2c-oled/

Assicurati di utilizzare PROGMEM per la tua grafica. Per esempio:

static const unsigned char YOUR_IMAGE_NAME PROGMEM = { }

In base alla progettazione, lo schermo "scadrà" dopo 5 secondi e tornerà a visualizzare l'ora.

La maggior parte delle impostazioni può essere trovata in Settings.h, in particolare, il nome delle prese jack associate è codificato qui:

#define PLUG1 "CHIAVI"

#define PLUG2 "P2" #define PLUG3 "P3" #define PLUG4 "P4" #define GENERICO "NA"

Ci sono anche alcune parti importanti del codice all'interno di Variables.h

float R1=96700.0;

float R2=96300.0; galleggiante R3=96500.0; galleggiante R4=96300.0;

Questi sono i valori di resistenza CONOSCIUTI, in ohm, di ciascuno dei 4 resistori.

R1 connesso ad A0, R2 ad A1, R3 ad A2 e R4 ad A3.

Si consiglia di misurare i resistori da 100k utilizzando un multimetro e utilizzare il valore esatto del resistore. Prendi la misura della resistenza una volta che tutto è collegato. (Ma non acceso).

Quando scegli i resistori per i tuoi jack, assicurati che ci sia un buon divario di ohm tra di loro e, quando li codifichi, datti una bella gamma più bassa e più alta del resistore scelto. Ecco cosa ho usato nel mio codice:

float P1_MIN=4000.0, P1_MAX=7000.0; // 5.6K

float P2_MIN=8000.0, P2_MAX=12000.0; // 10K float P3_MIN=20000.0, P3_MAX=24000.0; // 22K float P4_MIN=36000.0, P4_MAX=42000.0; // 39K

La ragione di ciò è tenere conto della lettura analogica e delle fluttuazioni di tensione minori, ecc

Quindi quello che succede è che se la resistenza rilevata è compresa tra 4000 ohm e 7000 ohm, si presume che tu abbia utilizzato un resistore da 5,6 k e quindi il codice lo vedrà come Jack Plug 1. Se la resistenza misurata è compresa tra 8000 ohm e 12000 ohm, il presupposto è che sia un resistore da 10k ed è Jack Plug 2 e così via.

Se hai bisogno di fare un po' di debug (non lasciare il commento in 'produzione' poiché il debug seriale utilizza la preziosa ram) decommenta semplicemente le righe richieste nella parte superiore di Settings.h

//#define SERIAL_DEBUG

//#define WAIT_FOR_SERIAL

Per decommentare, rimuovere semplicemente // …. per commentare la riga di nuovo, aggiungi nuovamente // all'inizio della riga.

SERIAL_DEBUG abilita il debug seriale e l'uso di cose come (ad esempio)

Serial.println(F("ciao mondo"));

WAIT_FOR_SERIAL è un passaggio aggiuntivo, il che significa che finché non si apre il monitor seriale, il codice non continuerà. Questo aiuta a non perdere nessun messaggio seriale importante. - NON LASCIARE MAI ATTIVATO

Se lasci WAIT_FOR_SERIAL abilitato, non sarai in grado di utilizzare il portachiavi in nessun ambiente "reale" poiché rimarrà bloccato in attesa del monitor seriale IDE Arduino prima che possa continuare nel ciclo principale dello schizzo. Una volta completato il debug, assicurati di decommentare nuovamente questa riga e ricaricare lo schizzo per la produzione/il completamento.

Quando si utilizza l'opzione SERIAL_DEBUG, il mio codice contiene quanto segue:

#ifdef SERIAL_DEBUG

Serial.print(F("JACK ATTIVO = ")); Serial.println(ACTIVE_JACK); int len = sizeof(SOCKET_1234_HAS_PLUGTYPE_X)/sizeof(SOCKET_1234_HAS_PLUGTYPE_X[0]); for (int i=0;i<len;i++) { Serial.print(F("SOCKET_1234_HAS_PLUGTYPE_X[")); Serial.print(i); Serial.print(F("] = ")); Serial.println(SOCKET_1234_HAS_PLUGTYPE_X); } Serial.println(); if (INSERTED[socket]) { Serial.print(F("Plug in socket ")); Serial.print(socket+1); Serial.print(F(" ha una resitenza di: ")); Serial.println(resistenza); } #finisci se

L'ultima riga Serial.print ti dirà qual è la resistenza, in ohm, dell'ultimo jack inserito. Quindi puoi anche usare questo schizzo come una sorta di ohmmetro per controllare la resistenza di una presa jack.

Passaggio 6: note

Penso di aver coperto tutto, ma per favore commenta e farò del mio meglio per leggere e rispondere quando posso:)

Mi scuso per il video un po' scadente: non ho un treppiede, una configurazione di ricodifica o uno spazio di lavoro adeguato per così dire, quindi questo è stato filmato (male) tenendo il telefono in una mano e cercando di dimostrarlo con l'altra.

Grazie per aver letto.