Arduino Guitar Jack Key Holder met Jack Recognition & OLED - Ajarnpa

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:17

Inleiding:

Deze instructable zal de bouw van mijn op Arduino gebaseerde Guitar Jack-plug-in-sleutelhouder beschrijven

Dit is mijn allereerste instructable, dus wees geduldig, want ik kan onderweg wijzigingen / updates aanbrengen

Stap 1: Onderdelen & Gereedschap

De meeste onderdelen die ik heb gekocht bij Amazon.co.uk of eBay, sommige had ik al aan het spelen - Hier is een lijst van wat je nodig hebt.

Amazon-links zijn allemaal Affiliate-links, misschien kun je elders goedkoper vinden - ik gebruik Amazon Prime veel, dus Amazon was toevallig mijn go-to.

Ik wilde deze build redelijk goedkoop en budgetvriendelijk houden. Je zou een groter TFT-scherm kunnen gebruiken als je dat wilt, evenals een andere Arduino. Gebruik geen NANO, omdat deze zal crashen vanwege het hoge geheugengebruik. De code gebruikt ongeveer 72% van het RAM-geheugen van de Pro Micro en is stabiel, maar na het testen zal een NANO crashen en vastlopen.

(Meer details in de stap Code.)

ONDERDELEN

1x Arduino Pro Micro -

1x 0,96 OLED met geel en blauw display -

4x WS2812 'Pixels' -

1x DS3231 RTC -

4x 1/4 Mono Jack (of zoveel als je wilt) - Amazon (Goud) of Amazon (Zilver) of eBay.co.uk

1x gemengd weerstandspakket -

4x 1/4 Gitaar Jacks -

1x Micro-USB-kabel Verlengkabel -

4x M3 Schroeven

GEREEDSCHAP & MATERIALEN

- Soldeerbout (dit is degene die ik heb gekocht - een TS100 - omdat deze kwam met extra tips

- Soldeer

- Heet lijmpistool (https://amzn.to/2UTd9PN)

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

- Draadknippers / strippers (https://amzn.to/2KzqUzp)

- 3D-printer of 3D-afdrukservice

OPTIONEEL - Deze items zijn optioneel, afhankelijk van hoe je ervoor kiest om alles aan te sluiten

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

- Schroefklemconnectoren (2-polig | 3-polig | 4-polig)

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

Stap 2: 3D-printen van de behuizing

Ik heb de mijne geprint op mijn Creality CR-10S, met behulp van Black PLA+ (https://amzn.to/2X2SDtE)

Ik heb geprint op 0,2 laags hoogte, met 25% vulling.

Stap 3: Alles samenvoegen + schema

Hoe je ervoor kiest om je Arduino aan te sluiten, is helemaal aan jou - ik heb er persoonlijk voor gekozen om mezelf als het ware een "schild" te maken. Om het schild te maken, heb ik vrouwelijke headers op veroboard gesoldeerd om bij de Pro Micro te passen, en vervolgens heb ik een rail van +5v en GND aan tegenovergestelde uiteinden toegevoegd. Ik heb jumperdraad gebruikt om de +5v aan te sluiten op mijn nu 5v 'rail', en deed hetzelfde voor de GND. Ik heb toen mijn 4x 100k-weerstanden toegevoegd, het ene uiteinde verbonden met +5v voor allemaal, en vervolgens maakt de andere kant verbinding met respectievelijk A0, A1, A2 en A3. Ik heb vervolgens schroefaansluitingen toegevoegd aan analoge pinnen A0, A1, A2 & A3 en ook pinnen 2 (SDA), 3 (SCL) & 4

Meet uw bedrading op en knip deze op de juiste lengte. Ik begon eerst met de WS2812 Pixel-LED's - de EERSTE WS2812-LED maakt verbinding met +5v van de Arduino, GND van de Arduino en DIN maakt verbinding met pin 4. Hierna worden de resterende 3 aan elkaar geketend, waarbij alle 5v> 5v worden geketend, GND > GND-pinnen en DOUT van de ene Pixel, maakt verbinding met DIN van de volgende. Eenmaal gesoldeerd, drukt u deze voorzichtig in de vierkante gaten aan de bovenkant, en hete lijm op hun plaats en ook om de achterkant te beschermen tegen onbedoelde verbindingen of kortsluitingen.

Na de LED's heb ik vervolgens de Guitar Jack Sockets erin geschroefd. Eén pin van elk wordt aangesloten op GND en vervolgens wordt de 2e pin van elk aangesloten op A0, A1, A2 en A3. Dus dat is Socket 1, naar A0, Socket 2 naar A1, Socket 3 naar A2 en Socket 4 naar A3.

Vervolgens heb ik 4 draden aan de OLED-aansluitingen gesoldeerd en overtollig soldeer zoveel mogelijk weggesneden. Je wilt je draden aan de achterkant van het scherm bevestigen, dus je soldeert aan de voorkant van het scherm.

Let op de pinnen! Sommige OLED's hebben GND aan de buitenkant, dan VCC, sommige hebben VCC aan de buitenkant en dan GND

Eenmaal gesoldeerd en je hebt de soldeerverbinding zo veel mogelijk getrimd of platgedrukt, druk je het scherm voorzichtig op zijn plaats. Het is qua ontwerp een beetje krap, maar houd er rekening mee dat verschillende afdruktoleranties hier invloed op kunnen hebben en dat u mogelijk wat kleine nabewerking moet doen om het passend te maken. Eenmaal op zijn plaats, plaats je wat hete lijm over elk van de 4 hoeken om het op zijn plaats te houden.

Sluit alles aan om overeen te komen met het schema en de afbeeldingen, en als je eenmaal tevreden bent, kun je de Pro Micro en RTC Clock ook op hun plaats lijmen en vervolgens de USB-extensie op de Pro Micro aansluiten.

Ik heb een micro-USB-extensie gebruikt zodat a) de USB kan worden gebruikt om stroom te leveren, maar meer nog, b) zodat het mogelijk was om de Pro Micro te herprogrammeren indien nodig zonder alles uit elkaar te halen

Als je tevreden bent, schroef je de behuizing aan elkaar met behulp van de 4 schroeven

Stap 4: De stekkers

De manier waarop dit werkt, is dat, in alle opzichten, een deel van het ontwerp werkt als een "ohmmeter". Een ohmmeter is een instrument voor het meten van elektrische weerstand. De meeste multimeters hebben deze functie waarbij u de schaal kiest en vervolgens een weerstand meet om de waarde te vinden. Het werkingsprincipe is dat je een BEKENDE weerstand aansluit op de +ve, die vervolgens wordt aangesloten op een ONBEKENDE weerstand, die aansluit op -ve. De verbinding tussen de 2 weerstanden maakt verbinding met de Arduino analoge pin zodat deze de spanning kan lezen en de weerstand kan berekenen.

Het werkt als een spanningsdeler en berekent de weerstand van de onbekende weerstand.

Als spanningsdelernetwerk van weerstanden R1 en R2

Vout = Vin * R2 / (R1 + R2) - We gebruiken 100k voor onze bekende (R1) weerstand. Dit geeft ons de "spanningsval"

Hieruit kunnen we nu de weerstand van de onbekende (R2) weerstand berekenen, R2 = Vout * R1 / (Vin – Vout) - waarbij R1 onze 100k (100.000 ohm) weerstand is

Door een andere weerstand te gebruiken in elke plug die u wilt gebruiken, kunt u de code dienovereenkomstig aanpassen, afhankelijk van de gebruikte jack.

Ik gebruik 4 jackpluggen. Ik heb ervoor gekozen om te gebruiken:

Bekende weerstand (x4) - 100k

Jackplug 1 - 5,6 k

Jackplug 2 - 10k

Jackplug 3 - 22k

Jackplug 4 - 39k

Je kunt dit natuurlijk uitbreiden en zoveel coderen als je wilt.

Stap 5: De code

Ten eerste heb je de Arduino IDE nodig, die hier beschikbaar is:

Je moet er ook voor zorgen dat je een paar Arduino-bibliotheken hebt:

Adafruit NeoPixel:

u8g2:

Adafruit RTCLib:

Adafruit SleepyDog (optioneel):

Een opmerking over het kiezen van het juiste "Arduino"-bord. Oorspronkelijk begon ik dit project met een Arduino Nano, omdat ze super goedkoop zijn voor ongeveer £ 3-£ 4 in het VK, of slechts £ 1,50 als je koopt bij AliExpress (maar let niet op de wachttijd van 30-50 dagen). Het probleem met de Nano is dat het SRAM 2 KB (2048 bytes) is. Deze schets gebruikt 1728 bytes dynamisch geheugen met globale variabelen. Dat is 84% van het SRAM, waardoor er slechts 320 bytes vrij zijn voor lokale variabelen. Dit was onvoldoende en zou de Nano doen vastlopen en bevriezen.

De Pro Micro (Leonardo) heeft 2,5K SRAM (2560 bytes), wat betekent dat er 694 bytes vrij zijn voor lokale variabelen (de schets gebruikt 72% van de Pro Micro's SRAM). Tot nu toe is dit perfect geschikt en stabiel gebleken voor mijn gebruik. Als u van plan bent veel jackpluggen te gebruiken, kunt u overwegen iets met meer SRAM te gebruiken.

Wat Flash-opslag betreft, gebruikt deze schets 88% (25252 bytes) van 30k (de ATMega328p [Nano] en ATMega32u4 [Pro Micro] hebben beide 32k, maar 2k is gereserveerd voor de bootloader)

Ik heb in de loop der jaren honderden Arduino-schetsen geschreven, maar ik ben een hobbyist - houd er dus rekening mee dat sommige delen van de code inefficiënt kunnen zijn of dat er "betere manieren om dit te doen" scenario's zijn. Dat gezegd hebbende, het werkt perfect voor mij en ik ben er blij mee. Ik gebruikte bibliotheken die op de meeste borden zouden moeten werken, of het nu AVR (meest eenvoudige Arduino's) of SAMD21 is (ik heb een handvol Cortex M0-apparaten)

Ik wilde ook een andere afbeelding weergeven op basis van de gebruikte aansluiting. Als u uw eigen afbeeldingen wilt maken, is dit een briljante eenvoudige handleiding voor het maken van de C-array voor afbeeldingen die met dit scherm worden gebruikt:

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

Zorg ervoor dat u PROGMEM gebruikt voor uw afbeeldingen. Bijv.:

statische const unsigned char YOUR_IMAGE_NAME PROGMEM = { }

Door het ontwerp zal het scherm na 5 seconden "time-out" zijn en terugkeren naar het weergeven van de tijd.

De meeste instellingen zijn te vinden in Settings.h, met name de naam van de bijbehorende jackpluggen zijn hier gecodeerd:

#define PLUG1 "TOETSEN"

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

Er zijn ook enkele belangrijke delen van code in Variables.h

vlotter R1=96700.0;

vlotter R2=96300,0; vlotter R3=96500,0; vlotter R4=96300,0;

Dit zijn de BEKENDE weerstandswaarden, in ohm, van elk van de 4 weerstanden.

R1 aangesloten op A0, R2 op A1, R3 op A2 en R4 op A3.

Het is raadzaam om uw 100k-weerstanden te meten met een multimeter en de exacte waarde van de weerstand te gebruiken. Meet de weerstand als alles is aangesloten. (Maar niet ingeschakeld).

Zorg er bij het kiezen van weerstanden voor je jackpluggen voor dat er een goede ohmspleet tussen zit, en geef jezelf bij het coderen een mooi bereik dat lager en hoger is dan de door jou gekozen weerstand. Dit is wat ik in mijn code heb gebruikt:

vlotter P1_MIN=4000,0, P1_MAX=7000,0; // 5,6K

vlotter P2_MIN=8000,0, P2_MAX=12000.0; // 10K vlotter P3_MIN=20000.0, P3_MAX=24000.0; // 22K vlotter P4_MIN=36000,0, P4_MAX=42000.0; // 39K

De reden hiervoor is om rekening te houden met de analoge uitlezing en de kleine spanningsschommelingen enz

Dus wat er gebeurt, is dat als de gedetecteerde weerstand tussen 4000 ohm en 7000 ohm ligt, we aannemen dat u een weerstand van 5,6k hebt gebruikt en dat de code dit dus ziet als Jack Plug 1. Als de gemeten weerstand tussen 8000 ohm en 12000 ohm, de veronderstelling is dat het een weerstand van 10k is en Jack Plug 2 is, enzovoort.

Als je wat debugging moet doen (laat niet onbecommentarieerd in 'productie' aangezien seriële debugging kostbare ram verbruikt), verwijder dan gewoon de regels die je nodig hebt bovenaan Settings.h

//#define SERIAL_DEBUG

//#define WAIT_FOR_SERIAL

Om commentaar ongedaan te maken, verwijdert u eenvoudig de // …. om de regel weer te becommentariëren, voegt u de // opnieuw toe aan de voorkant van de regel.

SERIAL_DEBUG maakt de seriële foutopsporing mogelijk en het gebruik van dingen zoals (bijvoorbeeld)

Serial.println(F("hallo wereld"));

WAIT_FOR_SERIAL is een extra stap, dat betekent dat de code niet verdergaat totdat u de seriële monitor opent. Dit helpt ervoor te zorgen dat u geen belangrijke seriële berichten mist. - LAAT DIT NOOIT INGESCHAKELD

Als u WAIT_FOR_SERIAL ingeschakeld laat, kunt u uw sleutelhouder niet gebruiken in een "echte" omgeving, omdat deze zal wachten op de Arduino IDE seriële monitor voordat deze verder kan gaan in de hoofdlus van de schets. Als je klaar bent met debuggen, zorg er dan voor dat je het commentaar van deze regel weer opheft en upload je schets opnieuw voor productie/voltooiing.

Bij gebruik van de optie SERIAL_DEBUG bevat mijn code het volgende:

#ifdef SERIAL_DEBUG

Serial.print(F("ACTIVE JACK = ")); 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); } Serieel.println(); if (INSERTED[socket]) { Serial.print(F("Plug in socket")); Seriële.print (socket+1); Serial.print(F(" heeft een weerstand van: ")); Serial.println(weerstand); } #stop als

De laatste Serial.print-regel zal u vertellen wat de weerstand is, in ohm, van de laatst geplaatste aansluiting. Je kunt deze schets dus ook gebruiken als een soort ohmmeter om de weerstand van een jackplug te controleren.

Stap 6: Opmerkingen

Ik denk dat ik alles heb behandeld, maar reageer alsjeblieft en ik zal mijn best doen om te lezen en te antwoorden wanneer ik kan:)

Excuses voor de ietwat slechte video - ik heb geen statief, hercoderingsopstelling of een goede werkruimte om zo te zeggen, dus dit werd gefilmd (slecht) terwijl ik de telefoon in de ene hand hield en probeerde hem met de andere te demonstreren.

Bedankt voor het lezen.