Building Block: Iron Man
2021-09-23
Lucas van der Vegt
Voor dit block toon je aan dat je een fysiek interactief object kan bouwen en programmeren met een Microcontroller.
lucasvdvegt/portfolio/buildingblocks/bb-ironman
Index
1. Hardware Programmeren
Je kan een microcontroller programmeren, zodanig dat hiermee een interactief project aangestuurd kan worden. De microcontroller kan inputs inlezen en outputs aansturen. Het project heeft geen beeldscherm nodig om te functioneren.
- [x] je kan een microcontroller programmeren
- [x] interactief
- [x] inputs
- [x] outputs
- [x] geen beeldscherm
1.1 Input Sonar Sensor
/clSonar.h
clSonar.h
Ik heb de inputs gemaakt met gebruik van classes. Ik werk met arduino dus de code is geschreven in C++, hieren kan je object georiënteerd programmeren. Dit zorgt ervoor dat ik mezelf minder hoef te herhalen en de structuur van de code duidelijker is. Ook heeft dit als voordeel dat dingen parallel aan elkaar kunnen lopen.
De class begint met een private gedeelte waarin alle variabelen worden geïnitieerd. Twee keer een int
waar de fysieke pin nummers in worden gezet. Een int
is een numerieke variabele met hele getallen. Vervolgens worden er 4 float
's geïnitieerd de gebruikt worden om later dingen te berekeken.
class clSonar {
private:
int trigPin;
int echoPin;
float duration;
float distance;
float lastVal;
float diff = 1;
⋮
Vervolgens is er in de public section als eerste een constructor. In deze constructor worden de meegegeven trigPin
en echoPin
waardes aan de bijbehorende variabelen gegeven. Als laatst word de init()
function aangeroepen.
⋮
public:
clSonar(int trigPin, int echoPin) {
this->trigPin = trigPin;
this->echoPin = echoPin;
init();
}
⋮
In de init()
function worden alle initialisaties gedaan. In dit geval houd dat in, dat de pins ingesteld worden op de correcte standen. En vervolgens word voor de eerste keer het update()
function uitgevoerd.
⋮
void init() {
pinMode(trigPin, OUTPUT);
pinMode(echoPin, INPUT);
update();
}
⋮
De update()
function zorgt ervoor dat de sonar sensor een waarde meet en het distance
variabele update met de nieuwst gemeten versie. De sonar sensor stuurt een pulse door een HIGH
voltage te geven aan de trigPin
en dan de tijd van aankomst bij de echoPin
met elkaar te vergelijken.
⋮
void update() {
digitalWrite(trigPin, LOW);
delayMicroseconds(2);
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);
duration = pulseIn(echoPin, HIGH);
distance = (duration*.0343)/2;
}
⋮
Vervolgens kan je van buitenaf het getValue()
function uitvoeren die alle stappen uitvoert en de distance in centimeters terug geeft.
⋮
int getValue() {
update();
return(distance);
}
};
main.ino
Als eerste word de clSonar
class ingeladen met een include in het hoofdbestand.
#include "clSonar.h"
⋮
Vervolgens worden de fysieke pin nummers gelinkt aan een constante waarde in de code.
⋮
#define TRIGPIN_1 2
#define ECHOPIN_1 3
⋮
Hier word de sonar class aangemaakt en worden er de juiste waardes aan meegegeven door middel van de constantes.
⋮
clSonar sonar1(TRIGPIN_1, ECHOPIN_1);
⋮
In de setup van het hoofdbestand hoeft niks extras geïnitialiseerd te worden, omdat dit al in de class word geregeld.
⋮
void setup() {
}
⋮
En nu kan je de functions in de class die bij de sonar sensor hoort gebruiken. In dit geval heb ik de function getValue()
als voorbeeld. Wanneer je deze function uitvoerd returned die de afstand in centimeters.
⋮
void loop() {
sonar1.getValue();
⋮
}
⋮
1.2 Midi output
arduino-midicontroller/midimessage
De grote challenge was een MIDI verbinding tussen arduino en computer over de USB tot stand brengen.
Na wat onderzoek kwam ik tot een soort pseudo lijst van stappen die er voor nodig waren.
- In arduino een code schrijven die de input detecteert en informatie doorgeeft aan een MIDI function.
- De MIDI function stuurt vervolgens vanuit 3 gegevens een byte door naar de serial output.
- Een programma om de serial arduino verbinding om te zetten via bytes naar een midi signaal.
- Een programma die het midi signaal naar een digitaal midi device stuurt.
- Een DAW zoals FL-Studio om naar het midi device verbinden en het gebruiken als inputs voor synths.
- Hierbij gebruik je ook nog een programma om de ruwe data van de midisignalen te controleren.
Midimessage Function
Vanuit de input kan de MIDImessage()
function aangeroepen worden die het midi message sturen afhandeld.
void MIDImessage(uint8_t status, uint8_t data1, uint8_t data2) {
Serial.write(status);
Serial.write(data1);
Serial.write(data2);
}
De MIDImessage()
function die wordt aangeroepen, handelt het versturen van de MIDI bytes af. Als input komen er 3 getallen binnen: status
, data1
en data2
. Bij eerste getal status
wordt bepaald wat de soort input is en op welk channel dit is. Het tweede getal data1
in de MIDI message geeft aan de welke controller in de lijst het is. En als laatste wordt de waarde doorgegeven in het data2
byte.
Dit wordt als byte
verstuurd naar de serial connectie over de 115200
port.
Ik haal de status bytes
uit deze lijst:
Midi Messages
Serial byte naar MIDI signaal naar digitaal device
Deze serial bytes worden door een programma genaamd "Hairless MIDI" omgezet naar een midi signaal.
Vervolgens wordt dit midi signaal verstuurd naar een digitaal midi device.
Digital Audio Workstation
In een DAW kan dit geïnterpreteerd worden als input voor verschillende onderdelen. In dit geval gebruik ik FL-Studio met een plugin die een synthesizer simuleert.
Demo:
1.3 Interactie
arduino-midicontroller/main.ino
Nu wil je de input en output aan elkaar linken door classes en functions samen te gebruiken.
main.ino
Als eerst worden alle classes ingeladen in het begin van de file.
#include "clSonar.h"
#include "clPotentiometer.h"
#include "fnMIDImessage.h"
⋮
Vervolgens worden alle fysieke inputs gelinkt aan een constante die later gebruikt kunnen worden.
⋮
#define TRIGPIN_1 2
#define ECHOPIN_1 3
#define TRIGPIN_2 4
#define ECHOPIN_2 5
#define POTPIN_1 14
#define POTPIN_2 15
⋮
Daarna worden de verschillende classes aangemaakt en geïnitialiseerd.
⋮
clSonar sonar1(TRIGPIN_1, ECHOPIN_1, 0);
clSonar sonar2(TRIGPIN_2, ECHOPIN_2, 1);
clPotentiometer pot1(POTPIN_1, 0);
clPotentiometer pot2(POTPIN_2, 0);
⋮
In de setup function word de serial reading aangezet op een bepaalde poort. (Deze function word door de arduino microcontroller herkent.)
⋮
void setup() {
Serial.begin(115200);
}
⋮
In de loop worden de updateMidi()
functions van de classes aangeroepen. Deze functions werken als een soort controllers.
⋮
void loop() {
sonar1.updateMidi();
sonar2.updateMidi();
pot1.updateMidi();
pot2.updateMidi();
}
⋮
Over de sonar sensor class heb ik het al eerder gehad, bij die class voegen we nog de updateMidi()
function aan toe. Die zit als volgt in elkaar.
/clSonar.h
class clSonar {
⋮
void updateMidi() {
Als eerste word de lokale function getValue()
aangeroepen om de laatste waarde van de sonar sensor te verkrijgen.
⋮
getValue();
⋮
Vervolgens word de nieuwe waarde vergeleken met de vorige waarde en runt alleen de rest van de code wanneer het een genoeg aantal verschil heeft. Dit doe je zodat de midicontroller niet overloaded word aan updates.
⋮
int valDiff = distance - lastVal;
if (abs(valDiff) > diff && distance < 30) {
⋮
Die values worden gemapt naar de correcte values voor een midimessage.
⋮
int distanceMap = map(distance, 0, 50, 0, 127);
⋮
En vervolgens word met de MIDImessage()
function het de correcte gegevens over midi gestuurd.
⋮
MIDImessage(177, midiControllerChannel, distanceMap);
⋮
Als laatste word de lastVal
geupdate naar de laatst gebruikte distance value voor de volgende loop.
⋮
lastVal = distance;
}
}
⋮
};
arduino-midicontroller/potentiometer
/clPotentiometer.h
Voor de potentiometer word er een vergelijkbare chain aan commands uitgevoerd.
class clPotentiometer {
⋮
int updateMidi(){
int potValDiff = potVal - lastVal;
if (abs(potValDiff) > diff) {
MIDImessage(177, midiControllerChannel, map(potVal, 0, 1023, 0, 127));
lastVal = potVal;
}
}
⋮
};
2. Externe electronica aansluiten
Je kan externe electronica aansluiten op de microcontroller zodanig dat dit extra functionaliteit toevoegt. Er is een externe input (bijv. sensoren, knoppen) en een externe output (bijv. lampjes, servo).
- [x] electronica algemeen
- [x] electronica inputs
- [x] electronica outputs
2.1 Input: Potentiometer
Een potentiometer is een knop die zorgt voor een variabele weerstand. De hoeveelheid weerstand kan gemeten worden in het arduino board met een analoge waarde.
De aansluiting van de draden werkt als volgt:
De meest rechter pin zorgt voor de 5v stroom. De linkerste pin sluit je aan op de ground input. Vervolgens kan je de middelste pin aansluiten op een analoge input van de arduino. Je krijgt in de arduino een waarde tussen 0
en 1023
.
2.2 Input: Sonar Sensor
Een ultrasonic sensor werkt door middel van een geluidsgolf 1 richting op te sturen, deze vervolgens weer op te vangen en de tijd er tussen te meten. Hiermee kan je de afstand tussen sensor en een object te berekenen.
Je sluit de sonar sensor als volgt aan:
De meest linker pin is voor de 5 volt stroom input pin. De rechter pin is voor de verbinding naar de ground. Vervolgens sluit je de trig
en output
connecties aan de bijbehorende digitale pins op het arduino board.
2.3 Output: Matrix Screen
Bij het matrix scherm zit de MAX7219
module die werkt als een interface tussen de arduino en het matrix scherm in. Hierdoor is het makkelijker om het schermpje te besturen zonder een boel preprocessing.(dit zorgt er ook voor dat het programma sneller loopt). Daardoor kan je in de arduino code gebruik maken van een coördinaten matrix.
De bedrading gaat als volgt:
Er zijn in totaal 5 mogelijke aansluitingen, 2 hiervan zijn voor stroom en de andere 3 voor het aansturen van het schermpje. De VCC
moet aan een power source verbonden worden en de GND
word aan een ground pin verbonden. Vervolgens moet je de drie controller outputs linken aan de bijbehorende digitale PWM
pins op het arduino board.
2.4 Output: Servo
Er zijn twee verschillende soorten servos, en positional. Een continuous servo kan, zoals de naam al zegt, achter elkaar door blijven draaien; dit is een soort wiel. De andere soort is een positional servo die ik in dit voorbeeld heb gebruikt. Met deze soort kan je vaak maar maximaal 360 tot 180 graden heen en weer draaien. De positional servo heeft wel als voordeel dat die vaak sterker en preciezer is.
De aansluiting werkt als volgt:
Een servo heeft 3 connecties, 2 power aansluitingen en de control connectie. De (vaak donkergekleurde) meest linker draadje is de ground en moet verbonden aan de ground pin op het arduino board. De middelste moet aangesloten worden aan een powersource. Vervolgens moet je de (vaak lichtgekleurde) rechter connectie verbinden aan de bijbehorende PWM
pin op het arduino board.
2.5 Samenkomst / Overzicht
Als laatste kan je al deze inputs en outputs samen aansluiten op een grotere arduino om zo een samenhangend geheeld te krijgen. Dit doe je door alle individuele stappen te combineren en de correcte pins aan te duiden in de code.
3. Bruikbaar product
In mijn eindproduct komt het programmeren en aansluiten van electronica samen in één eindproduct. Je hebt een solide behuizing voor dit eindproduct ontworpen waarbij bedrading en gevoelige electronica verborgen zijn, zodanig dat het product bruikbaar is voor een eindgebruiker zonder dat het meteen kapot gaat. Je kan verantwoorden welke keuzes ik heb gemaakt in de vormgeving van het product en waarom deze aansluiten bij de doelgroep.
- [x] solide behuizing
- [x] verborgen electronica
- [x] keuzes in de vormgeving, doelgroep
3.1 Casing
Voor de casing ga ik de 2d lasercutter gebruiken met het 3mm hout. Als eerste meet ik op hoe groot het object in grote lijnen moet worden. Met deze informatie kan er vervolgens op de website mnakercase een casing worden ontworpen. Ik wil een soort synth met een makkelijk te bedienen interface aan voorkant. Daarom heb ik gekozen voor een box met een schuine kant aan de voorkant. Daarna importeer je het .ai
bestand in Adobe Illustrator en kan je daar alle details in toevoegen.
Eerst moeten de gecreëerde lijnen door het programma omgezet worden naar de correcte afmetingen. Om te snijden moet je rode (#FF0000) lijnen gebruiken met een stroke dikte van 0.0283
zonder fill. Voor de engraving moet je de kleur zwart gebruiken (#FFFFFF). De dikte ervan kan je veranderen door de opacity van de zwarte kleur aan te passen.
Er moeten 6 plekken voor sonar sensors komen, 3 plekken voor potentiometers en 1 ruimte voor het matrix scherm. Daarnaast wil ik ook nog wat branding erop gooien om het product wat aantrekkelijker te maken.
De gaatjes voor de sonarsensors heb ik door middel van een online dimensions schematic van de HC-SR04
. Door de afmetingen na te maken in adobe illustrator en zes keer te kopieren heb ik nu de benodigde gaatjes voor de sonar sensors.
Daarna heb ik de grootte van het draaigedeelte van de potentiometers opgemeten en hiervan drie rondjes naast elkaar geplaatst. Vervolgens heb ik het matrix scherm opgemeten en de bijbehorende vierkant in het design verwerkt.
De laatste stap is om de opmaak aan de casing toe te voegen. Ik heb ervoor gekozen om een paar keer het woord floatsynth
op de casing te zetten, dat is de branding name van mijn product. Daarnaast heb ik een keer mijn eigen naam en de naam van het zelfbedachte bedrijf erop gezet.
Vervolgens kan je dit ontwerp uitprinten in de lasercutter, op een 600 x 300 mm stuk plywood.
Als laatste stap moet je de stukken hout eruit klikken en kan je de casing in elkaar zetten. Nu kan je alle hardware erin verwerken en de kabels op de goede manier aansluiten.
Voor de wiring is aan de binnenkant genoeg ruimte overgelaten, dus je ziet daar niks van. Ook zit er een gat aan de achterkant om mogelijk de usb kabel doorheen te doen. De achterkant kan je niet vastlijmen zodat je nog eventuele aanpassingen kan doen aan de wiring.
3.2 Doelgroep
Als project moesten we een product ontwerpen voor een museum, in dit geval heb ik het museumpark gekozen. Mijn product was bedoelt als kunstobject die gebruikt kon worden door de mensen die door het park heen lopen. Ook is het bedoeld voor de mensen die van het Erasmus ziekenhuis komen, hier komen soms mensen vandaan die fysiek en/of mentaal beperkt zijn en moeilijk een normaal instrument kunnen spelen. doelgroep.
Floatsynth
Het muziek instrument voor iedereen.
Veel mensen hebben nooit geleerd hoe je een instrument moet bespelen en voor sommige mensen is het fysiek onmogelijk om instrumenten te kunnen spelen.
De Floatsynth is een muzikaal instrument die gespeeld kan worden door iedereen. Het heeft touch-less controls die gebruik maken van sonar technologie. Deze controllers sturen hun waardes naar de synthesizer die vervolgen geluid produceert. De synth software is zo geprepareert dat iedereen tenminste iets van een musicaal geloud kan produceren.
De verschillende features zitten verdeeld over het device, zo ontstaat er een soort radius van interactieviteit. Qua vormgeving heb ik het simpel gehouden met alleen maar een logo. Om het interresanter te maken zou ik vormpjes bij / om de interactieve delen kunnen plaatsten om meer aandacht te wekken, ook zou ik het een andere kleur kunnen geven.