Steek Lezend Zwaard (heb Je Je Punt Gemaakt?)

Sinds dat ik begonnen ben met langzwaard vechten binnen de HEMA bond in 2023, ben ik tegen het probleem opgelopen dat wanneer ik iemand op de borst steek dit niet wordt gezien door de juryleden. Vaak zitten er ledematen tussen het zwaard en hun gezichtsveld of het gebeurd zo snel dat het niet wordt opgemerkt. Dat is heel erg frustrerend omdat je daar de meeste punten voor kunt krijgen. Daarom ben ik voor dit project bezig gegaan met een zwaard die dit voor jou registreert door middel van een arduino en meerdere sensoren!

De handleiding van het daadwerkelijk bouwen van dit project vind je vanaf stap 9.

Elektronische componenten

• Arduino uno
• Draadbruggen set
• 30 AWG Flexibel koperdraad zwart
• 1x 330 Ohm-weerstand
• 1x piezo buzzer
• 1 x LDR lichtgevoelige weerstand
• Acceleratie versnellingsmeter en gyroscoop I2C -MPU- 6050
• Prototyping board (PCB)
• 9V Batterij clip met 5.5mm jack
• 9 Volt batterij

Materialen behuizing

• 1x MDF plank 4 mm 60x80 cm
• 1x lange stok 1,3 m 2,5 cm diameter
• Katoen touw 2 mm dik
• Benson PVC isolatie tape
• Houtlijm
• Leer 10x10 cm

Gereedschappen

• Lasersnijder
• Schuurpapier korrel 180
• Soldeerbout met soldeer (+soldeertin)
• Naald en draad

Dit is de eerste keer dat ik met arduino heb gewerkt, toen we aankwamen bij het concept fase voelde ik me nog erg onzeker over het verloop van dit project. Daarom heb ik mijn eerste ideeën zo dicht mogelijk bij mijzelf gehouden om zo plezier te krijgen in het ontwerpen. Het eerste idee wat in mij opkwam was een vrij gevaarlijk idee. Namelijk: Wat nou als ik een vlammen werper aan een zwaard vastbind dat zodra die begint te bewegen opeens een vuurzwaard zou worden. Maar met oog op de veiligheid heb ik van dit idee afgezien. Mijn 2e idee was gebaseerd op mijn laatste Nederlands kampioenschap zwaardvechten. Hier had ik een aantal van de gevechten makkelijk kunnen winnen als mijn rake steken meegeteld waren in de score. Het 2e idee sprak mij hier het meest aan omdat dit gebaseerd is op een sport die ik liefheb en ook haalbaar is om te maken terwijl ik mijzelf nog wel flink uitdaag.

Iteratie 1

Omdat ik nog zo weinig ervaring heb met arduino heb ik eerst een hele simpele test gemaakt. Om 3 lampjes achter elkaar aan te laten gaan. Dit heb ik gedaan om wat bekender met volgordes te worden en waar welke bedrading naar toe zou moeten. Het eerste kwartier dat ik dit probeerde wilde het 2e lampje maar niet aan. Door elk draadje bij langs te gaan nadat ik mijn code had afgespeurd kwam ik erachter dat ik een pinnetje een gaatje opzij moest zetten.

Iteratie 2

Voor mijn 2e iteratie ben ik aan de slag gegaan met een licht gevoelig weerstand. Hier heb ik een code voor geschreven die in eerste instantie een lampje aan laat gaan. In principe is dat een hele simpele versie van wat ik uiteindelijk wil gaan maken. Dit heb ik eerst gemaakt met een lampje en toen dat werkte heb ik het lampje verwisselt met een buzzer. Die keuze heb ik gemaakt omdat ik erachter kwam dat je tijdens een gevecht het lampje erg moeilijk op valt. Maar na een kleine test tijdens het sporten kwam ik erachter dat een buzzer een hard genoeg geluid maakt om op te vallen.

Iteratie 3

Mijn volgende test was of ik dit ook met 2 licht weerstanden kon doen. Zoals op de laatste foto te zien zitten de 2 weerstanden achter elkaar en moeten ze beide geactiveerd zijn om de buzzer af te laten gaan.

Door de laatste iteratie en een gesprek met mijn trainer op de club kwam ik op een toevoeging voor mijn project. Voordat een slag of steek punten krijgt moet er genoeg intentie achter de aanval zitten. Per ongelukke aanrakingen met het wapen worden niet geteld met het oog op de historie van onze sport en op het feit dat lichte aanrakingen bija niet verwonden.

Om deze reden heb ik besloten om een acceleratie sensor in dit project te bouwen. Door eerst de beweging en snelheid van het zwaard te meten voorkom je dat de steek doorgegeven wordt als raak zonder dat er genoeg intentie aanwezig is. Dit betekent dat ik voor mijn volgende prototype ga proberen hoe ik eerst de ene weerstand moet activeren voordat hij de 2e weerstand mag aflezen.

In deze iteratie heb ik gewerkt aan mijn nieuwe gate keeper systeem.

Deze werkt als volgt:

-Weerstand 1 (input1) _______________Weerstand 2 (input2) _______Output (lampje)

------HIGH -------------------------------------------HIGH ----------------------------------HIGH(aan)

------LOW --------------------------------------------HIGH ------------------------------------------LOW

------HIGH --------------------------------------------LOW ------------------------------------------LOW

------LOW ---------------------------------------------LOW ------------------------------------------LOW

Dit schema visualiseert wat er moet gebeuren voordat de buzzer (in dit geval het lampje om de oren te besparen in de test fase) aan mag gaan. Beide weerstanden moeten geactiveerd zijn voordat deze aan mag. Elke andere combinatie wordt niet geaccepteerd.

Als het ware functioneren de weerstanden als poortwachters (gate keepers). De eerste weerstand is poortwachter 1 waar de waarde eerst door gelaten moet worden voor die bij de 2e poort aan mag kloppen. De eerste weerstand wil ik dan vervangen met de acceleratie sensor en de 2e blijft een licht weerstand die aan de punt van het zwaard wordt bevestigd.

De aanhouder wint

Deze prototype heeft mij erg veel moeite gekost. Doordat ik niet wilde dat de arduino de waardes van de 2e poortwachter zou lezen zonder dat de eerste al is geactiveerd moest ik werken met een extra obstakel. Dit heb ik eerst geprobeerd door de 2 regels code achter elkaar aan te plakken wat niet werkte, toen door de 2e waarde vanaf het begin op 0 te zetten. Wat ook niet werkte omdat analog read niet op die manier werkt. En toen had ik het geprobeerd door de analog invoer op de arduino op low te zetten in mijn code. Wat natuurlijk ook niet werkt.

Uiteindelijk was de oplossing erg simpel. Door een boolean(aan uit knop in code) te maken voor beide weerstanden kon ik daar ook een nieuwe if statement van maken. Deze booleans beginnen beide als uit en worden aangezet wanneer de waardes kloppen. Door daar gebruik van te maken kon ik mijn schema toepassen in de code en kwam ik weer een stapje richting van mijn gewenste eindresultaat. Het resultaat en de code is hierboven te zien.

Om te leren hoe de sensor te werk gaat heb ik een tutorial opgezocht van Superb tech op youtube. https://www.youtube.com/watch?v=a37xWuNJsQI

Deze tutorial heb ik gevolgd om de sensor eerst werkend te maken en om vervolgens te kijken of ik daar ook een if-statement van kon maken dat een lampje laat branden. Dit is me zonder veel moeite gelukt doordat ik in een eerdere prototype die code al heb gemaakt en alleen de waardes hoefde aan te passen. Ik heb hierbij geleerd door in de code de " || "te gebruiken ik meerdere voorwaardes kan gebruiken. De aansluiting van de sensor op de arduino is hierboven te zien en de gebruikte is hieronder te zien.

#include "Wire.h"    //library in Arduino ide 
#include "I2Cdev.h"  //library in Arduino ide  
#include "MPU6050.   //library in Arduino ide (acceleratie sensor)

MPU6050 mpu;
int16_t ax, ay, az;
int16_t gx, gy, gz;
int ledPin= 2; //het lampje
int intentieX = 250; // of het zwaard genoeg heeft bewogen x as
int intentieY = 250; // of het zwaard genoeg heeft bewogen y as
int intentieZ = 250; // of het zwaard genoeg heeft bewogen z as


struct MyData {
  byte X;
  byte Y;
  byte Z;
};


MyData data;


void setup()
{
  Serial.begin(9600);
  Wire.begin();
  mpu.initialize();
  pinMode (ledPin,OUTPUT);
}


void loop()
{
 
  mpu.getMotion6(&ax, &ay, &az, &gx, &gy, &gz);
  data.X = map(gx, -17000, 17000, 0, 255 ); // X axis data 
  data.Y = map(gy, -17000, 17000, 0, 255); // Y axis data
  data.Z = map(gz, -17000, 17000, 0, 255);  // Z axis data
  Serial.print(data.X); //controle waardes x as
  Serial.print(",");
  Serial.print(data.Y); //controle waardes Y as
  Serial.print(",");
  Serial.println(data.Z); //controle waardes z as
  Serial.print(",");


if( data.X >= intentieX || data.Y>= intentieY || data.Z >= intentieZ ){ //voorwaardes of het lampje aan mag. 
   digitalWrite (ledPin, HIGH); //lampje aan
} else{
   digitalWrite (ledPin, LOW); //lampje uit
}
}

Na weer een keer gespard te hebben in een training kwam ik op een nieuw probleem uit in mijn ontwerp. Namelijk wanneer je de tegenstander goed hebt gestoken stopt het zwaard met bewegen. Daardoor laat hij de waarde niet meer langs de eerste poortwachter gaan (beweegt het zwaard genoeg?). Hier heb ik een oplossing op bedacht.

Ik heb gezocht naar een manier om de beweeg waardes tijdelijk op te slaan in de arduino voordat hij hem weer reset. De meest logische oplossing hiervoor was om een timer te bouwen die af zou gaan wanneer er genoeg acceleratie is geweest. Arduino heeft een milliseconden systeem wat ik hier voor kan gebruiken.

Gebruikte integers:

int huidigeTijd = 0;//deze waarde wordt aangepast wanneer de timer wordt opgeroepen(het millis systeem van arduino)
int oudeTijd = 0; //deze waarde wordt aangepast wanneer de timer start
int resetTijd = 2000; //dit is hoe lang de timer duurt
int doelTijd = 0; // het einde van de timer

Door deze integers heb ik een timer kunnen bouwen. Arduino zelf kan niet tijd stop zetten of resetten. Daarom heb ik een rekensom moeten maken die uitrekent hoeveel tijd er al verstreken is na het opstarten van de arduino en het moment dat er genoeg acceleratie is geweest. Om dit mogelijk te maken heb ik 2 vrienden om hulp gevraagd die veel ervaring hebben met coderen. Zo zijn wij samen op de volgende code uitgekomen:

//Timer code-------------------------------------------------------------------------------------------
 oudeTijd = huidigeTijd;
  huidigeTijd = millis(); //millis systeem van arduino
  int deltaTime = huidigeTijd - oudeTijd; //hoeveel tijd is er verstreken?
  doelTijd = doelTijd - deltaTime;  //de doeltijd word de reset tijd wanneer de timer afgaat. Hoeveel tijd er is verstreken sinds dat moment wordt er dan vanaf getrokken.

  if (doelTijd< -1){ //dit voorkomt dat de arduino oneindig lang doortelt in de min getallen.
    doelTijd = -1;
}

doelTijd = resetTijd; //deze code wordt opgeroepen in de if statement van de gate keepers. 

Deze code kan worden opgeroepen in de if-statements van de poortwachters. Wanneer er genoeg acceleratie is geweest dan zal hij 2 seconden af tellen. Binnen in die 2 seconden mag hij kijken of er een steek is geweest en daarbuiten zal de arduino daar niet op reageren.

Uiteindelijk heb ik de laatste 2 prototypes samengevoegd tot een enkele code. In plaats van dat er 2 licht sensoren waren heb ik de eerste vervangen met de acceleratie sensor. Bij de eerste poortwachter is nu een timer aan gekoppeld die afgaat wanneer de acceleratie hoog genoeg is geweest. Als laatste aanpassing voor mijn daadwerkelijke eind prototype zal ik het lampje vervangen met een buzzer dat voor 1 seconde een geluid zal maken. De uiteindelijke code heb ik toegevoegd aan stap 12. Het enige verschil met deze prototype is dat het lampje is vervangen met een buzzer en de intensie waardes op de werkelijkheid zijn aangepast.

Op dit punt is mijn prototype zo goed als afgerond. Daarom is nu het punt van het zwaard zelf maken aangekomen. gebruik hier de:

• 1x MDF plank 4 mm 60x80 cm
• 1x lange stok 1,3 m 2,5 cm diameter
• Katoen touw 2 mm dik
• Lasersnijder

De lange stok wordt de basis van het zwaard. Uit de MDF plaat heb ik de pareerstang uitgesneden met behulp van de lasersnijder. Hiervoor heb ik een DXF bestand gemaakt met behulp van illustrator. De afbeelding hiervan is boven dit kopje te vinden. Voor het controleren van de maten snij het ontwerp eerst uit van papier. Bij het maken van het bestand heb ik tussendoor getest of de arduino goed zou passen om niet voor nare verassingen te komen staan. Je vind het snijbestand boven dit kopje.

In het ontwerp zitten extra gaten.

• 2 aan de bovenkant aan weerszijdes van waar de stok zal komen. Deze zijn om de 2 verlengde draden van de licht sensor door te laten.
• Een ronde aan de voorkant van de stang. Hier zal de buzzer uitsteken zodat deze goed te horen is.
• En als laatste een serie kleine gaatjes aan de achterkant van de pareerstang. Deze heb ik toegevoegd zodat de 2 houten paneeltjes afneembaar zijn. Door die gaatjes met katoenen touw aan elkaar te verbinden zit de pareerstang stevig aan elkaar vast maar mocht er een probleem zijn met de arduino zijn ze toch redelijk eenvoudig te demonteren. Dit maakt de behuizing praktisch en valt nog steeds binnen de beoogde uitstraling.

Gebruik hier:

• 1x lange stok 1,3 m 2,5 cm diameter
• Katoen touw 2 mm dik
• Houtlijm

Lijm alle onderdelen aan elkaar met de houtlijm. Doe dit secuur en laat dit dan goed drogen. Denk er goed om dat de 2 achterste stukken hout (met de gaatjes) niet mee gelijmd worden omdat deze afneembaar moeten blijven.

Schuif de stok door het daarvoor bestemde gat totdat je 32 centimeter overhebt voor het heft. Voeg tussen de stok en de stang aan beide kanten voldoende lijm toe en laat dit minimaal een dag goed drogen.

Nu het zwaard in elkaar zit is de volgende stap de arduino toevoegen en de bedrading solderen. Gebruik hiervoor:

• Arduino uno
• Draadbruggen set
• 30 AWG Flexibel koperdraad rood
• Set krimpkousen
• 1x 330 Ohm-weerstand
• 1x piezo buzzer
• 1 x LDR lichtgevoelige weerstand
• Acceleratie versnellingsmeter en gyroscoop I2C -MPU- 6050
• Prototyping board (PCB)
• 9V Batterij clip met 5.5mm jack
• 9 Volt batterij
• Ductape

• Soldeerbout met soldeer (+soldeertin)

Gebruik als voeding een 9 volt batterij. Deze is klein genoeg om in de behuizing te passen en krachtig genoeg om de arduino te kunnen voeden.

Het circuit dat gebouwd moet worden heb ik hierboven geplaatst in een fritzing bestand. De licht sensor komt helemaal aan het topje van het zwaard dus deze heb ik bevestigd aan 2 lange draden en deze aan elkaar gesoldeerd. Ditzelfde heb ik gedaan met de buzzer die door het gat van de pareerstang steekt. Alle draden die eerder aan de breadboard waren bevestigd heb ik nu aan een pcb bordje vast gesoldeerd. Om die reden heb ik alle verbindingen aan de achterkant van het pcb bord opnieuw verbonden met de soldeertin zoals te zien is op de 4e foto. Het gaat hierbij om de 5 volt met de buzzer en de sensoren, het weerstandje met de licht sensor en de acceleratie meter. Door de gaatjes en draden met elkaar te verbinden door middel van soldeer tin geleiden die het stroom en zijn ze net zoals op een breadboard met elkaar verbonden.

Vergeet niet voor het solderen van de licht sensor om de draden door de daarvoor bestemde gaten te voeren zodat deze correct vast zitten. Dit kan naderhand niet meer!

Gebruik de ductape om de arduino stevig in de behuizing vast te zetten zoals te zien is op de laatste foto. Zet de buzzer in het gat vast door ook hier royaal gebruik te maken van houtlijm.

Omdat het zwaard nu in elkaar zit heb ik de laatste testen uit kunnen voeren met mijn code. Ik heb hierbij de intensie meter bijgesteld op daadwerkelijke slagen en steken om dit zo dichtbij als mogelijk is in te stellen op een daadwerkelijk gevecht. Ook heb ik in de code het lampje nu eindelijk vervangen met een buzzer en dit nog een keer uitgetest.

Dit is het uiteindelijke resultaat geworden:

//motion sensor ---------------------------------------------------------------------------
#include "Wire.h"
#include "I2Cdev.h"
#include "MPU6050.h"


MPU6050 mpu;
int16_t ax, ay, az;
int16_t gx, gy, gz;
int intentieX = 250;
int intentieY = 250;
int intentieZ = 250;


struct MyData {
  byte X;
  byte Y;
  byte Z;
};


MyData data;


//tijd en photoresistor------------------------------------------------------------------


//int ledPin2 = 2;
const int ledPin2 = 2; //buzzer
bool gateKeeper1 = false; //poortwachter 1 acceleratie
bool gateKeeper2 = false; //poortwachter 2 licht sensor
int huidigeTijd = 0;
int oudeTijd = 0;
int resetTijd = 2000; //de lengte van de timer 
int doelTijd = 0; //timer die aftelt


//---------------------------------------------------------------------------------------
void setup() {
  Serial.begin(9600);
  Wire.begin();
  mpu.initialize(); //acceleratie sensor
  pinMode(ledPin2, OUTPUT); //buzzer
  pinMode(A2, INPUT);  /// licht sensor
}


//--------------------------------------------------------------------------------------
void loop() {
  int value2 = analogRead(A2); //licht sensor wordt afgelezen


  //tijd berekening en timer starten----------------------------------------------------
  oudeTijd = huidigeTijd;
  huidigeTijd = millis(); //milli systeem van arduino
  int deltaTime = huidigeTijd - oudeTijd; 
  doelTijd = doelTijd - deltaTime; //laat de timer aftellen


  if (doelTijd < -1) { //voorkomt het doortellen van de arduino onder de min 1
    doelTijd = -1; //doeltijd word op min 1 gehouden tot er weer wat gebeurd
  }


  //motion sensor aflezen----------------------------------------------------------------
  mpu.getMotion6(&ax, &ay, &az, &gx, &gy, &gz);
  data.X = map(gx, -17000, 17000, 0, 255);  // X axis data
  data.Y = map(gy, -17000, 17000, 0, 255);  //Y axis data
  data.Z = map(gz, -17000, 17000, 0, 255);  // Z axis data

  //Timer aan of uit---------------------------------------------------------------------
   Serial.println(doelTijd);


  if (data.X >= intentieX || data.Y >= intentieY || data.Z >= intentieZ) { //is er genoeg acceleratie geweest?
    gateKeeper1 == true; //Ja dat is er! start de timer
    doelTijd = resetTijd;
  } else {
    gateKeeper1 == false; //nee dat is er niet! er gebeurd niks
  }


  //is er iemand geraakt met een steek?--------------------------------------------------


  if (value2 > 400) { //nee dat is er niet
    gateKeeper2 = false;
  } else if (doelTijd > 0) { //ja dat is er en de timer staat aan!
    gateKeeper2 = true;
  } else {
    gateKeeper2 = false; //de timer staat niet aan dus dit telt niet
  }


  if (gateKeeper2 == true) { //Alle voorwaarden kloppen! buzzen maar
    digitalWrite(ledPin2, HIGH); //buzzer gaat aan
    tone (ledPin2, 1000,1000); // buzzer maakt voor 1 seconde een geluid
  } else {
    digitalWrite(ledPin2, LOW); //buzzer staat uit
  }
}

Deze code heb ik meerdere keren uitgetest met mijn gesoldeerde project en al met al ben ik zeer tevreden met de manier waarop hij op mijn bewegingen en steken reageerd.

Nu zijn we bij het punt aangekomen om het zwaard mooi en afgewerkt te maken.

Gebruik hiervoor:

• Ductape
• Lapje flexibel leer
• Katoenen touw
• Houtlijm
• Naald en draad
• Het zwaard

Het zwaard zit nu in elkaar en de lijm is goed gedroogd, maar de buiten bedrading is nog niet voldoende beschermd om te gebruiken en de licht sensor zit nog niet goed vast op de punt.

De punt

Laat de draden van de sensor kruislings over de stok heen wikkelen en buig de sensor zo om dat deze plat op de punt komt te liggen. Plak deze stevig vast met stroken ductape die over de draden gaan maar niet verder dan 3 cm van de punt gaan.

Pak nu het lapje leer en snij het bijgevoegde patroon uit. Leg deze precies over de punt en de sensor en naai hem dan vast met een rijg steek. Naai dit met dubbel draad voor extra stevigheid.

De basis

Om de draad ingang bij de pareerstang te verstevigen zullen we die verstevigen met het katoenen draad. Knip een lang stuk draad af (circa 70 cm) en wikkel die meerdere keren om het zwaard en draad heen zoals op de foto. Om er zeker van te zijn dat dit goed vast zit heb ik de uiteindes ingesmeerd met houtlijm.

Dit is de uiteindelijke prototype! Bekijk de video om het resultaat goed te bekijken (en te horen). Ik demonstreer daar hoe hij werkt door middel van het zwaard eerst goed te laten bewegen voor de steek. Maar ik laat ook zien dat hij niet afgaat als er nog niet genoeg is bewogen.

Al met al heb ik erg veel geleerd van dit project en veel nieuwe dingen uitgeprobeerd. Mocht jij hem ook willen bouwen, heel veel succes! en bovenal veel steek plezier!