There is a few ingredients to make a successful wearable, and they all work together. There is not a fixed place to start - some people work better with a thought-through concept, others work better when they start making.
What’s your inspiration? What’s the concept, what do you want to say with your wearable piece of art?
Where and how do you wear it? Pick a part of the body - are you making something for on your head? Around your arm? On your hand? How can you make it wearable for that body part?
This can change along the way! By trying out your wearable as you’re making it on different parts of the body, it can go in different directions.
Pick your input/output - is it moving, emitting light or making sound? Is there an interaction: does it react to sound or dimming of light? Pick your electronics based on that. You can try out different options and see what you like
Prototyping your electronics on a breadboard is the easiest
Pick your materials - what is it made of? Is it hard or soft? How do you attach it to the body? Prototype in 3D!
Make something wearable from scratch - i.e. with patterns, elastic, straps, velcro, etc.
Build on something existing - i.e. on a glove or headband
There are various ways to make something wearable. You can use all kinds of clips, hairbands, gloves, velcro, straps… Below you can find some of the available options.
Tools, techniques, machines & materials
To make your actual wearable, you can use various techniques - from quick cardboard prototyping with glue to sewing & jewelry making techniques. Below are some examples of materials and techniques to create 2D and 3D shapes to give shape to your wearable!
Creating three dimensional shapes with
Metal wire
Fabric, color filter sheets
Sewing machine zigzag
Set the sewing machine to zigzag and carefully start sewing:
You can also work directly on a piece of clothing! You could make an e-textile pressure or touch sensor for example.
Other prototyping materials and techniques to explore:
Air drying modeling clay: clay modeling techniques & tools
Metal wire: jewelry making techniques, soldering
Fabric & thread: sewing, textile craft techniques
Conductive fabric: soldering
Embedding electronic components in clay
Sewing LEDs onto fabric
Glueing
Integrating electronics into wearables
How do you go from a messy breadboard and wearable elements to electronics that you can wear? If you make something big, you often have some space to hide your electronics under something. If it’s small, then you need other solutions. It’s not always about how to make your circuit invisible, but rather how you can place your microcontroller and battery in relation to your input and output, in a way that looks natural or intentional. If you can’t hide it, you can always make it part of the look! For example, if you want to make an earring with a motor, why not make another earring in which you can put your battery and microcontroller? Or you could have a microcontroller necklace that you can wear under your shirt, or on top if you make it look nice! If you make something to wear on your head, maybe you can hide your microcontroller and battery under a ponytail, or you can place the microcontroller and battery on a clip that you pin to the back inside of your shirt.
And don’t forget: we’re prototyping, so it’s also okay if it’s not immediately the most efficient, optimal, final form of your wearable dreams. You have to start somewhere!
Your wearable art has 3 ingredients:
Battery powered electronics
Something that makes it wearable
An interesting input/output/interaction coming to life with electronics and your creations
Here you can see these elements laid out: there is a microcontroller powered with a rechargeable LiPO battery, there is a headband to wear it on your head, and there is an eye antenna attached to the servo motor that can float in front of you like a deep sea fish. With these ingredients, you could glue the microcontroller and battery to a hair clip and hide it in a bun or under your hair, or you could make the wires longer and hide it a bit further away.
Swaying necklace
Another example to make something wearable is to make a necklace with a pouch like here.
The microcontroller and the battery fit in the pouch, and match with the swaying ribbon. This is an example of hiding the electronics in plain sight by making them match with the wearable.
Swinging ring
Now, if you want the movement on your hand instead, you could attach the motor to a glove, or in this case, bend metal wire to make a ring.
Here you can see it in action:
The electronics are simply hidden in my sleeve. I’m wearing them on my skin by sticking pieces of velcro to my arm and to the battery and microcontroller, so they easily come off if needed but they are still pretty stable. This is nice for prototyping. They could also be velcro’ed to a bracelet or sleeve.
Interactive scarf
In this next example (using the Arduino example LDR_NeoPixel_amount), the electronics can be hidden in the wearable object (a scarf) itself.
The lights (Neopixels) need to go on the inside, but the LDR needs to be on the outside so it can detect lighting changes.
Interaction prototyping
Here you can see it in action. Once you have a first prototype, you can start the prototyping the interaction that you want. There is plenty of ways to influence the amount of light on an LDR: covering it with your hand, walking into a darker area, putting something on top of it. Many things to try out!
Here, a subtle movement of the neck is already enough to turn on the lights.
Keyboard glove
This is an example of a very simple capacitive touch keyboard that you can wear. It’s made with conductive tape on an existing glove.
The code is basically the same as the touch_keyboard_speaker.ino example, but with 5 instead of 6 touch sensors. When changing the amount of touch sensors, make sure you change all of the arrays by adding or removing values according to the amount you have (I spent 30 minutes trying to figure out why it was acting weird because of this).
A next step would be to integrate the electronics and solder wires to the conductive tape instead of using alligator clips.
Another nice iteration would be to add an MP3 module with custom sounds, to go beyond the bleepy sounds from the tone function.
More examples & inspiration
Embroidery, embedding electronics into soft circuits
Second Skins Re-FREAM by Malou Beemer shows integration of LEDs into garments, using textiles to diffuse the light. It also shows traces sewn with a sewing machine on the project page.
You can already make electronic wearables without a microcontroller. For example, you can use a coin cell battery (and optional coin cell battery holder with on/off switch) and an LED or LED filament and make something that emits light. You can even make it interactive by introducing an LDR (light dependent resistor) to the mix. But once you start using a microcontroller and programming, the sky is the limit!
Kit
You all received a kit with the following content:
Seeed Studio XIAO ESP32S3 development board + 2 sets of header pins + Bluetooth antenna
Grove Shield for XIAO with battery management chip
Breadboard
Jumper wires (male/male & male/female)
Lithium ion battery (3.7V 600mAh)
USB-C to USB-C or USB-A cable
LED
LDR
2 resistors: 67 Ohm and 4.7k Ohm
Micro servo motor
Piezo buzzer
Check if the content of your kit matches the picture below (approximately):
Soldering
Here is a soldering comic adaptation by Andie Nordgren that shows you the basics of soldering:
And here another reference image:
We are going to bring this to action with the header pins of the XIAO board, so we can easily prototype electronic circuits:
When soldering wires, make sure your connections are strong.
You could for example make a flexible LDR voltage divider like this:
Setting up the Arduino IDE
In these examples we’re using a Seeed Studio XIAO ESP32S3. Their wiki is a great place to get started and acquainted with all of the possibilities this tiny development board has to offer. But first, we need to install some drivers. For both Mac and Windows, you can get them here (CP210x VCP Mac OSX Driver or CP210x Windows Drivers). For Mac, it can also work to just follow the steps below and then upload something to your ESP32 for the first time; there should be a prompt to install some drivers at some point.
For a quick start, follow these steps in the Arduino IDE (assuming you have it installed already; if not, download the latest stable version and launch it):
Now, navigate to Tools > Board > Boards Manager..., type the keyword “esp32” in the search box, select 2.0.17 (the latest version, 3.x.x, does not work with the ESP32Servo library) and install it.
Plug in your board and select the board and port from the dropdown menu in the top left of the interface. Click on ‘Select other board and port’ and look for the XIAO_ESP32S3.
That should be it! Now you can start uploading the example code or write your own. One thing to keep in mind with ESP32s is that sometimes they’re in the wrong mode for programming. You can get back to boot mode by unplugging the board, then pressing and holding down the boot button on the board, then plugging it back in. Now it should work again :-)
Basic setup
To prototype wearables, we’re going to use the Grove Shield for XIAO, which makes trying things out very easy. You can even charge your LiPO battery with the XIAO while it’s on the shield, so you don’t need a separate charger for it. It’s plug and play and you can snap off the smaller part of the base if you don’t need it. It snaps off easily:
You can always leave out the shield if it’s too bulky for your final wearable once you know how you want to wire everything. There is also protoboard available if you prefer to solder it all together.
To start out, we’ll use the shield as a prototyping board together with a breadboard. You can plug Grove cables into the sockets to connect the data pins to your inputs and outputs, you can solder wires to the GPIO holes or you can solder sockets into the GPIO holes (like below) to plug in jumper wires to plug & play!
You can also just use the mini breadboard to start prototyping with, and leave the shield for later!
Battery use
Please pay careful attention when plugging in the battery into the development shield: connect + to + and - to minus!
The battery is about the same size as the shield, so you could fold it like this and use velcro or double sided tape to stick them together. I wouldn’t use glue since I’m not sure how it would react with the battery and the shield.
I would cover the bottom of the board with tape to avoid making any short circuits, for example if you want to glue a metal clip to the base to make it wearable.
Resistors
For the LEDs, we are using a 67 Ohm current limiting resistor. The values for the resistor in series with an LED depend on a couple of factors (color, power supply voltage, current rating); 67 Ohm is based on a power supply voltage of 3.3V, an average voltage drop of 2V and a current rating of the LED of 20 mA. There’s calculators for this online :-) If you use a bigger value resistor, it will still work, but the LED will shine a little less bright. If you use a smaller value resistor, the LED may shine a bit brighter, but it could also break in the long term (theoretically).
For the LDR there is a 4.7k Ohm resistor in your kit. I chose this value because it works well with the LDRs as they have a similar range. If you buy your own LDRs they may have different min and max values so try it out or check the datasheet.
Arduino code & circuits
Example code can be found in the Arduino (code) folder. You can find examples on programmed and external, digital, analog and touch input, combined with light, motion or sound output. Below you can find how you should wire up the circuits on a breadboard. This is also described in the Arduino code files. Find out how they work in the Arduino code files too!
Programmed input
Blinking an LED (light output, digitalWrite)
Fading an LED (analogWrite, PWM)
Wire up your circuit on the breadboard like this:
Here is a video of what the output should be.
If you connect the LED to an ESP32S3 on a Grove shield, the result is the same:
Digital input
Using a momentary push button to turn on an LED (digitalRead, using internal pullup resistor)
Wire up your circuit like below.
Analog input
Reading LDR sensor data (serial monitor)
Using LDR sensor data to fade LED (mapping input values to output values)
Using LDR sensor data to light up Neopixels (libraries)
For the LDR & LED examples, set up your circuit like below.
Here you can see the expected interaction:
And for the Neopixel strip, wire it up like this:
Also an example when the ESP32S3 is on the Grove shield:
Sweeping a servo with LDR input (motion output)
Wire up like this:
As a wearable, this is what you can do with a servo motor and an LDR!
If you’ve made the circuit with an LDR, it’s only one step further to connect your own, self made sensor! Take out the LDR, and stick two jumper wires to alligator clip in where the LDR legs were.
Touch input
Turning on an LED with touch (touchRead, using input to do something with output, while statement)
Toggling an LED with touch (if/else statement)
Fading an LED with touch (touchRead, mapping capacitance ranges)
Mapping a capacitance range to tones on a speaker (sound output, tone)
Using touch pins to make a keyboard (multiple pins, arrays)
For the touch & LED examples, wire up the breadboard like below. The alligator clip can also be a male/male jumper wire, as long as there is something that you can touch.
Here a jumper wire is used; when you touch the end of the wire, the LED lights up.
The touch & speaker examples can be wired up like below; in this example it’s with a buzzer but it also works with a piezo buzzer like in the kit!
The touch range example sounds like this:
You can also connect something conductive, like a conductive spool knitted sample. Now the interaction is way more interesting!
And if you want more touch sensors, just plug in more wires in the touch pins you want to use. I moved the speaker to the other side now so all touch inputs are on one side.
Introductie & presentatie (voorbeelden van mogelijke inputs/outputs, draagbare maaktechnieken, interacties)
13:45-14:15
Ideevorming, brainstormen, schetsen
14:15-15:00
Crashcursus Elektronica & Arduino-programmering gericht op wat jullie willen. Als je al bekend bent met elektronica/programmeren: beginnen!
15:00-15:15
Pauze
15:15-16:45
Prototyping van circuits en (onderdelen van) het draagbare kunstwerk
16:45-17:00
Show & tell, opruimen
Workshop dag 2
13:00-17:00
13:00-13:15
Binnenkomst, welkom, wat heb je nodig om te beginnen?
13:15-15:00
Werken aan het tot leven brengen van de draagbare kunst: elektronica & vormen samenbrengen, het draagbaar maken, het integreren van het elektronische circuit
15:00-15:15
Pauze
15:15-16:30
Prototypes afmaken: testen, troubleshooten, puntjes op de i
16:30-17:00
Wearable art show! Resultaten vastleggen & reflecteren op het proces, afsluiten met een drankje
Leerdoel
Hoe
Draagbare objecten ontwerpen in 3D
Prototyping met verschillende beschikbare materialen en 3D-technieken
Arduino IDE crashcursus - walkthrough voor beginners
Basisbeginselen van elektronica
‘Schetsen met hardware’: prototypen van elektronica en leren door te doen, verschillende inputs/outputs uitproberen of er eentje uitkiezen om diep in te duiken
Einde dag 1 doelen:
Een duidelijk idee voor een wearable
Onderdelen van de wearable zonder elektronica, vormtesten en prototypes
Werkende geprogrammeerde elektronica (hoeft nog niet draadloos, gesoldeerd of definitief te zijn, gewoon een eerste werkende iteratie)
Einde dag 2 doelen:
Werkende elektronica, gesoldeerd en op batterijen
Elektronica en design komen samen in een draagbaar kunstwerk
Er zijn een paar ingrediënten om een succesvolle wearable te maken, en ze werken allemaal samen. Er is geen vaste plek om te beginnen - sommige mensen werken beter met een doordacht concept, anderen werken beter als ze beginnen met maken.
Wat is je inspiratie? Wat is het concept, wat wil je zeggen met je draagbare kunstwerk?
Waar en hoe draag je het? Kies een lichaamsdeel - maak je iets voor op je hoofd? Om je arm? Op je hand? Hoe kun je het draagbaar maken voor dat lichaamsdeel?
Dit kan onderweg veranderen! Door je draagbare ding uit te proberen terwijl je het op verschillende lichaamsdelen maakt, kan het in verschillende richtingen gaan.
Kies je input/output - beweegt het, geeft het licht af of maakt het geluid? Is er interactie: reageert het op geluid of het dimmen van licht? Kies je elektronica op basis daarvan. Je kunt verschillende opties uitproberen en kijken wat je leuk vindt
Het prototypen van je elektronica op een breadboard is het makkelijkst
Kies je materialen - waar is het van gemaakt? Is het hard of zacht? Hoe bevestig je het aan het lichaam? Prototype in 3D!
Maak iets draagbaars vanaf nul - d.w.z. met patronen, elastiek, bandjes, klittenband, enz.
Bouw voort op iets bestaands - d.w.z. op een handschoen of hoofdband
Er zijn verschillende manieren om iets draagbaar te maken. Je kunt allerlei soorten clips, haarbanden, handschoenen, klittenband, bandjes gebruiken… Hieronder vind je enkele van de beschikbare opties.
Gereedschappen, technieken, machines en materialen
Om je eigen wearable te maken, kun je verschillende technieken gebruiken - van snelle kartonnen prototypes met lijm tot naai- en sieradenmaaktechnieken. Hieronder vind je enkele voorbeelden van materialen en technieken om 2D- en 3D-vormen te maken om je wearable vorm te geven!
Driedimensionale vormen maken met
Metaaldraad
Stof, kleurfiltervellen
Naaimachine zigzag
Stel de naaimachine in op zigzag en begin voorzichtig met naaien:
Je kunt ook direct op een kledingstuk werken! Je zou bijvoorbeeld een e-textiel druk- of aanraaksensor kunnen maken.
Andere prototypingmaterialen en -technieken om te verkennen:
Luchtdrogende boetseerklei: kleimodelleertechnieken en -gereedschap
Metaaldraad: technieken voor het maken van sieraden, solderen
Stof en draad: naaien, textieltechnieken
Geleidende stof: solderen
Elektronische componenten in klei inbedden
LED’s op stof borduren
Lijmen
Elektronica integreren in wearables
Hoe ga je van een rommelig breadboard en losse elementen naar elektronica die je kunt dragen? Als je iets groots maakt, heb je vaak wat ruimte om je elektronica onder iets te verbergen. Als het echter klein is, heb je andere oplossingen nodig. Het draait niet altijd om hoe je je circuit onzichtbaar maakt, maar eerder om hoe je je microcontroller en batterij ten opzichte van je invoer en uitvoer kunt plaatsen, op een manier die er natuurlijk of opzettelijk uitziet. Als je het niet kunt verbergen, kun je het altijd onderdeel van de look maken! Als je bijvoorbeeld een oorbel met een motor wilt maken, waarom maak je dan niet een andere oorbel waarin je je batterij en microcontroller kunt doen? Of je kunt een microcontrollerketting maken die je onder je shirt kunt dragen, of eroverheen als je het er mooi uit wilt laten zien! Als je iets maakt om op je hoofd te dragen, kun je je microcontroller en batterij misschien onder een paardenstaart verstoppen, of je kunt de microcontroller en batterij op een clip bevestigen die je aan de achterkant van je shirt vastmaakt.
En vergeet niet: we zijn aan het prototypen, dus het is ook oké als het niet meteen de meest efficiënte, optimale, definitieve vorm is van je draagbare dromen. Je moet ergens beginnen!
Je draagbare kunst heeft 3 ingrediënten:
Elektronica op batterijen
Iets dat het draagbaar maakt
Een interessante input/output/interactie die tot leven komt met elektronica en je creaties
Hier zie je deze elementen uitgelegd: er is een microcontroller die wordt aangestuurd door een oplaadbare LiPO-batterij, er is een hoofdband om hem op je hoofd te dragen en er is een oogantenne bevestigd aan de servomotor die voor je kan zweven als een diepzeevis. Met deze ingrediënten kun je de microcontroller en de batterij aan een haarclip lijmen en deze in een knot of onder je haar verstoppen, of je kunt de draden langer maken en deze wat verder weg verstoppen.
Slingerende strik
Een ander voorbeeld om iets draagbaar te maken, is om een ketting te maken met een zakje zoals hier.
De microcontroller en de batterij passen in het zakje en passen bij de bewegende strik. Dit is een voorbeeld van het verbergen van de elektronica in het zicht door ze te laten passen bij de wearable.
Schommelende ring
Als je de beweging liever op je hand wilt, kun je de motor aan een handschoen bevestigen of in dit geval een metalen draad buigen om een ring te maken.
Hier zie je het in actie:
De elektronica zit gewoon verstopt in mijn mouw. Ik draag ze op mijn huid door stukjes klittenband op mijn arm en op de batterij en microcontroller te plakken, zodat ze er gemakkelijk af kunnen als dat nodig is, maar ze nog steeds behoorlijk stevig zijn. Dit is handig voor prototypen. Ze kunnen ook met klittenband aan een armband of mouw worden bevestigd.
Interactieve sjaal
In dit volgende voorbeeld (met behulp van het Arduino-voorbeeld LDR_NeoPixel_amount) kan de elektronica worden verborgen in het draagbare object (een sjaal) zelf.
De lichten (Neopixels) moeten aan de binnenkant worden geplaatst, maar de LDR moet aan de buitenkant zitten zodat deze veranderingen in de verlichting kan detecteren.
Interactieprototyping
Hier zie je het in actie. Zodra je een eerste prototype hebt, kun je beginnen met het prototypen van de interactie die je wilt. Er zijn talloze manieren om de hoeveelheid licht op een LDR te beïnvloeden: door hem met je hand te bedekken, door een donkerdere ruimte in te lopen, door er iets op te leggen. Er zijn veel dingen om uit te proberen!
Hier is een subtiele beweging van de nek al voldoende om de Neopixels aan te doen.
Toetsenbordhandschoen
Dit is een voorbeeld van een heel eenvoudig capacitief aanraaktoetsenbord dat je kunt dragen. Het is gemaakt met geleidende tape op een bestaande handschoen.
De code is in principe hetzelfde als het touch_keyboard_speaker.ino-voorbeeld, maar met 5 in plaats van 6 aanraaksensoren. Zorg ervoor dat je bij het wijzigen van het aantal aanraaksensoren alle arrays wijzigt door waarden toe te voegen of te verwijderen op basis van het aantal dat je hebt (ik heb een half uur verspild om erachter te komen waarom het raar deed hierdoor).
Een volgende stap zou zijn om de elektronica te integreren en draden aan de geleidende tape te solderen in plaats van krokodillenklemmen te gebruiken. Een andere leuke iteratie zou zijn om een MP3-module met aangepaste geluiden toe te voegen, om verder te gaan dan de piepgeluiden van de toonfunctie.
Meer voorbeelden en inspiratie
Borduurwerk, elektronica in soft circuits embedden
Second Skins Re-FREAM door Malou Beemer toont de integratie van LED’s in kledingstukken, waarbij textiel wordt gebruikt om het licht te diffusen. Het toont ook elektronische traces die met een naaimachine zijn genaaid op de projectpagina.
Hardware & software
Je kunt al elektronische wearables maken zonder microcontroller. Je kunt bijvoorbeeld een knoopcelbatterij (en optionele knoopcelbatterijhouder met aan/uit-schakelaar) en een LED of LED-filament gebruiken en iets maken dat licht uitzendt. Je kunt het zelfs interactief maken door een LDR (lichtafhankelijke weerstand) aan de mix toe te voegen. Maar zodra je een microcontroller en programmering gebruikt, is de sky the limit!
Kit
Jullie hebben allemaal een kit ontvangen met de volgende inhoud:
Seeed Studio XIAO ESP32S3-ontwikkelbord + 2 sets header-pinnen + Bluetooth-antenne
Grove Shield voor XIAO
Breadboard
Jumperdraden (mannelijk/mannelijk en mannelijk/vrouwelijk)
Lithium-ionbatterij (3,7 V 600 mAh)
USB-C naar USB-C of USB-A-kabel
LED
LDR
2 weerstanden: 67 Ohm en 4,7 kOhm
Microservomotor
Piëzo-zoemer
Controleer of de inhoud van je kit overeenkomt met de onderstaande afbeelding (ongeveer):
Solderen
Hier is een soldeerstripbewerking van Andie Nordgren die je de basis laat zien van solderen:
En hier nog een handige referentie:
We gaan dit in de praktijk brengen met de header-pinnen van het XIAO-bord, zodat we eenvoudig elektronische circuitjes kunnen prototypen:
Zorg ervoor dat je verbindingen sterk zijn wanneer je draden soldeert.
Je kunt een flexibele LDR-spanningsdeler maken zoals deze:
De Arduino IDE instellen
In deze voorbeelden gebruiken we een Seeed Studio XIAO ESP32S3. Hun wiki is een geweldige plek om te beginnen en kennis te maken met alle mogelijkheden die dit kleine ontwikkelbord te bieden heeft. Maar eerst moeten we een aantal drivers installeren. Voor zowel Mac als Windows kun je ze hier krijgen (CP210x VCP Mac OSX Driver of CP210x Windows Drivers). Voor Mac kun je ook gewoon de onderstaande stappen volgen en dan voor het eerst iets uploaden naar je ESP32; er zou op een gegeven moment een prompt moeten zijn om wat drivers te installeren.
Voor een snelle start, volg deze stappen in de Arduino IDE (ervan uitgaande dat je het al hebt geïnstalleerd; als dat niet zo is, download dan de nieuwste stabiele versie en start deze):
Navigeer nu naar Extra > Board > Boards Manager..., typ het trefwoord “esp32” in het zoekvak, selecteer 2.0.17 (de nieuwste versie, 3.x.x, werkt niet met de ESP32Servo-bibliotheek) en installeer deze.
Sluit je board aan en selecteer het board en de poort in het dropdownmenu linksboven in de interface. Klik op ‘Selecteer ander board en poort’ en zoek naar de XIAO_ESP32S3.
Dat zou het moeten zijn! Nu kun je beginnen met het uploaden van de voorbeeldcode of je eigen code schrijven. Houd er rekening mee dat ESP32’s soms in de verkeerde modus staan om te programmeren. Je kunt terug naar de opstartmodus door het board los te koppelen, de opstartknop (B, van boot) op het board ingedrukt te houden en het board vervolgens weer aan te sluiten. Nu zou het weer moeten werken :-)
Basis setup
Om wearables te prototypen, gaan we het Grove Shield voor XIAO gebruiken, wat het prototypen makkelijker maakt. Je kunt zelfs je LiPO-batterij opladen met de XIAO terwijl deze op het shield zit, dus je hebt er geen aparte oplader voor nodig. Het is plug and play en je kunt het kleinere deel van de basis afklikken als je het niet nodig hebt. Het is makkelijk af te breken (maar let op, want daarna kun je ‘m niet meer terugplakken):
Je kunt het shield altijd weglaten als het te groot is voor je uiteindelijke wearable, zodra je weet hoe je alles wilt aansluiten; er is ook protoboard om alles op te solderen als je wil.
Om te beginnen gebruiken we het shield als een prototypingbord samen met een breadboard. Je kunt Grove kabels in de sockets steken om de datapinnen met je inputs en outputs te verbinden, je kunt draden solderen aan de GPIO-gaten of je kunt sockets solderen in de GPIO-gaten (zoals hieronder) om jumperdraden in te pluggen voor plug & play!
Je kunt ook gewoon het mini breadboard gebruiken om te beginnen met prototypen en het shield bewaren voor later.
Batterijgebruik
Let goed op wanneer je de batterij aansluit: verbind + met + en - met min!
De batterij is ongeveer even groot als het shield, dus je kunt hem zo vouwen en met klittenband of dubbelzijdig plakband aan elkaar plakken. Ik zou geen lijm gebruiken, omdat ik niet zeker weet hoe het zou reageren met de batterij en de verbindingen op het shield.
Ik zou de onderkant van het bord met plakband bedekken om kortsluiting te voorkomen, bijvoorbeeld als je een metalen clip aan de basis wilt lijmen om hem draagbaar te maken.
Weerstanden
Voor de led’s gebruiken we een 67 Ohm stroombegrenzende weerstand. De waarden voor de weerstand in serie met een led zijn afhankelijk van een aantal factoren (kleur, voedingsspanning, stroomsterkte); 67 Ohm is gebaseerd op een voedingsspanning van 3,3 V, een gemiddelde spanningsval van 2 V en een stroomsterkte van de LED van 20 mA. Er zijn hier online rekenmachines voor :-) Als je een grotere weerstand gebruikt, zal het (tot op zekere hoogte) nog steeds werken, maar de LED zal iets minder fel schijnen. Als je een kleinere weerstand gebruikt, kan de LED iets feller schijnen, maar kan deze op de lange termijn ook kapot gaan.
Voor de LDR zit er een 4.7k Ohm weerstand in je kit. Deze waarde heb ik uitgekozen omdat die goed werkt met de LDRs omdat ze een vergelijkbare range hebben. Als je zelf LDRs koopt, hebben ze misschien andere minimale en maximale waardes, dus probeer het uit of kijk in de datasheet.
Arduino-code en -circuits
Voorbeeldcode is te vinden in de map Arduino (code). Je vindt voorbeelden van geprogrammeerde en externe, digitale, analoge en touch input, gecombineerd met licht-, bewegings- of geluidsoutput. Hieronder vind je hoe je de circuits op een breadboard moet aansluiten. Dit wordt ook beschreven in de Arduino-codebestanden. De link naar de bestanden staat in het zijmenu.
Geprogrammeerde input
Een LED laten knipperen (licht als output, digitalWrite)
Een LED laten dimmen (analogWrite, PWM)
Sluit je circuit op het breadboard zo aan:
Hier is een video van wat de output zou moeten zijn.
Als je de LED aansluit op een ESP32S3 op een Grove shield, is het resultaat hetzelfde:
Digitale ingang
Een LED aanzetten met een drukknop (digitalRead, met interne pullup-weerstand)
Sluit je circuit aan zoals hieronder.
Analoge ingang
LDR-sensorwaarden lezen (seriële monitor)
LDR-sensorwaarden gebruiken om LED te dimmen (input toewijzen aan output)
LDR-sensorwaarden gebruiken om Neopixels te laten oplichten (gebruik van libraries)
Voor de LDR- en LED-voorbeelden maak je je circuit in zoals hieronder.
Hier zie je de interactie:
En voor de Neopixel-strip, sluit je deze als volgt aan:
Ook een voorbeeld wanneer de ESP32S3 op het Grove shield zit:
Een servo met LDR-ingang (beweging als output) bewegen
Sluit als volgt aan:
Als wearable is dit is wat je kunt doen met een servomotor en een LDR!
Als je het circuit met een LDR hebt gemaakt, is het nog maar één stap verder om je eigen, zelfgemaakte sensor aan te sluiten! Haal de LDR eruit en steek twee jumperdraden met krokodillenklemuitgang waar de poten van de LDR zaten. Zo vervang je de ene variabele weerstand door de ander.
Touch input
Een LED aanzetten met touch (touchRead, input gebruiken om iets met output te doen, while statement)
Een LED aanzetten met touch (if/else statement)
Een LED dimmen met aanraking (touchRead, capaciteitsbereiken in kaart brengen)
Een capaciteitsbereik mappen naar tonen op een luidspreker (geluid als output, tone functie)
Aanraakpinnen gebruiken om een toetsenbord te maken (meerdere pinnen, arrays)
Voor de voorbeelden van aanraking en LED, sluit je het breadboard aan zoals hieronder. De krokodillenklem kan ook een mannelijke/mannelijke jumperdraad zijn, zolang er iets is dat je kunt aanraken.
Hier wordt een jumperdraad gebruikt; wanneer je het uiteinde van de draad aanraakt, licht de LED op.
De touch- en speakervoorbeelden kunnen worden aangesloten zoals hieronder; in dit voorbeeld is het met een buzzer, maar het werkt ook met een piëzo buzzer zoals in de kit!
Het voorbeeld van het touch klinkt als volgt:
Je kunt ook iets geleidends aansluiten, zoals een geleidende, gepunnikte sensor. Nu is de interactie veel interessanter!
En als je meer aanraaksensoren wilt, sluit je gewoon meer draden aan op de aanraakpinnen die je wilt gebruiken en pas je de code erop aan. Ik heb de speaker nu naar de andere kant verplaatst, zodat alle aanraakingangen aan één kant zitten.
