Maak een aangepaste Arduino-testbank met Wirewrapping - Ajarnpa

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

Deze Instructable laat je een eenvoudige manier zien om een Arduino Nano aan te sluiten op verschillende PCB-breakoutboards. Dit project kwam tot stand tijdens mijn zoektocht naar een effectieve, maar niet-destructieve manier om meerdere modules met elkaar te verbinden.

Ik had vijf modules die ik met elkaar wilde verbinden:

• Een Arduino
• Een 5-inch 800x480 grafisch LCD-aanraakscherm van Haoyu electronics
• Een SD-kaartlezer
• Een DS1302 real-time klokeenheid
• Een MAX485 RS-485/RS-422-zendontvanger

Het aanraakpaneel en de real-time klokmodules waren eerder gebruikt in mijn mijn Dali Clock- en mijn Rainbow Synthesizer-projecten, maar die prototypes waren op een breadboard gemaakt en waren gedemonteerd om ruimte te maken voor nieuwe projecten.

Het werd me duidelijk dat als ik al deze modules samen in een vaste armatuur zou hebben, ik meer tijd zou kunnen besteden aan het schrijven van software en minder tijd aan het bedraden van dingen op een breadboard. Tegelijkertijd wilde ik niets permanent aan elkaar solderen, zodat ik de modules kon bewaren voor toekomstig gebruik.

Deze Instructable laat zien hoe ik het allemaal samenvoeg met behulp van draadwikkeling.

Stap 1: De interconnecties plannen

Mijn eerste stap was om in kaart te brengen hoe alle modules te verbinden met de beschikbare pinnen op een Arduino Nano. Het display en de SD-kaart zijn beide SPI-modules. SPI is een bus, dus de CLK-, MISO- en MOSI-lijnen kunnen in serie worden geschakeld naar de modules die deze nodig hebben, samen met stroom. Elk zou echter hun eigen CS (Chip Select) -pin nodig hebben.

Ik besloot de RTC-module op zijn eigen pinnen te plaatsen omdat eerdere experimenten me hadden laten zien dat deze niet helemaal SPI-compatibel was. De zendontvangermodules hadden ook hun eigen pinnen nodig.

Nadat ik alles in kaart had gebracht, zag ik dat het er zo uitzag:

• Arduino Pin GND -> LCD GND -> SD-kaart GND -> Transceiver GND -> RTC 5V
• Arduino Pin 5V -> LCD 5V -> SD-kaart 5V -> Transceiver VCC -> RTC VCC
• Arduino Pin 13 -> LCD CLK -> SD-kaart CLK
• Arduino Pin 12 -> LCD MISO -> SD-kaart MISO
• Arduino Pin 11 -> LCD MOSI -> SD-kaart MOSI
• Arduino Pin 10 -> LCD CS
• Arduino Pin 9 -> LCD PD
• Arduino Pin 2 -> LCD INT
• Arduino Pin 8 -> RTC CLK
• Arduino Pin 7 -> RTC DAT
• Arduino Pin 6 -> RTC RST
• Arduino Pin 4 -> SD-kaart CS
• Arduino Pin 14 -> Transceiver DI
• Arduino Pin 15 -> Transceiver DE
• Arduino Pin 16 -> Transceiver RE
• Arduino Pin 17 -> Zendontvanger RO

Pinnen 0 en 1 worden gebruikt door de USB-interface, dus ze waren verboden terrein. Digitale pinnen 3, 5, 18 en 19 bleven vrij, evenals analoge ingangen A4 tot en met A7, waardoor toekomstige uitbreiding mogelijk was.

Stap 2: Het probleem met jumperdraden en wirewrap als oplossing

Aanvankelijk had ik geprobeerd alles met elkaar te verbinden met korte, op maat gemaakte, gekrompen Y-kabels. De crimps en connectoren zijn echter slechts ontworpen om één draad tegelijk te gebruiken. Het proppen van meerdere draden in één behuizing was moeilijk en leidde tot fragiele verbindingen die niet lang meegingen. Niet alleen was het krimpproces tijdrovend, eenmaal in gebruik zouden de connectoren zichzelf waarschijnlijk losraken van de pinnen, wat leidde tot extra tijdverspilling bij het opsporen van intermitterende fouten.

Ik had altijd al eens wirewrapping willen proberen, dus ik dacht dat dit een goede gelegenheid was om dat te doen. Na wat onderzoek kocht ik een WSU-30 M-gereedschap, wat extra lange 19 mm lange enkele rij headers en 30 AWG draadwikkeldraad op eBay.

Als technologie heeft draadwikkelen een lange geschiedenis. Het was een populaire manier om digitale computers te maken in de jaren '60, '70 en '80 en werd veelvuldig gebruikt in telefooncentrales. Hoewel het verouderd was door massaproductie van printplaten, heeft draadwikkelen de volgende voordelen voor de hobbyist:

• Het is goedkoop en snel
• Het is gemakkelijk aan te brengen en kan schoon worden verwijderd
• Het werkt met de pin-headers die op veel breakout-boards zijn gesoldeerd
• Het vormt een langdurige en betrouwbare verbinding
• Het maakt meerdere verbindingen van en naar elk punt mogelijk (wanneer lange headers worden gebruikt)

Stap 3: Een Arduino Nano voorbereiden

De volgende stap was het voorbereiden van mijn Arduino Nano. Ik had een Arduino Nano zonder headers, wat handig bleek te zijn, omdat ik de extra lange header-pinnen aan de bovenzijde wilde solderen, zodat ik de labels kon zien tijdens het draadwikkelen.

Ik heb ook wat extra lange headers gesoldeerd aan het kleine breakout-bord dat bij mijn display werd geleverd.

Op de zendontvangermodule bevonden de schroefklemmen zich aan de andere kant van de headers, dus ik heb ze gedesoldeerd en naar dezelfde kant als de headers verplaatst.

De andere borden hadden korte headers die al aan de juiste kant waren gesoldeerd, dus ik heb ze gehouden zoals ze zijn.

Stap 4: Een dienblad ontwerpen

Ik wilde alle elektronica aan de achterkant van de LCD-standaard kunnen monteren die ik voor mijn Dali Clock-instructie had gemaakt, dus heb ik iets in OpenSCAD gemodelleerd. Ik maakte uitsparingen voor de verschillende planken die ik wilde monteren.

Nadat ik de lade had uitgeprint, heb ik alle modules op hun plaats gelijmd.

Stap 5: Het proces van wirewrapping

Het proces van draadwikkelen bestaat uit de vier stappen: meten, snijden, strippen en wikkelen.

Ik meet voldoende draad af om de twee punten die ik wil verbinden te overspannen, plus een extra inch aan elk uiteinde om te wikkelen. Vervolgens verwijder ik 1 inch isolatie aan elk uiteinde en gebruik het gereedschap om de draad op de paal te wikkelen.

Het volgende is de exacte techniek die ik gebruik, die je kunt zien in mijn demonstratievideo:

• Ik meet de overspanning tussen twee punten die ik wil verbinden
• Ik markeer de gewenste lengte met mijn vingers en gebruik vervolgens een liniaal om twee centimeter toe te voegen
• Ik knip de draad op lengte
• Ik meet 1 en een 1/4 inch van het einde
• Vervolgens steek ik het uiteinde in het gat op de wikkeltool
• Ik trek de draad naar beneden in de opening in het snijblad
• Ik ruk de draad van het andere uiteinde en strip een centimeter draad bloot
• Ik herhaal het proces voor de andere kant van de draad

Met de draad aan beide uiteinden gestript, steek ik het blote draaduiteinde in de loop van het draadwikkelgereedschap zodat het gestripte gedeelte uit de inkeping aan de zijkant komt. Vervolgens schuif ik de punt naar beneden op een paal en draai hem een paar slagen, waarbij ik het gereedschap losjes vasthoud zodat het omhoog kan komen terwijl het kronkelt.

Een goede verbinding laat ongeveer 7 draadwindingen op de paal achter. Als de windingen op elkaar zijn gestapeld, duw dan niet zo hard op het gereedschap!

UPDATE: Een aantal van jullie heeft aangegeven dat de isolatie rond de paal moet worden gewikkeld voor trekontlasting. Ik heb twee foto's toegevoegd om het verschil te laten zien.

Stap 6: Wire Wrapping het hele bord

Dit toont het bord nadat ik alle verbindingen heb omwikkeld. Ik heb onderweg een paar fouten gemaakt, maar deze waren gemakkelijk ongedaan te maken door de draden af te knippen en een pincet te gebruiken om de uiteinden van de palen los te maken.

Ik stel voor om het een voor een te doen en je werk te controleren met een multimeter of door elk onderdeel in te schakelen en te testen. Het is een stuk moeilijker te repareren als er meerdere lagen draden zijn.

Mijn eindproduct ziet er een beetje rommelig uit, maar als je wilt kun je wat voorzichtiger zijn met de routing of verschillende kleuren gebruiken om het overzichtelijk te houden.

Ook al ziet het er niet mooi uit, het is een stuk robuuster dan een breadboard! Maar de grote bonus is dat als je het op enig moment uit elkaar wilt halen, je dit gemakkelijk kunt doen zonder schade aan de Arduino Nano of aan de pin-headers op de afzonderlijke borden!

Stap 7: Compatibele projecten

Met het ingevulde bord kunt u deze projecten uitvoeren:

• Smeltende digitale klok uit de jaren 80
• Een verlichte regenboogpiano met een Arduino (vereist externe componenten)