Gidsen · 26 min leestijd

Slimme blindenstok met Arduino: waarschuwingen voor obstakels, water en valpartijen

Zo bouw je een slimme blindenstok met Arduino: obstakeldetectie met de HC-SR04, trilalarm, watersensor, valdetectie met de MPU6050, SOS en de volledige code.

Een slimme blindenstok met Arduino waarschuwt een slechtziende of blinde voor obstakels die een gewone witte stok niet opmerkt, en het is een van de populairste elektronicaprojecten voor schoolopdrachten en techniekwedstrijden. Een HC-SR04-ultrasoonsensor bij het handvat meet de afstand tot alles wat voor je ligt; naarmate het obstakel dichterbij komt, pulseert een trilmotor in het handvat sneller en harder, en als je wilt geeft een buzzer bij elke puls een korte piep. Zo voelt de gebruiker obstakels boven heuphoogte, die de punt van de stok nooit raakt, al een paar stappen van tevoren.

In deze gids begin je met de basisschakeling en voeg je daarna stap voor stap de extra's toe die het project echt bruikbaar maken: een plassensensor bij de punt van de stok, een algoritme dat met een MPU6050 merkt dat de stok is gevallen en een SOS laat horen als niemand dat binnen 20 seconden annuleert, een voeding die met één 18650-cel meer dan 25 uur meegaat, een behuizing die rekening houdt met gewicht en ergonomie, en een ESP32 + GPS-uitbreiding die de locatie per sms verstuurt. Aan het eind vind je ook concrete tips om het project te testen en te presenteren op een techniekwedstrijd.

HC-SR04-ultrasone afstandssensor voor een slimme stok
De HC-SR04 stuurt een geluidspuls van 40 kHz uit en berekent de afstand uit de tijd die de echo nodig heeft om terug te komen. Op een slimme stok let hij binnen een smalle kegel van ongeveer 15 graden op obstakels tussen 2 en 150 cm.

Wat is een slimme stok en wat doet hij?

De witte stok is het hulpmiddel dat een blinde persoon het meest vertrouwt: elke tik onthult de grond, de stoeprand, een trede of een laag obstakel vooraan. Maar een stok "ziet" alleen wat de punt raakt. Obstakels boven heuphoogte, zoals een lage boomtak, een bord dat boven de stoep uitsteekt, de buitenspiegel van een vrachtwagen, een open raam of een airco-unit die uit een muur steekt, raken de punt nooit en komen in plaats daarvan tegen het lichaam of het hoofd van de gebruiker. Een slimme stok is ontworpen om dat gat te dichten: een elektronische sensor scant de hoogtes en afstanden die de stok niet bereikt en geeft het resultaat als trilling door aan de hand van de gebruiker.

Eén ding vooraf: een slimme stok vervangt de witte stok of de oriëntatie- en mobiliteitstraining niet, hij vult ze aan. De ultrasoonsensor heeft blinde vlekken en batterijen raken leeg, dus de gouden regel van het ontwerp is dat de stok precies zo moet blijven werken als altijd, ook als de elektronica helemaal uit staat. Op de Internationale Dag van de Witte Stok, elk jaar op 15 oktober, is dit project een mooie gelegenheid om op je school te laten zien.

Hoe werkt een slimme stok?

Het project bestaat uit één lus die honderden keren per seconde draait en vier onafhankelijke taken tegelijk afhandelt. Elke 60 milliseconden meet de Arduino de afstand, neemt de mediaan van de laatste drie metingen en past daarop de trilsnelheid aan. Elke halve seconde leest hij de watersensor aan de punt van de stok uit. Vijftig keer per seconde leest hij de versnellingswaarden van de MPU6050 om te controleren of de stok is gevallen. En elke dertig seconden controleert hij de batterijspanning. Het ontwerp heeft twee uitgangskanalen met aparte taken: trilling is alleen voor obstakels, terwijl geluid bijzondere gebeurtenissen meldt, zoals water, een val, SOS en een lege batterij. Een korte druk op de knop zet de obstakelpiepjes aan of uit als je dat wilt.

OnderdeelTaakOpmerking
Arduino Nano (Uno voor prototypes)Meet, beslist en stuurt de motor en buzzer aanDe Nano past bij een stok omdat hij klein en licht is
HC-SR04-ultrasoonsensorMeet de afstand tot het obstakel voor je5 V, ongeveer 15 mA; JSN-SR04T voor gebruik in de regen
TrilmotormoduleGeeft het obstakel door aan de hand via trillingKant-en-klare module met transistor en diode
Passieve buzzerMeldingen voor water, val, SOS en batterijPassief, dus hij kan verschillende tonen spelen
WaterniveausensorWaarschuwt als de punt van de stok in water komt1–2 cm boven de punt, alleen onder spanning tijdens het meten
MPU6050 (GY-521)Detecteert dat de stok is gevallen en plat ligtI2C, adres 0x68
DrukknopGeluid aan/uit, alarm annuleren, SOS bij lang indrukkenOnder de duim geplaatst
18650-cel + TP4056 + MT3608Mobiele voeding, opladen via USB, boost naar 5 VGebruik een beschermde TP4056 (met DW01)
2 weerstanden van 100 kΩDeler om de batterijspanning te metenHet middelpunt gaat naar A0
Schakelaar en behuizingAan/uit en bescherming3D-geprint of een klein projectdoosje
Arduino Nano
Arduino Nano
Passieve buzzer
Passieve buzzer
Drukknop
Drukknop
18650 Li-ionbatterij
18650 Li-ionbatterij

Obstakeldetectie: hoe meet de HC-SR04 en waar komt hij?

Als de HC-SR04 een puls van 10 microseconden op zijn TRIG-pin krijgt, zendt hij acht geluidsgolven van 40 kHz uit en houdt hij de ECHO-pin HIGH totdat de echo terugkomt. Bij 20 °C reist geluid ongeveer 343 meter per seconde; als je heen en terug meetelt, gaat er ongeveer 58 microseconden voorbij per centimeter. De afstand is dus simpelweg cm = tijd (µs) / 58. De sensor ziet binnen een kegel van ongeveer 15 graden; op 1,5 meter afstand is die kegel ongeveer 40 cm breed. Omdat de sensor meedraait met de stok als je die van links naar rechts zwaait, scant hij automatisch een strook van ongeveer een meter breed voor je. De details van de sensor vind je in het artikel HC-SR04-afstandssensor.

Het belangrijkste detail van de montage is de hoek. Tijdens het lopen houd je de stok niet rechtop maar naar voren gekanteld, ongeveer 40–50 graden ten opzichte van de verticaal. Als je de sensor evenwijdig aan de stok plakt, wijst hij naar de grond en verwart hij de vloer voortdurend met een obstakel. Bevestig de doos dicht bij het handvat, ongeveer 75 cm boven de grond, en richt de sensor iets boven horizontaal. Met de stok onder 45 graden moet de sensoras een hoek van 60 graden met de schacht maken (gemeten richting de punt) zodat de sensor 15 graden boven horizontaal wijst. De makkelijkste manier om de juiste hoek te vinden is de stok in je gewone grip te houden en een waterpas-app op je telefoon tegen de voorkant van de doos te houden.

Sensorhoek (boven horizontaal)Gescande hoogte op 1,5 m afstandTypische obstakels die hij opmerkt
0°Ongeveer 55–95 cmBanken, afvalbakken, de carrosserie van een geparkeerde auto
15°Ongeveer 95–135 cmDe romp van een persoon, fietsstuur, de laadbak van een vrachtwagen
25°Ongeveer 120–170 cmBorden, boomtakken, open ramen, buitenspiegels

Als je met één sensor begint, is 15–20 graden een goed compromis: obstakels op lichaamshoogte worden daarmee goed opgemerkt. Obstakels op hoofdhoogte komen echter pas in de bovenrand van de kegel terecht als ze nog ver weg zijn en vallen eruit naarmate je dichterbij komt. Als hoofdhoogte voor jou belangrijk is, wijd dan een tweede HC-SR04 daaraan, 30–35 graden omhoog gekanteld; omdat deze sensor schuin meet, houd je zijn bereik op ongeveer 200 cm. Vergeet niet de twee sensoren na elkaar te triggeren met minstens 60 ms ertussen, anders hoort de een de echo van de ander. Voor een uitgebreide vergelijking met laser- (ToF) en infraroodsensoren, zie het artikel afstandssensoren vergeleken.

SensorBereikVoordelenNadelen
HC-SR042–400 cmGoedkoop, eenvoudig, brede kegelNiet waterdicht, heeft moeite met zachte oppervlakken
JSN-SR04TOngeveer 25–450 cmWaterdichte probe, werkt in de regenZiet niets dichterbij dan 25 cm, duurder
VL53L1X (laser-ToF)Tot 4 mKlein, licht, smalle bundelBereik daalt in zonlicht, 3,3 V I2C
Sharp GP2Y0A02 (infrarood)20–150 cmAnaloge uitgang, eenvoudige codeLaat zich foppen door donkere en glimmende oppervlakken, verbruikt ongeveer 33 mA
Ken de blinde vlekken van de ultrasoonsensor: zachte oppervlakken zoals een dikke jas, struiken of een gordijn absorberen het geluid, terwijl een glazen deur of een schuin paneel het wegkaatst, waardoor het obstakel misschien helemaal niet verschijnt. Dunne palen van 3–4 cm doorsnede worden ook laat opgemerkt, omdat ze klein zijn binnen de kegel. Daarom moet je een slimme stok nooit presenteren als het enige veiligheidshulpmiddel; het is een hulpmiddel dat samenwerkt met de witte stok.

Trilsnelheid en piepsnelheid op basis van afstand

Een blinde persoon neemt zijn omgeving grotendeels waar via geluid: een naderende auto, het geroezemoes van een menigte, de echo van het tikken van de stok tegen een muur helpen allemaal bij het vinden van de weg. Een buzzer die voortdurend piept maskeert die geluiden in plaats van te helpen. Het belangrijkste waarschuwingskanaal in dit project is daarom trilling, en de regel is simpel: hoe dichterbij het obstakel, hoe vaker en sterker de trilpulsen. Alles verder dan 150 cm wordt genegeerd, en als een obstakel dichterbij is dan 30 cm trilt de motor continu. Daartussen wordt het pulsinterval lineair berekend met map(): interval = 120 + (afstand − 30) × 6,5 ms.

Waarom 150 cm? Iemand die met een witte stok loopt, legt ongeveer 1 meter per seconde af. Een bereik van 150 cm geeft ongeveer 1,5 seconde voordat hij het obstakel bereikt; omdat de reactietijd op een tactiele waarschuwing 0,2–0,3 seconde is, is dat genoeg om te stoppen of van richting te veranderen. Rek je het bereik op tot 250 cm, dan trilt de stok op een drukke stoep non-stop, waardoor de gebruiker de waarschuwingen na een tijdje gaat negeren. Binnen werkt 100 cm goed, buiten 150–200 cm; je hoeft alleen de constante FAR_CM aan te passen.

AfstandPulsintervalTrilsterkte (PWM)Betekenis voor de gebruiker
Verder dan 150 cmGeen trilling0De weg is vrij
150 cm900 ms150Er is een obstakel voor je
100 cm575 ms194Obstakel nadert, wees voorzichtig
60 cm315 ms229Vertraag, maak je klaar om van richting te veranderen
40 cm185 ms247Heel dichtbij
30 cm of dichterbijContinu255Stop
Arduino-trilmotormodule
Trilmotormodule: naast de muntvormige motor van ongeveer 10 mm doorsnede zitten de transistor die hem aanstuurt en een vrijloopdiode. De IN-pin gaat rechtstreeks naar een PWM-pin van de Arduino en de module draagt de motorstroom.

De motor die het vaakst in stokken wordt gebruikt, is een muntvormige ERM-motor zoals in mobiele telefoons. Hij draait op ongeveer 3 V en verbruikt zo'n 60–80 mA. Een Arduino-pin kan echter hooguit 40 mA leveren, met 20 mA als veilige grens, dus de motor wordt niet rechtstreeks op de pin aangesloten maar via een transistor. Kant-en-klare modules bevatten die transistor al, plus de diode die de tegenspanning opvangt als de motor stopt; de meeste modules werken op 3,3–5 V. Gebruik je een kale motor, dan volstaan een NPN-transistor zoals een BC337 of 2N2222, een basisweerstand van 1 kΩ en een 1N4148-diode in sperrichting over de motor; je kunt transistors vergelijken in de tool Transistors.

Waar je de motor plaatst is net zo belangrijk als de code. Plaats hem in het handvat, waar de handpalm of wijsvinger rust, en bevestig hem met dun rubber in plaats van schuim, want schuim absorbeert de trilling. Op volle snelheid trilt een muntmotor met ongeveer 200 Hz, en onze huid is het gevoeligst voor trillingen rond 200–300 Hz, dus zelfs een kleine motor op de juiste plek is goed te voelen. Omdat ERM-motoren bij heel lage PWM-waarden niet kunnen aanlopen, blijft de zwakste trilling in de code op 150 van 255. Meer over de keuze van de motor en het regelen van de intensiteit met PWM vind je in het artikel trilmotor.

Bedradingsschema: Arduino Uno/Nano, ESP32 en Raspberry Pi Pico

De onderstaande tabel komt precies overeen met alle code in dit artikel. De pinnummers zijn hetzelfde op de Uno en Nano; op beide boards zit de I2C-bus van de MPU6050 op A4 (SDA) en A5 (SCL). De VCC van de trilmodule gaat naar 5V en zijn IN-pin is bewust op D5 gezet: tone() gebruikt Timer2, dus PWM op D3 en D11 werkt niet meer zolang de buzzer speelt, terwijl D5 bij Timer0 hoort en daar geen last van heeft. De pinindeling van de Nano zie je in de tool Pinout.

AansluitingArduino Uno / NanoESP32Raspberry Pi Pico
HC-SR04 VCC5VVIN (5 V)VBUS of de 5 V-rail
HC-SR04 TRIGD9GPIO 18GP2
HC-SR04 ECHOD10 (direct)GPIO 19, via een 1 kΩ / 2 kΩ-delerGP3, via een 1 kΩ / 2 kΩ-deler
IN van de trilmoduleD5 (PWM)GPIO 25GP15
Passieve buzzer (+)D8GPIO 26GP16
Knop (andere pootje naar GND)D2GPIO 27GP14
Watersensor +D7GPIO 33GP22
Watersensor SA1GPIO 34 (ADC1)GP26 (ADC0)
MPU6050 SDAA4GPIO 21GP4
MPU6050 SCLA5GPIO 22GP5
MPU6050 VCC5V3V33V3
Batterijmeting (middelpunt van de 100k/100k-deler)A0GPIO 35 (ADC1)GP28 (ADC2)
NEO-6M GPS TX / RXGeenGPIO 16 / GPIO 17Geen
SIM800L TXD / RXDGeenGPIO 13 / GPIO 23Geen
De ECHO-pin van de HC-SR04 geeft een puls van 5 V af, maar de pins van de ESP32 en de Pico werken op 3,3 V en zijn niet 5V-tolerant. Bouw een spanningsdeler als ECHO → 1 kΩ → draad naar het board → 2 kΩ → GND, dan komt er ongeveer 3,3 V op de pin. Gebruik op de ESP32 ADC1-pins (GPIO 32–39) voor analoge metingen, want ADC2 werkt niet als Wi-Fi aan staat. Op ESP32-boards met een WROVER-module zijn GPIO 16 en 17 verbonden met het PSRAM; heb je zo'n board, verplaats de GPS dan naar twee andere pins. Alle modules moeten dezelfde GND delen.

Stap voor stap bouwen: begin met de basisstok

  1. Bouw de schakeling eerst op een breadboard en bevestig hem pas helemaal aan het eind aan de stok. Plaats de Arduino Nano in het midden van het breadboard en breng 5V en GND naar de zijrails.
  2. Sluit VCC en GND van de HC-SR04 aan op de rails, TRIG op D9 en ECHO op D10.
  3. Sluit VCC van de trilmodule aan op 5V, zijn GND op GND en zijn IN-pin (S bij sommige modules) op D5. Steek het positieve pootje van de passieve buzzer in D8 en het andere pootje in GND.
  4. Upload de basiscode hieronder en open de Serial Monitor op 9600 baud. Beweeg je hand langzaam naar de sensor toe en ervan af; de afstand op het scherm moet veranderen en de trilling moet daarmee sneller en langzamer worden.
  5. Houd de sensor op 150, 100, 60 en 30 cm van een muur en vergelijk de waarde in de Serial Monitor met een rolmaat. Is het verschil meer dan 1–2 cm, controleer dan de bedrading en de voeding.
  6. Werkt alles, voeg dan de watersensor, de MPU6050 en de knop toe en ga verder met de volledige code.
C++ (Arduino IDE)
1// Temel akıllı baston: engel yaklaştıkça titreşim ve bip hızlanır / Basic smart cane: vibration and beeps speed up as an obstacle gets closer
2const int TRIG = 9, ECHO = 10;      // HC-SR04
3const int VIB = 5;                  // titreşim modülü IN, PWM pini / vibration module IN, PWM pin
4const int BUZZER = 8;               // pasif buzzer / passive buzzer
5
6const int NEAR_CM = 30;             // bundan yakın: sürekli uyarı / closer than this: continuous alert
7const int FAR_CM = 150;             // bundan uzak: sessiz / farther than this: silent
8const int PULSE_MS = 60;            // bir titreşim darbesinin süresi / length of one vibration pulse
9
10unsigned long lastPing = 0, lastPulse = 0;
11int distanceCm = 999;
12int vibNow = -1;
13
14void setVib(int v) {                // yalnızca değer değişince yaz / write only when the value changes
15  if (v != vibNow) { analogWrite(VIB, v); vibNow = v; }
16}
17
18int pingCm() {
19  digitalWrite(TRIG, LOW);  delayMicroseconds(2);
20  digitalWrite(TRIG, HIGH); delayMicroseconds(10);   // 10 µs tetik darbesi / 10 µs trigger pulse
21  digitalWrite(TRIG, LOW);
22  unsigned long t = pulseIn(ECHO, HIGH, 12000UL);    // 12 ms ≈ 2 m, daha uzağı gerekmez / 12 ms ≈ 2 m, no need for more
23  return t == 0 ? 999 : (int)(t / 58);               // 999 = yankı yok / 999 = no echo
24}
25
26void setup() {
27  Serial.begin(9600);
28  pinMode(TRIG, OUTPUT);
29  pinMode(ECHO, INPUT);
30  pinMode(VIB, OUTPUT);
31}
32
33void loop() {
34  unsigned long now = millis();
35
36  if (now - lastPing >= 60) {                        // ölçümler arası en az 60 ms / at least 60 ms between pings
37    lastPing = now;
38    distanceCm = pingCm();
39    Serial.println(distanceCm);
40  }
41
42  if (distanceCm < 2 || distanceCm > FAR_CM) {       // yol açık / the path is clear
43    setVib(0);
44  } else if (distanceCm <= NEAR_CM) {                // çok yakın: sürekli / very close: continuous
45    setVib(255);
46    if (now - lastPulse >= 120) { lastPulse = now; tone(BUZZER, 2500, 60); }
47  } else {
48    unsigned long period = map(distanceCm, NEAR_CM, FAR_CM, 120, 900);  // yakın = sık / near = frequent
49    int strength = map(distanceCm, NEAR_CM, FAR_CM, 255, 150);         // yakın = güçlü / near = strong
50    if (now - lastPulse >= period) {
51      lastPulse = now;
52      tone(BUZZER, 2000, 30);                        // kısa bip / short beep
53    }
54    setVib(now - lastPulse < PULSE_MS ? strength : 0);
55  }
56}

Er staat nergens in de code een lange delay(); elke taak draait op tijdstempels die met millis() worden bijgehouden, zodat de trilpulsen de metingen nooit ophouden. Voor pulseIn() is een timeout van 12 ms gekozen: aangezien 12.000 / 58 ≈ 200 cm zijn echo's van verder weg voor ons toch nutteloos, en een korte timeout voorkomt dat de lus blijft hangen. Komt er geen echo terug, dan geeft de functie 999, wat telt als "weg vrij". setVib() schrijft alleen naar de motor als de waarde verandert; omdat analogWrite() in de 2.x-versies van de ESP32-core bij elke aanroep de PWM-eenheid opnieuw configureert, laat dit kleine detail dezelfde code daar ook soepel draaien.

Plassensensor: een melding als de punt van de stok in water komt

Plassen behoren tot de moeilijkst op te merken obstakels met een witte stok: als de punt in water gaat, verschillen geluid en gevoel nauwelijks van de grond, terwijl een paar centimeter water genoeg is om je schoenen nat te maken. Hiervoor gebruiken we een goedkope waterniveausensor met in elkaar grijpende koperbanen. Sommige banen zijn verbonden met de voeding en andere met de signaallijn; als water ze overbrugt, stijgt de signaalspanning en neemt de waarde van analogRead() toe. Een droge sensor leest dicht bij 0, terwijl een sensor met zijn uiteinde in water op de Uno meestal een waarde van een paar honderd geeft; hoe dieper hij erin gaat, hoe hoger de waarde.

Bevestig de sensor helemaal onderaan de stok met zijn onderrand ongeveer 1–2 cm boven de punt en zijn banen loodrecht op de grond. Zo raakt niets hem op droge grond, maar in een plas dieper dan 1–2 cm worden de banen nat. De bekende zwakte van deze sensoren is dat de koperbanen door elektrolyse snel corroderen als ze voortdurend onder spanning staan. De oplossing in de code is om de +-pin van de sensor op D7 aan te sluiten in plaats van rechtstreeks op 5V en hem alleen tijdens de 10 ms van de meting van spanning te voorzien. Met één meting per halve seconde staat de sensor slechts 2% van de tijd onder spanning. Hoe hij werkt vind je in het artikel waterniveausensor en hoe hij verschilt van een regenbordje in het artikel regensensor.

Arduino-waterniveausensor
Waterniveausensor: als water de in elkaar grijpende koperbanen overbrugt, stijgt de spanning op de S-pin. Op een slimme stok zit hij 1–2 cm boven de punt en krijgt hij alleen tijdens de meting spanning.
Bedek het baanvrije bovenste deel van de sensor en zijn connector met hotglue of nagellak; water mag alleen de meetbanen raken. Laat de kabel niet buiten de stok bungelen: leid hem door de binnenkant van een aluminium stok of wikkel hem in krimpkous om de schacht. Voor een robuustere oplossing bevestig je twee roestvrijstalen schroeven 1 cm uit elkaar vlak boven de punt: de ene gaat naar D7, de andere naar A1, dat via een weerstand van 100 kΩ naar GND wordt getrokken. Als water de twee schroeven overbrugt, stijgt A1; de code blijft hetzelfde, je meet alleen WATER_LIMIT opnieuw.

Valdetectie met de MPU6050

De MPU6050 is een bewegingssensor met een drieassige versnellingsmeter en een drieassige gyroscoop op één chip, aangesloten via I2C. Op het GY-521-board zit een spanningsregelaar, dus het kan op 5 V draaien; het standaardadres is 0x68. In dit project gebruiken we alleen de versnellingsmeter en spreken we vier registers rechtstreeks aan in plaats van een bibliotheek te gebruiken: een 0 schrijven naar 0x6B maakt de chip wakker uit de slaapstand, 0x1A schakelt het ingebouwde 44 Hz-filter in, 0x10 schrijven naar 0x1C verhoogt het meetbereik naar ±8 g, en we lezen de X-, Y- en Z-versnellingen uit de zes bytes vanaf 0x3B. Het standaardbereik van ±2 g raakt zo verzadigd op het moment dat de stok de grond raakt, waardoor de werkelijke grootte van de klap verborgen blijft. In het ±8 g-bereik komt elke 1 g overeen met 4096 ruwe tellen. Om de sensor beter te leren kennen, kijk je in het artikel MPU6050-versnellingsmeter en gyroscoop.

MPU6050-versnellingsmeter- en gyroscoopmodule (GY-521)
MPU6050 (GY-521): een drieassige versnellingsmeter en gyroscoop. Hij zit vast in de doos met de op het board gedrukte X-pijl langs de stokschacht.

Bij elke meting berekent de code twee grootheden. De eerste is de totale versnelling: g = √(ax² + ay² + az²). Zolang de stok stilgehouden wordt of op de grond ligt, is dit ongeveer 1 g; bij een harde klap schiet het omhoog tot enkele g. De tweede is de kanteling, de hoek tussen de stok en de verticaal. Monteer je het board met de X-pijl langs de schacht, dan is de kanteling atan2(√(ay² + az²), |ax|): die leest 0 graden bij een rechtopstaande stok, 40–55 tijdens het lopen en 85–90 als hij op de grond ligt. Systemen die valpartijen van mensen detecteren, zoeken eerst naar een korte vrije val (een moment dicht bij 0 g); maar een omvallende stok beweegt als een staaf die rond zijn punt draait, dus een sensor bij het handvat ziet dat moment vaak nooit. Daarom zoekt ons algoritme niet naar vrije val maar naar een klap gevolgd door een platte, bewegingloze stand.

FaseVoorwaardeDuurWat gebeurt er?
WALKTotale versnelling overschrijdt 2,5 gOnbeperktGaat naar SETTLE; obstakelmeldingen blijven doorlopen
SETTLEWacht tot het schudden stopt1 sGaat naar CHECK
CHECKKanteling moet boven 70° blijven en versnelling tussen 0,8 en 1,2 g2 sTerug naar WALK als de voorwaarde breekt, ALARM als hij standhoudt
ALARMElke seconde een piep en trilling zodat de stok te vinden is20 sGeannuleerd door een druk op de knop of door de stok op te pakken (kanteling onder 60°)
SOS... --- ... in morsecode met geluid, led en trillingTot geannuleerdEen korte druk stopt het; de ESP32 stuurt een sms

Deze volgorde voorkomt de meeste valse alarmen. Met de stok op de grond tikken tijdens het lopen kan ook korte klappen boven 2,5 g geven, maar een seconde later zit de stok nog in de hand en staat hij onder 40–55 graden gekanteld, dus de controlefase wordt direct afgebroken; de gebruiker merkt het niet eens. Valt de stok echter en blijft hij plat liggen, dan begint het alarm na ongeveer 3 seconden, en met de piep elke seconde kan een gebruiker die zijn stok heeft laten vallen hem op het geluid terugvinden. Pakt de gebruiker de stok op, dan stopt het alarm vanzelf. Reageert niemand gedurende 20 seconden, dan neemt de code aan dat het een echte val kan zijn en start de SOS. Ook de knop 2 seconden ingedrukt houden start op elk moment handmatig een SOS.

Deze methode detecteert dat de stok is gevallen, niet de gebruiker. Houdt de persoon de stok vast tijdens het vallen, of komt de stok tegen een muur te leunen, dan gaat het alarm niet af; houd dus altijd de handmatige SOS-knop en leg deze beperking duidelijk uit in je presentatie. Om een val van het lichaam direct te meten, moet de sensor in een apart apparaat zitten dat aan de riem of om de pols wordt gedragen.

Test- en kalibratiecode

Drempels verschillen een beetje bij elke stok, elk oppervlak en elke sensor. Upload voordat je verdergaat naar de hoofdcode de onderstaande sketch: elke kwartseconde print hij de afstand, de ruwe waarde van de watersensor, de hoogste versnelling van de laatste kwartseconde en de kanteling naar de Serial Monitor. Als je de waarden in een tabel opschrijft, vul je ook meteen het resultatenhoofdstuk van je projectverslag.

C++ (Arduino IDE)
1// Test ve kalibrasyon: mesafe, su sensörü ham değeri, en yüksek ivme (g) ve eğim / Test and calibration: distance, raw water value, peak acceleration (g) and tilt
2#include <Wire.h>
3
4const int TRIG = 9, ECHO = 10;
5const int WATER_PWR = 7, WATER_SIG = A1;
6const byte MPU = 0x68;
7
8float peakG = 0, tilt = 0;
9unsigned long lastPrint = 0;
10
11void mpuWrite(byte reg, byte val) {
12  Wire.beginTransmission(MPU);
13  Wire.write(reg);
14  Wire.write(val);
15  Wire.endTransmission();
16}
17
18void readMpu() {
19  Wire.beginTransmission(MPU);
20  Wire.write(0x3B);                                  // ACCEL_XOUT_H
21  if (Wire.endTransmission(false) != 0) return;
22  if (Wire.requestFrom(MPU, (uint8_t)6) != 6) return;
23  float a[3];
24  for (int i = 0; i < 3; i++) {
25    uint8_t hi = Wire.read();
26    uint8_t lo = Wire.read();
27    a[i] = (int16_t)(((uint16_t)hi << 8) | lo) / 4096.0;    // ±8 g: 4096 LSB/g
28  }
29  float g = sqrt(a[0] * a[0] + a[1] * a[1] + a[2] * a[2]);
30  if (g > peakG) peakG = g;
31  tilt = atan2(sqrt(a[1] * a[1] + a[2] * a[2]), fabs(a[0])) * 180.0 / PI;  // X ekseni baston boyunca / X axis along the cane
32}
33
34int pingCm() {
35  digitalWrite(TRIG, LOW);  delayMicroseconds(2);
36  digitalWrite(TRIG, HIGH); delayMicroseconds(10);
37  digitalWrite(TRIG, LOW);
38  unsigned long t = pulseIn(ECHO, HIGH, 25000UL);
39  return t == 0 ? 999 : (int)(t / 58);
40}
41
42void setup() {
43  Serial.begin(9600);
44  pinMode(TRIG, OUTPUT);
45  pinMode(ECHO, INPUT);
46  pinMode(WATER_PWR, OUTPUT);
47  Wire.begin();
48  mpuWrite(0x6B, 0x00);                              // uyku modundan çıkar / wake from sleep mode
49  mpuWrite(0x1A, 0x03);                              // 44 Hz alçak geçiren filtre / 44 Hz low-pass filter
50  mpuWrite(0x1C, 0x10);                              // ivme aralığı ±8 g / accelerometer range ±8 g
51}
52
53void loop() {
54  readMpu();                                         // olabildiğince sık oku, tepeyi yakala / read as often as possible to catch the peak
55  if (millis() - lastPrint >= 250) {
56    lastPrint = millis();
57    digitalWrite(WATER_PWR, HIGH);                   // sensörü yalnızca ölçerken besle / power the sensor only while measuring
58    delay(10);
59    int water = analogRead(WATER_SIG);
60    digitalWrite(WATER_PWR, LOW);
61    Serial.print(F("cm: "));          Serial.print(pingCm());
62    Serial.print(F("  su/water: "));  Serial.print(water);
63    Serial.print(F("  tepe/peak g: ")); Serial.print(peakG, 2);
64    Serial.print(F("  egim/tilt: ")); Serial.println(tilt, 0);
65    peakG = 0;
66  }
67}
  1. Meet de watersensor droog en met zijn uiteinde 1 cm in een glas water. Leest hij bijvoorbeeld 0–20 droog en 520 nat, kies dan het midden van 270–300 voor WATER_LIMIT.
  2. Houd de stok in je gewone grip en zwaai hem van links naar rechts alsof je loopt. Noteer de kanteling; die blijft meestal tussen 40 en 55 graden en moet onder PICKUP_DEG (60) liggen.
  3. Leg de stok plat op de vloer. De kanteling moet 85–90 aangeven en de versnelling ongeveer 0,95–1,05 g, wat LYING_DEG (70) en het venster van 0,8–1,2 g bevestigt.
  4. Tik de stok tijdens het lopen zoals gewoonlijk op de grond en let op de piekwaarden van g. Laat de stok daarna 10 keer op een mat vallen. Stel IMPACT_G in onder de waarden van de vallen; ook als tikken deze drempel overschrijden, filtert de kantelcontrole ze eruit.
  5. Doe 10 metingen op 30, 60, 100 en 150 cm van een muur en vergelijk het gemiddelde met een rolmaat.

Volledige code: obstakels, water, valpartijen, SOS en waarschuwing bij lege batterij

In de volledige code draaien de vier taken in dezelfde lus zonder elkaar op te houden, en valdetectie is een kleine toestandsmachine gebouwd met enum en switch-case. De knop heeft drie taken: tijdens het lopen zet een korte druk de obstakelpiepjes aan of uit (de trilling blijft altijd aan), tijdens een alarm of SOS annuleert een korte druk het, en een lange druk van 2 seconden start op elk moment een SOS. Een hoge piep betekent geluid aan, een lage piep betekent geluid uit.

C++ (Arduino IDE)
1// Akıllı baston, tam sürüm: engel, su birikintisi, düşme algılama, SOS ve pil uyarısı
2// Smart cane, full version: obstacles, puddles, fall detection, SOS and low-battery warning
3#include <Wire.h>
4
5// Pinler (Arduino Uno ve Nano) / Pins (Arduino Uno and Nano)
6const int BUTTON = 2;               // buton, diğer bacağı GND / button, other leg to GND
7const int VIB = 5;                  // titreşim modülü IN (PWM) / vibration module IN (PWM)
8const int WATER_PWR = 7;            // su sensörü + ucu / water sensor + pin
9const int BUZZER = 8;               // pasif buzzer / passive buzzer
10const int TRIG = 9, ECHO = 10;      // HC-SR04
11const int LED = 13;                 // dahili LED, SOS'ta yanıp söner / built-in LED, flashes during SOS
12const int BAT = A0;                 // 18650, 100k/100k bölücüyle / 18650 via a 100k/100k divider
13const int WATER_SIG = A1;           // su sensörü S ucu / water sensor S pin
14const byte MPU = 0x68;              // MPU6050, AD0 = GND
15
16// Ayarlar: test koduyla bulduğun değerleri yaz / Settings: use the values from the test sketch
17const int NEAR_CM = 30, FAR_CM = 150;
18const int PULSE_MS = 60;
19const int WATER_LIMIT = 300;        // kuru ve ıslak okumaların ortası / midpoint of dry and wet readings
20const float IMPACT_G = 2.5;         // düşme darbesi eşiği / fall impact threshold
21const float LYING_DEG = 70;         // bundan büyük eğim = yerde yatıyor / tilt above this = lying flat
22const float PICKUP_DEG = 60;        // bundan küçük eğim = kaldırıldı / tilt below this = picked up
23const unsigned long CANCEL_MS = 20000;   // SOS'tan önce iptal süresi / time to cancel before SOS
24const float LOW_BAT_V = 3.4;        // 18650 için düşük pil sınırı / low limit for an 18650 cell
25
26enum Mode { WALK, SETTLE, CHECK, ALARM, SOS };
27Mode mode = WALK;
28
29// SOS Mors kodu: artı = ses, eksi = sessizlik, birim 150 ms / SOS in Morse: plus = tone, minus = silence, unit 150 ms
30const int8_t SOS_PATTERN[] = {1, -1, 1, -1, 1, -3, 3, -1, 3, -1, 3, -3, 1, -1, 1, -1, 1, -7};
31const byte SOS_LEN = sizeof(SOS_PATTERN) / sizeof(SOS_PATTERN[0]);
32const unsigned long UNIT_MS = 150;
33
34bool soundOn = true, wet = false, waterAlert = false, waterHigh = false, sosOn = false;
35bool btnDown = false, longFired = false;
36int distanceCm = 999, vibNow = -1;
37int hist[3] = {999, 999, 999};
38byte histIdx = 0, sosStep = 0;
39float gTotal = 1.0, tilt = 45;
40unsigned long lastPing = 0, lastPulse = 0, lastMpu = 0, lastWater = 0, lastBat = 0, lastBeep = 0;
41unsigned long modeStart = 0, waterStart = 0, sosStepStart = 0, btnSince = 0;
42
43void setVib(int v) {                // yalnızca değişince yaz / write only on change
44  if (v != vibNow) { analogWrite(VIB, v); vibNow = v; }
45}
46
47void mpuWrite(byte reg, byte val) {
48  Wire.beginTransmission(MPU);
49  Wire.write(reg);
50  Wire.write(val);
51  Wire.endTransmission();
52}
53
54bool readMpu() {
55  Wire.beginTransmission(MPU);
56  Wire.write(0x3B);                                   // ACCEL_XOUT_H
57  if (Wire.endTransmission(false) != 0) return false;
58  if (Wire.requestFrom(MPU, (uint8_t)6) != 6) return false;
59  float a[3];
60  for (int i = 0; i < 3; i++) {
61    uint8_t hi = Wire.read();
62    uint8_t lo = Wire.read();
63    a[i] = (int16_t)(((uint16_t)hi << 8) | lo) / 4096.0;   // ±8 g: 4096 LSB/g
64  }
65  gTotal = sqrt(a[0] * a[0] + a[1] * a[1] + a[2] * a[2]);
66  tilt = atan2(sqrt(a[1] * a[1] + a[2] * a[2]), fabs(a[0])) * 180.0 / PI;  // 0° dik, 90° yatay / 0° upright, 90° flat
67  return true;
68}
69
70int pingCm() {
71  digitalWrite(TRIG, LOW);  delayMicroseconds(2);
72  digitalWrite(TRIG, HIGH); delayMicroseconds(10);
73  digitalWrite(TRIG, LOW);
74  unsigned long t = pulseIn(ECHO, HIGH, 12000UL);     // 12 ms ≈ 2 m
75  return t == 0 ? 999 : (int)(t / 58);
76}
77
78int median3(int a, int b, int c) {                    // tek tük hatalı ölçümü eler / drops a single bad reading
79  if ((a <= b && b <= c) || (c <= b && b <= a)) return b;
80  if ((b <= a && a <= c) || (c <= a && a <= b)) return a;
81  return c;
82}
83
84// 0 = olay yok, 1 = kısa basış, 2 = uzun basış (2 s) / 0 = nothing, 1 = short press, 2 = long press (2 s)
85byte readButton(unsigned long now) {
86  bool pressed = digitalRead(BUTTON) == LOW;
87  if (pressed && !btnDown) { btnDown = true; longFired = false; btnSince = now; }
88  if (pressed && btnDown && !longFired && now - btnSince >= 2000) { longFired = true; return 2; }
89  if (!pressed && btnDown) {
90    btnDown = false;
91    if (!longFired && now - btnSince >= 30) return 1;  // 30 ms'den kısası sıçramadır / shorter than 30 ms is bounce
92  }
93  return 0;
94}
95
96void setMode(Mode m, unsigned long now) {
97  mode = m;
98  modeStart = now;
99  sosStep = 0;
100  sosStepStart = now;
101  sosOn = false;
102  setVib(0);
103  noTone(BUZZER);
104  digitalWrite(LED, LOW);
105}
106
107void fallUpdate(unsigned long now) {
108  switch (mode) {
109    case WALK:
110      if (gTotal > IMPACT_G) setMode(SETTLE, now);      // sert darbe / hard impact
111      break;
112    case SETTLE:                                        // 1 s sarsıntının bitmesini bekle / wait 1 s for the shaking to stop
113      if (now - modeStart >= 1000) setMode(CHECK, now);
114      break;
115    case CHECK:                                         // 2 s boyunca yatay ve hareketsiz mi? / flat and still for 2 s?
116      if (tilt < LYING_DEG || fabs(gTotal - 1.0) > 0.2) setMode(WALK, now);   // yalnızca bir vuruştu / just a tap
117      else if (now - modeStart >= 2000) setMode(ALARM, now);
118      break;
119    case ALARM:
120      if (tilt < PICKUP_DEG) setMode(WALK, now);        // baston kaldırıldı / the cane was picked up
121      else if (now - modeStart >= CANCEL_MS) setMode(SOS, now);
122      break;
123    default:
124      break;
125  }
126}
127
128void waterUpdate(unsigned long now) {
129  digitalWrite(WATER_PWR, HIGH);                        // yalnızca ölçerken besle: aşınmayı yavaşlatır / power only while measuring: slows corrosion
130  delay(10);
131  int v = analogRead(WATER_SIG);
132  digitalWrite(WATER_PWR, LOW);
133  if (v > WATER_LIMIT && !wet) { wet = true; waterAlert = true; waterStart = now; }   // kurudan ıslağa / dry to wet
134  else if (v < WATER_LIMIT - 100) wet = false;          // histerezis / hysteresis
135}
136
137void walkOutput(unsigned long now) {
138  // Ses kanalı: önce su uyarısı / Sound channel: water alert first
139  if (waterAlert && now - waterStart >= 1800) waterAlert = false;
140  if (waterAlert && now - lastBeep >= 300) {
141    lastBeep = now;
142    waterHigh = !waterHigh;
143    tone(BUZZER, waterHigh ? 1600 : 1000, 250);         // iki tonlu uyarı / two-tone alert
144  }
145
146  // Titreşim kanalı: engel ne kadar yakınsa o kadar sık ve güçlü / Vibration channel: the closer, the faster and stronger
147  if (distanceCm < 2 || distanceCm > FAR_CM) {
148    setVib(0);
149  } else if (distanceCm <= NEAR_CM) {
150    setVib(255);
151    if (soundOn && !waterAlert && now - lastBeep >= 120) { lastBeep = now; tone(BUZZER, 2500, 60); }
152  } else {
153    unsigned long period = map(distanceCm, NEAR_CM, FAR_CM, 120, 900);
154    int strength = map(distanceCm, NEAR_CM, FAR_CM, 255, 150);
155    if (now - lastPulse >= period) {
156      lastPulse = now;
157      if (soundOn && !waterAlert) tone(BUZZER, 2000, 30);
158    }
159    setVib(now - lastPulse < PULSE_MS ? strength : 0);
160  }
161}
162
163void alarmOutput(unsigned long now) {                   // "bastonum düştü" sesi: bulmayı kolaylaştırır / "cane dropped" sound: helps finding it
164  setVib((now - modeStart) % 1000 < 150 ? 255 : 0);
165  if (now - lastBeep >= 1000) { lastBeep = now; tone(BUZZER, 2000, 150); }
166}
167
168void sosOutput(unsigned long now) {
169  if (now - sosStepStart >= (unsigned long)abs(SOS_PATTERN[sosStep]) * UNIT_MS) {
170    sosStep = (sosStep + 1) % SOS_LEN;                  // sonraki adım / next step
171    sosStepStart = now;
172  }
173  bool on = SOS_PATTERN[sosStep] > 0;
174  if (on != sosOn) {
175    sosOn = on;
176    if (on) tone(BUZZER, 3000); else noTone(BUZZER);
177    digitalWrite(LED, on);
178    setVib(on ? 255 : 0);
179  }
180}
181
182void batteryUpdate() {
183  float v = analogRead(BAT) * (5.0 / 1023.0) * 2.0;     // bölücü gerilimi yarıya indirir / the divider halves the voltage
184  Serial.print(F("Pil / Battery: "));
185  Serial.println(v, 2);
186  if (v < LOW_BAT_V && mode == WALK) tone(BUZZER, 800, 400);   // kalın, uzun bip / low, long beep
187}
188
189void setup() {
190  Serial.begin(9600);
191  pinMode(BUTTON, INPUT_PULLUP);
192  pinMode(TRIG, OUTPUT);
193  pinMode(ECHO, INPUT);
194  pinMode(VIB, OUTPUT);
195  pinMode(WATER_PWR, OUTPUT);
196  pinMode(LED, OUTPUT);
197  Wire.begin();
198  mpuWrite(0x6B, 0x00);                                 // MPU6050'yi uyandır / wake the MPU6050
199  mpuWrite(0x1A, 0x03);                                 // 44 Hz filtre / 44 Hz filter
200  mpuWrite(0x1C, 0x10);                                 // ±8 g
201  tone(BUZZER, 1500, 100);                              // açılış sesi / power-on beep
202}
203
204void loop() {
205  unsigned long now = millis();
206
207  byte b = readButton(now);
208  if (b == 2) {
209    setMode(SOS, now);                                  // uzun basış: elle SOS / long press: manual SOS
210  } else if (b == 1) {
211    if (mode == ALARM || mode == SOS) {
212      setMode(WALK, now);                               // alarmı ya da SOS'u iptal et / cancel the alarm or SOS
213    } else {                                            // yürürken (SETTLE/CHECK dahil) sesi aç ya da kapat / while walking (incl. SETTLE/CHECK) sound on or off
214      soundOn = !soundOn;
215      tone(BUZZER, soundOn ? 2000 : 600, 120);
216    }
217  }
218
219  if (now - lastMpu >= 20) {                            // saniyede 50 ölçüm / 50 readings per second
220    lastMpu = now;
221    if (readMpu()) fallUpdate(now);
222  }
223
224  if (mode == WALK || mode == SETTLE || mode == CHECK) {
225    if (now - lastPing >= 60) {
226      lastPing = now;
227      hist[histIdx] = pingCm();
228      histIdx = (histIdx + 1) % 3;
229      distanceCm = median3(hist[0], hist[1], hist[2]);
230    }
231    if (now - lastWater >= 500) { lastWater = now; waterUpdate(now); }
232    walkOutput(now);
233  } else if (mode == ALARM) {
234    alarmOutput(now);
235  } else {
236    sosOutput(now);
237  }
238
239  if (now - lastBat >= 30000) { lastBat = now; batteryUpdate(); }
240}
Functie of instellingWat doet het?
pingCm()Doet één meting; geeft 999 als er binnen 12 ms geen echo komt
median3()Neemt de mediaan van de laatste drie metingen en negeert een enkele foute waarde
readMpu()Leest de zes bytes versnellingsdata en berekent de totale versnelling en kanteling
fallUpdate()Draait de toestandsmachine WALK → SETTLE → CHECK → ALARM → SOS
waterUpdate()Zet de watersensor 10 ms onder spanning, leest hem uit en start een melding bij de overgang van droog naar nat
walkOutput()Maakt trilling op basis van de afstand en de watermelding als tweetoons geluid
sosOutput()Speelt de array SOS_PATTERN stap voor stap af
readButton()Onderscheidt korte (1) en lange (2) drukken en negeert contactdender korter dan 30 ms
IMPACT_G, LYING_DEG, CANCEL_MSValgevoeligheid en annuleertijd; stel ze af met de testsketch

Het SOS-patroon volgt de regels van morsecode: een punt is 1 eenheid, een streep 3 eenheden, met 1 eenheid tussen signalen, 3 tussen letters en 7 tussen herhalingen. Met een eenheid van 150 ms is één SOS-cyclus 34 eenheden, ofwel ongeveer 5,1 seconden. De toon van 3 kHz is met opzet gekozen: het menselijk oor is het gevoeligst tussen 2 en 4 kHz, en kleine passieve buzzers klinken in dat bereik ook het hardst. Voor het verschil tussen actieve en passieve buzzers, zie het artikel Wat is een buzzer?.

Batterij, voeding en looptijd

Een slimme stok wordt de hele dag buiten gebruikt, dus het voedingsontwerp is net zo belangrijk als de sensoren. Laten we het gemiddelde verbruik schatten: de Nano verbruikt ongeveer 20 mA, de HC-SR04 15 mA en de MPU6050 4 mA. De trilmotor verbruikt zo'n 70 mA, maar alleen tijdens pulsen; bij een gemiddelde wandeling is zijn gemiddelde ongeveer 10 mA. De buzzer en de watersensor voegen een paar mA toe. Dat is samen ruwweg 50 mA, oftewel 0,25 W bij 5 V. Een 18650-cel van 2600 mAh bevat bij 3,7 V ongeveer 9,6 Wh; via een boostconverter met 85% rendement komt ongeveer 8 Wh bij de schakeling aan. 8 / 0,25 = 32 uur; rekening houdend met het feit dat je de batterij niet helemaal kunt benutten is een realistisch getal 25–30 uur. Wie hem twee uur per dag gebruikt, laadt de stok ongeveer om de twee weken op. Je kunt zelf rekenen met de tool Batterijduur en over het verschil tussen mAh en Wh lezen in het artikel mAh en Wh.

VoedingsbronGewichtOng. looptijd (50 mA)Oordeel
9V-PP3-batterij (ongeveer 500 mAh), naar VIN45 g8–10 uurNiet aanbevolen: de spanning zakt in als de motor draait, niet oplaadbaar
4 × AA NiMH (2000 mAh), naar de 5V-pinOngeveer 120 g35–40 uurZwaar; bereikt 5,6 V als hij vol is, wat tegen de limiet aan zit
1 × 18650 + TP4056 + MT3608Ongeveer 55 g25–30 uurAanbevolen: licht, opladen via USB, beveiligd
2 × 18650 in serie (7,4 V), naar VINOngeveer 105 g45–50 uurGaat lang mee maar is zwaar, heeft een aparte laadschakeling nodig
Powerbank (10.000 mAh)200 g of meerMeerdere dagenZwaar; de meeste powerbanks schakelen uit bij lage stroom
TP4056 Li-ion-oplaadmodule
TP4056-oplaadmodule: laadt de 18650-cel via USB op tot 4,2 V met 1 A. De versie met de DW01-beveiligingschip beschermt de cel ook tegen overontlading en kortsluiting; de belasting sluit je aan op OUT+ en OUT−.

De aanbevolen voedingsketen is als volgt: de 18650-cel gaat naar de klemmen B+ en B− van de TP4056-module. De lijn van OUT+ van de module loopt via een schuifschakelaar naar de ingang van de MT3608-boostmodule. De uitgang van de MT3608, ingesteld op 5,0 V, voedt de 5V-pin van de Nano, de HC-SR04 en de trilmodule. Om de batterijspanning te meten, wordt direct na de schakelaar een deler van twee weerstanden van 100 kΩ aangesloten met het middelpunt op A0; omdat hij na de schakelaar zit, belast hij de batterij niet als de stok uit staat. De DW01-chip schakelt de cel af bij ongeveer 2,4–2,5 V, maar de code waarschuwt veel eerder door onder 3,4 V elke 30 seconden een lage piep te spelen. Meer details in het artikel TP4056-oplaadmodule.

De uitgang van de MT3608 kan met zijn trimmer tot wel 28 V worden ingesteld, en de module kan af fabriek op elke waarde staan. Meet voordat je hem op de Nano aansluit de uitgang met een multimeter en draai aan de trimmer tot hij 5,0 V aangeeft; een verkeerd ingestelde boostconverter vernietigt het board in seconden. Voed je het board tijdens tests alleen via USB, dan blijft A0 zwevend, is de batterijmeting willekeurig en kun je de piep voor lege batterij horen; dat is normaal.

Behuizing, gewicht en ergonomie

De meeste opvouwbare witte stokken wegen 200–300 g en de gebruiker zwaait ze uren met zijn pols van links naar rechts. Elke gram die je toevoegt wordt vermenigvuldigd met de afstand tot de hand en belast de pols. Bevestig je een doos van 150 g 10 cm onder het handvat, dan is het extra koppel op de pols 150 × 10 = 1,5 kg·cm; dezelfde doos 60 cm lager zou 9 kg·cm geven, zes keer zoveel. Verzamel dus alle elektronica in één doos en plaats die vlak onder het handvat; alleen de watersensor en zijn dunne kabel lopen naar beneden naar de punt. Probeer het totale toegevoegde gewicht onder 150 g te houden.

OnderdeelOng. gewicht
Arduino Nano7 g
HC-SR049 g
MPU6050 (GY-521)2 g
Trilmodule + passieve buzzer5 g
Waterniveausensor en kabel8 g
18650-cel45–48 g
TP4056 + MT3608 + schakelaar8 g
3D-geprinte doos en klemmen40–50 g
Draden, schroeven, klittenband10–15 g
TotaalOngeveer 135–150 g
  • Materiaal: Print de doos in PETG of ABS; PLA kan zacht worden en vervormen in een auto die in de zon staat. Een wanddikte van 1,6–2 mm is genoeg.
  • Montage: Bevestig de doos met twee slangklemmen of een met rubber gevoerde klittenbandband aan de stok. Bij opvouwbare stokken moet de doos boven het eerste scharnier zitten, anders kan de stok niet worden opgevouwen.
  • Sensorvenster: De twee cilinders van de HC-SR04 moeten aan de voorkant uit de doos steken; zet er geen dun plastic of gaas voor, want ultrasoon geluid gaat daar niet doorheen.
  • Regen: Boor een klein afvoergaatje in de onderkant van de doos en leg er een zakje silicagel in. Woon je ergens met veel regen, gebruik dan de waterdichte JSN-SR04T-probe in plaats van de HC-SR04.
  • Knop: Kies een grote knop met een duidelijke klik en plaats hem waar de duim van nature op het handvat rust. Zet er een verhoogde rand van 2 mm omheen zodat hij niet per ongeluk wordt ingedrukt.
  • Aan/uit: De stand van de schakelaar moet met de tast te herkennen zijn; de piep bij het opstarten bevestigt ook dat het apparaat werkt.
  • Oplaadpoort: De USB-aansluiting van de TP4056 moet vanaf de onderkant van de doos bereikbaar zijn en met een rubberen dopje worden afgesloten als hij niet wordt gebruikt.
  • Zichtbaarheid: Reflecterende tape op de zijkanten van de doos helpt bestuurders de stok op te merken als de gebruiker 's avonds de weg oversteekt.

De locatie versturen met ESP32 + GPS

Met een Arduino kan de stok tijdens een SOS alleen mensen in de buurt met geluid waarschuwen. Met een ESP32 en een GPS-module kan de locatie van de stok echter als bericht naar een familielid worden gestuurd. Standaard geeft de NEO-6M-module NMEA-zinnen af op 9600 baud, met één positiebepaling per seconde; de bibliotheek TinyGPSPlus verwerkt ze en geeft je breedtegraad, lengtegraad en het aantal satellieten. Volgens het datasheet duurt de eerste fix na een koude start ongeveer 27 seconden; in de praktijk duurt het buiten van 30 seconden tot enkele minuten, en binnen is er vaak helemaal geen fix. De kleine backupbatterij op de module bewaart de laatste satellietgegevens, zodat bij latere starts binnen enkele seconden een fix komt. Details in het artikel NEO-6M-GPS-module.

NEO-6M-GPS-module met keramische antenne
NEO-6M-GPS-module: de keramische antenne heeft zicht op de hemel nodig, dus hij komt bovenop de doos, uit de buurt van metalen onderdelen. De standaard baudrate is 9600.

Er zijn twee manieren om het bericht te versturen. Voor een schooldemo is het makkelijkst om de ESP32 met de persoonlijke hotspot van de telefoon van de gebruiker te verbinden en het bericht te versturen met een Telegram-bot. Voor een stok die echt op straat werkt, past een SIM800L-GSM-module beter, die niet van de telefoon afhangt: hij verstuurt een sms rechtstreeks met de simkaart erin. De SIM800L heeft 3,4–4,4 V nodig en trekt tijdens het zenden stroompieken tot 2 A, dus voed hem rechtstreeks vanaf de 18650-cel in plaats van via de boostconverter en plaats een condensator van 1.000 µF over zijn voedingspins. Deze module werkt alleen op 2G-netwerken; in landen waar 2G is uitgeschakeld heb je een 4G-module nodig zoals de A7670 of SIM7600. Wil je alles op één board, dan kun je een TTGO T-Call (ESP32 + SIM800L) gebruiken.

C++ (Arduino IDE)
1// ESP32 akıllı baston: engel uyarısı, su ve düşme algılama, SOS'ta GPS konumunu SMS ile gönderme
2// ESP32 smart cane: obstacle alert, water and fall detection, sends the GPS location by SMS on SOS
3// Kütüphane: TinyGPSPlus (Mikal Hart) / Library: TinyGPSPlus (Mikal Hart)
4#include <Wire.h>
5#include <TinyGPSPlus.h>
6
7// Pinler / Pins
8const int TRIG = 18, ECHO = 19;          // ECHO 1 kΩ / 2 kΩ bölücüyle / ECHO via a 1 kΩ / 2 kΩ divider
9const int VIB = 25, BUZZER = 26, BUTTON = 27;
10const int WATER_PWR = 33, WATER_SIG = 34;   // ADC1 pini / ADC1 pin
11const int BAT = 35;                      // 100k/100k bölücü / 100k/100k divider
12const int GPS_RX = 16, GPS_TX = 17;      // NEO-6M TX → 16, RX ← 17
13const int GSM_RX = 13, GSM_TX = 23;      // SIM800L TXD → 13, RXD ← 23
14const byte MPU = 0x68;                   // SDA 21, SCL 22
15
16const char* PHONE = "+905XXXXXXXXX";     // SMS gidecek numara / number to text
17
18const int NEAR_CM = 30, FAR_CM = 150, PULSE_MS = 60;
19const int WATER_LIMIT = 1200;            // 12 bit ölçekte, test ederek bul / on the 12-bit scale, find by testing
20const float IMPACT_G = 2.5, LYING_DEG = 70, PICKUP_DEG = 60;
21const unsigned long CANCEL_MS = 20000, SMS_REPEAT_MS = 300000;   // 5 dakikada bir konum / location every 5 minutes
22
23enum Mode { WALK, SETTLE, CHECK, ALARM, SOS };
24Mode mode = WALK;
25const int8_t SOS_PATTERN[] = {1, -1, 1, -1, 1, -3, 3, -1, 3, -1, 3, -3, 1, -1, 1, -1, 1, -7};
26const int SOS_LEN = sizeof(SOS_PATTERN) / sizeof(SOS_PATTERN[0]);
27const unsigned long UNIT_MS = 150;
28
29TinyGPSPlus gps;
30bool soundOn = true, wet = false, waterAlert = false, waterHigh = false, sosOn = false, smsDue = false;
31bool btnDown = false, longFired = false;
32int distanceCm = 999, vibNow = -1, sosStep = 0, histIdx = 0;
33int hist[3] = {999, 999, 999};
34float gTotal = 1.0, tilt = 45;
35unsigned long lastPing = 0, lastPulse = 0, lastMpu = 0, lastWater = 0, lastBat = 0, lastBeep = 0;
36unsigned long modeStart = 0, waterStart = 0, sosStepStart = 0, btnSince = 0, lastSms = 0;
37
38void setVib(int v) {
39  if (v != vibNow) { analogWrite(VIB, v); vibNow = v; }
40}
41
42void mpuWrite(byte reg, byte val) {
43  Wire.beginTransmission(MPU);
44  Wire.write(reg);
45  Wire.write(val);
46  Wire.endTransmission();
47}
48
49bool readMpu() {
50  Wire.beginTransmission(MPU);
51  Wire.write(0x3B);
52  if (Wire.endTransmission(false) != 0) return false;
53  if (Wire.requestFrom(MPU, (uint8_t)6) != 6) return false;
54  float a[3];
55  for (int i = 0; i < 3; i++) {
56    uint8_t hi = Wire.read();
57    uint8_t lo = Wire.read();
58    a[i] = (int16_t)(((uint16_t)hi << 8) | lo) / 4096.0;   // ±8 g
59  }
60  gTotal = sqrt(a[0] * a[0] + a[1] * a[1] + a[2] * a[2]);
61  tilt = atan2(sqrt(a[1] * a[1] + a[2] * a[2]), fabs(a[0])) * 180.0 / PI;
62  return true;
63}
64
65int pingCm() {
66  digitalWrite(TRIG, LOW);  delayMicroseconds(2);
67  digitalWrite(TRIG, HIGH); delayMicroseconds(10);
68  digitalWrite(TRIG, LOW);
69  unsigned long t = pulseIn(ECHO, HIGH, 12000UL);
70  return t == 0 ? 999 : (int)(t / 58);
71}
72
73int median3(int a, int b, int c) {
74  if ((a <= b && b <= c) || (c <= b && b <= a)) return b;
75  if ((b <= a && a <= c) || (c <= a && a <= b)) return a;
76  return c;
77}
78
79int readButton(unsigned long now) {      // 0 yok, 1 kısa, 2 uzun / 0 none, 1 short, 2 long
80  bool pressed = digitalRead(BUTTON) == LOW;
81  if (pressed && !btnDown) { btnDown = true; longFired = false; btnSince = now; }
82  if (pressed && btnDown && !longFired && now - btnSince >= 2000) { longFired = true; return 2; }
83  if (!pressed && btnDown) {
84    btnDown = false;
85    if (!longFired && now - btnSince >= 30) return 1;
86  }
87  return 0;
88}
89
90void feedGps() {                          // NMEA cümlelerini çöz / parse the NMEA sentences
91  while (Serial2.available()) gps.encode(Serial2.read());
92}
93
94// SIM800L'den belirli bir yanıtı bekle / wait for a given reply from the SIM800L
95bool waitFor(const char* token, unsigned long timeoutMs) {
96  String buf;
97  unsigned long start = millis();
98  while (millis() - start < timeoutMs) {
99    while (Serial1.available()) {
100      buf += (char)Serial1.read();
101      if (buf.indexOf(token) >= 0) return true;
102      if (buf.length() > 200) buf.remove(0, 100);
103    }
104    feedGps();                            // beklerken GPS'i kaçırma / keep reading GPS while waiting
105  }
106  return false;
107}
108
109bool sendSms(const String& text) {
110  Serial1.println("AT");                  // ilk AT baud hızını eşler / the first AT syncs the baud rate
111  if (!waitFor("OK", 1000)) {
112    Serial1.println("AT");
113    if (!waitFor("OK", 1000)) return false;
114  }
115  Serial1.println("AT+CMGF=1");           // metin modu / text mode
116  if (!waitFor("OK", 1000)) return false;
117  Serial1.print("AT+CMGS=\"");
118  Serial1.print(PHONE);
119  Serial1.println("\"");
120  if (!waitFor(">", 5000)) return false;  // mesaj istemi / message prompt
121  Serial1.print(text);
122  Serial1.write(26);                      // Ctrl+Z: gönder / Ctrl+Z: send
123  return waitFor("+CMGS", 20000);         // şebeke onayı / network confirmation
124}
125
126String sosText() {                        // SMS'te Türkçe harf kullanma / no Turkish letters in the SMS
127  String s = "SOS! Akilli baston yardim cagrisi. ";
128  if (gps.location.isValid()) {
129    s += "Konum: https://maps.google.com/?q=";
130    s += String(gps.location.lat(), 6) + "," + String(gps.location.lng(), 6);
131    s += " (" + String(gps.location.age() / 1000) + " sn once, " + String(gps.satellites.value()) + " uydu)";
132  } else {
133    s += "GPS konumu henuz yok.";
134  }
135  return s;
136}
137
138void setMode(Mode m, unsigned long now) {
139  mode = m;
140  modeStart = now;
141  sosStep = 0;
142  sosStepStart = now;
143  sosOn = false;
144  setVib(0);
145  noTone(BUZZER);
146  if (m == SOS) { smsDue = true; lastSms = now; }
147}
148
149void fallUpdate(unsigned long now) {
150  if (mode == WALK && gTotal > IMPACT_G) setMode(SETTLE, now);
151  else if (mode == SETTLE && now - modeStart >= 1000) setMode(CHECK, now);
152  else if (mode == CHECK) {
153    if (tilt < LYING_DEG || fabs(gTotal - 1.0) > 0.2) setMode(WALK, now);
154    else if (now - modeStart >= 2000) setMode(ALARM, now);
155  } else if (mode == ALARM) {
156    if (tilt < PICKUP_DEG) setMode(WALK, now);
157    else if (now - modeStart >= CANCEL_MS) setMode(SOS, now);
158  }
159}
160
161void waterUpdate(unsigned long now) {
162  digitalWrite(WATER_PWR, HIGH);
163  delay(10);
164  int v = analogRead(WATER_SIG);          // 0–4095
165  digitalWrite(WATER_PWR, LOW);
166  if (v > WATER_LIMIT && !wet) { wet = true; waterAlert = true; waterStart = now; }
167  else if (v < WATER_LIMIT - 400) wet = false;
168}
169
170void walkOutput(unsigned long now) {
171  if (waterAlert && now - waterStart >= 1800) waterAlert = false;
172  if (waterAlert && now - lastBeep >= 300) {
173    lastBeep = now;
174    waterHigh = !waterHigh;
175    tone(BUZZER, waterHigh ? 1600 : 1000, 250);
176  }
177  if (distanceCm < 2 || distanceCm > FAR_CM) {
178    setVib(0);
179  } else if (distanceCm <= NEAR_CM) {
180    setVib(255);
181    if (soundOn && !waterAlert && now - lastBeep >= 120) { lastBeep = now; tone(BUZZER, 2500, 60); }
182  } else {
183    unsigned long period = map(distanceCm, NEAR_CM, FAR_CM, 120, 900);
184    int strength = map(distanceCm, NEAR_CM, FAR_CM, 255, 150);
185    if (now - lastPulse >= period) {
186      lastPulse = now;
187      if (soundOn && !waterAlert) tone(BUZZER, 2000, 30);
188    }
189    setVib(now - lastPulse < PULSE_MS ? strength : 0);
190  }
191}
192
193void sosOutput(unsigned long now) {
194  if (smsDue || now - lastSms >= SMS_REPEAT_MS) {      // girişte ve 5 dakikada bir / on entry and every 5 minutes
195    smsDue = false;
196    lastSms = now;
197    noTone(BUZZER);
198    bool ok = sendSms(sosText());
199    Serial.println(ok ? "SMS gonderildi / SMS sent" : "SMS gonderilemedi / SMS failed");
200    sosStepStart = millis();
201    sosOn = false;
202  }
203  if (now - sosStepStart >= (unsigned long)abs(SOS_PATTERN[sosStep]) * UNIT_MS) {
204    sosStep = (sosStep + 1) % SOS_LEN;
205    sosStepStart = now;
206  }
207  bool on = SOS_PATTERN[sosStep] > 0;
208  if (on != sosOn) {
209    sosOn = on;
210    if (on) tone(BUZZER, 3000); else noTone(BUZZER);
211    setVib(on ? 255 : 0);
212  }
213}
214
215void setup() {
216  Serial.begin(115200);
217  Serial2.begin(9600, SERIAL_8N1, GPS_RX, GPS_TX);    // NEO-6M varsayılanı 9600 baud / NEO-6M default is 9600 baud
218  Serial1.begin(9600, SERIAL_8N1, GSM_RX, GSM_TX);    // SIM800L
219  pinMode(BUTTON, INPUT_PULLUP);
220  pinMode(TRIG, OUTPUT);
221  pinMode(ECHO, INPUT);
222  pinMode(WATER_PWR, OUTPUT);
223  Wire.begin(21, 22);
224  mpuWrite(0x6B, 0x00);
225  mpuWrite(0x1A, 0x03);
226  mpuWrite(0x1C, 0x10);
227  tone(BUZZER, 1500, 100);
228}
229
230void loop() {
231  unsigned long now = millis();
232  feedGps();
233
234  int b = readButton(now);
235  if (b == 2) setMode(SOS, now);
236  else if (b == 1) {
237    if (mode == ALARM || mode == SOS) setMode(WALK, now);              // alarmı ya da SOS'u iptal et / cancel the alarm or SOS
238    else { soundOn = !soundOn; tone(BUZZER, soundOn ? 2000 : 600, 120); }   // yürürken: ses aç/kapat / while walking: sound on/off
239  }
240
241  if (now - lastMpu >= 20) {
242    lastMpu = now;
243    if (readMpu()) fallUpdate(now);
244  }
245
246  if (mode == WALK || mode == SETTLE || mode == CHECK) {
247    if (now - lastPing >= 60) {
248      lastPing = now;
249      hist[histIdx] = pingCm();
250      histIdx = (histIdx + 1) % 3;
251      distanceCm = median3(hist[0], hist[1], hist[2]);
252    }
253    if (now - lastWater >= 500) { lastWater = now; waterUpdate(now); }
254    walkOutput(now);
255  } else if (mode == ALARM) {
256    setVib((now - modeStart) % 1000 < 150 ? 255 : 0);
257    if (now - lastBeep >= 1000) { lastBeep = now; tone(BUZZER, 2000, 150); }
258  } else {
259    sosOutput(now);
260  }
261
262  if (now - lastBat >= 30000) {
263    lastBat = now;
264    float v = analogReadMilliVolts(BAT) * 2 / 1000.0;  // kalibreli mV okuma / calibrated mV reading
265    Serial.printf("Pil / Battery: %.2f V, GPS: %s\n", v, gps.location.isValid() ? "var / fix" : "yok / no fix");
266    if (v < 3.4 && mode == WALK) tone(BUZZER, 800, 400);
267  }
268}

De code gebruikt dezelfde toestandsmachine als de Arduino-versie; het verschil zit in de SOS. Zodra de SOS begint, stuurt sendSms() de SIM800L achtereenvolgens de commando's AT, AT+CMGF=1 voor tekstmodus en AT+CMGS="nummer", wacht op de prompt ">", schrijft het bericht en verstuurt het met Ctrl+Z (26). De locatie verschijnt in het bericht als kaartlink, die op een telefoon de kaartenapp opent als je erop tikt. Heeft de GPS nog geen fix, dan staat dat in het bericht, en terwijl de SOS doorgaat wordt de locatie elke 5 minuten opnieuw verstuurd. De sms-tekst vermijdt met opzet Turkse letters: tekens als ş, ğ en ı staan niet in het standaard GSM-alfabet en worden op sommige telefoons verminkt weergegeven. Tijdens het verzenden kan de code tot 30 seconden wachten; na het opstarten heeft de SIM800L ook 10–30 seconden nodig om zich op het netwerk te registreren.

Slimme stok met de Raspberry Pi Pico (MicroPython)

Op de Raspberry Pi Pico wordt dezelfde logica met MicroPython gebouwd. time_pulse_us() werkt als pulseIn() op de Arduino en geeft een negatieve waarde terug als er geen echo komt. PWM-uitgangen stel je in met de 16-bits duty_u16(); voor de trilmotor betekent 65535 vol vermogen. De zes bytes van de MPU6050 worden in één keer gelezen met i2c.readfrom_mem() en omgezet naar getallen met teken door 65536 af te trekken van waarden boven 32767. De pins van de Pico werken ook op 3,3 V, dus de ECHO-deler is hier ook onmisbaar. Voed je hem op batterij, geef dan de 5 V-uitgang van de MT3608 aan de VSYS-pin; de HC-SR04 wordt van dezelfde 5 V-rail gevoed. Met de Pico W, die Wi-Fi heeft, kun je de status van de stok ook tonen op een webpagina.

MicroPython
1from machine import Pin, PWM, I2C, ADC, time_pulse_us
2import time, math
3
4# Pinler: ECHO 1 kΩ / 2 kΩ bölücüyle / Pins: ECHO via a 1 kΩ / 2 kΩ divider
5trig, echo = Pin(2, Pin.OUT), Pin(3, Pin.IN)
6i2c = I2C(0, sda=Pin(4), scl=Pin(5), freq=400000)    # MPU6050
7button = Pin(14, Pin.IN, Pin.PULL_UP)
8vib = PWM(Pin(15))
9vib.freq(1000)
10buzzer = PWM(Pin(16))
11water_pwr, water_sig = Pin(22, Pin.OUT), ADC(26)
12bat = ADC(28)                                         # 100k/100k bölücü / 100k/100k divider
13
14NEAR_CM, FAR_CM, PULSE_MS = 30, 150, 60
15WATER_LIMIT = 20000                                   # 16 bit ölçekte, test ederek bul / on the 16-bit scale, find by testing
16IMPACT_G, LYING_DEG, PICKUP_DEG, CANCEL_MS = 2.5, 70, 60, 20000
17SOS = [1, -1, 1, -1, 1, -3, 3, -1, 3, -1, 3, -3, 1, -1, 1, -1, 1, -7]   # Mors kodu / Morse code
18UNIT_MS = 150
19MPU = 0x68
20
21i2c.writeto_mem(MPU, 0x6B, b'\x00')                   # uyandır / wake up
22i2c.writeto_mem(MPU, 0x1A, b'\x03')                   # 44 Hz filtre / 44 Hz filter
23i2c.writeto_mem(MPU, 0x1C, b'\x10')                   # ±8 g
24
25beep_off = None
26
27def tone(freq, ms=0):                                 # ms = 0: noTone'a kadar çalar / plays until quiet()
28    global beep_off
29    buzzer.freq(freq)
30    buzzer.duty_u16(32768)                            # %50 doluluk / 50% duty
31    beep_off = time.ticks_add(time.ticks_ms(), ms) if ms else None
32
33def quiet():
34    global beep_off
35    buzzer.duty_u16(0)
36    beep_off = None
37
38def ping_cm():
39    trig.low(); time.sleep_us(2)
40    trig.high(); time.sleep_us(10)                    # 10 µs tetik / 10 µs trigger
41    trig.low()
42    t = time_pulse_us(echo, 1, 12000)                 # yankı yoksa negatif / negative if no echo
43    return 999 if t < 0 else t // 58
44
45def read_mpu():
46    d = i2c.readfrom_mem(MPU, 0x3B, 6)
47    a = []
48    for i in (0, 2, 4):
49        v = (d[i] << 8) | d[i + 1]
50        if v > 32767:
51            v -= 65536                                # işaretli 16 bit / signed 16-bit
52        a.append(v / 4096)                            # ±8 g: 4096 LSB/g
53    g = math.sqrt(a[0] * a[0] + a[1] * a[1] + a[2] * a[2])
54    tilt = math.atan2(math.sqrt(a[1] * a[1] + a[2] * a[2]), abs(a[0])) * 180 / math.pi
55    return g, tilt
56
57mode, mode_t = "walk", time.ticks_ms()
58sound_on, wet, water_alert, water_high = True, False, False, False
59hist, hist_i, dist = [999, 999, 999], 0, 999
60sos_i, sos_t, sos_on = 0, 0, None
61btn_down, long_fired, btn_t = False, False, 0
62last_ping = last_pulse = last_mpu = last_water = last_bat = last_beep = water_t = time.ticks_ms()
63
64def set_mode(m):
65    global mode, mode_t, sos_i, sos_t, sos_on
66    mode, mode_t = m, time.ticks_ms()
67    sos_i, sos_t, sos_on = 0, mode_t, None
68    vib.duty_u16(0)
69    quiet()
70
71def button_event(now):                                # 0 yok, 1 kısa, 2 uzun / 0 none, 1 short, 2 long
72    global btn_down, long_fired, btn_t
73    pressed = button.value() == 0
74    if pressed and not btn_down:
75        btn_down, long_fired, btn_t = True, False, now
76    if pressed and btn_down and not long_fired and time.ticks_diff(now, btn_t) >= 2000:
77        long_fired = True
78        return 2
79    if not pressed and btn_down:
80        btn_down = False
81        if not long_fired and time.ticks_diff(now, btn_t) >= 30:
82            return 1
83    return 0
84
85tone(1500, 100)                                       # açılış sesi / power-on beep
86while True:
87    now = time.ticks_ms()
88    if beep_off is not None and time.ticks_diff(now, beep_off) >= 0:
89        quiet()
90
91    b = button_event(now)
92    if b == 2:
93        set_mode("sos")                               # uzun basış: elle SOS / long press: manual SOS
94    elif b == 1:
95        if mode in ("alarm", "sos"):
96            set_mode("walk")                          # alarmı ya da SOS'u iptal et / cancel the alarm or SOS
97        else:                                         # yürürken: ses aç/kapat / while walking: sound on/off
98            sound_on = not sound_on
99            tone(2000 if sound_on else 600, 120)
100
101    if time.ticks_diff(now, last_mpu) >= 20:          # 50 Hz
102        last_mpu = now
103        g, tilt = read_mpu()
104        el = time.ticks_diff(now, mode_t)
105        if mode == "walk" and g > IMPACT_G:
106            set_mode("settle")
107        elif mode == "settle" and el >= 1000:
108            set_mode("check")
109        elif mode == "check":
110            if tilt < LYING_DEG or abs(g - 1) > 0.2:
111                set_mode("walk")                      # yalnızca bir vuruş / just a tap
112            elif el >= 2000:
113                set_mode("alarm")
114        elif mode == "alarm":
115            if tilt < PICKUP_DEG:
116                set_mode("walk")                      # baston kaldırıldı / cane picked up
117            elif el >= CANCEL_MS:
118                set_mode("sos")
119
120    if mode in ("walk", "settle", "check"):
121        if time.ticks_diff(now, last_ping) >= 60:
122            last_ping = now
123            hist[hist_i] = ping_cm()
124            hist_i = (hist_i + 1) % 3
125            dist = sorted(hist)[1]                    # 3 ölçümün ortancası / median of 3
126        if time.ticks_diff(now, last_water) >= 500:
127            last_water = now
128            water_pwr.on()
129            time.sleep_ms(10)
130            w = water_sig.read_u16()
131            water_pwr.off()
132            if w > WATER_LIMIT and not wet:
133                wet, water_alert, water_t = True, True, now
134            elif w < WATER_LIMIT - 5000:
135                wet = False
136        if water_alert and time.ticks_diff(now, water_t) >= 1800:
137            water_alert = False
138        if water_alert and time.ticks_diff(now, last_beep) >= 300:
139            last_beep = now
140            water_high = not water_high
141            tone(1600 if water_high else 1000, 250)   # iki tonlu su uyarısı / two-tone water alert
142        if dist < 2 or dist > FAR_CM:
143            vib.duty_u16(0)
144        elif dist <= NEAR_CM:
145            vib.duty_u16(65535)
146            if sound_on and not water_alert and time.ticks_diff(now, last_beep) >= 120:
147                last_beep = now
148                tone(2500, 60)
149        else:
150            period = 120 + (dist - NEAR_CM) * 780 // (FAR_CM - NEAR_CM)        # 120–900 ms
151            strength = 65535 - (dist - NEAR_CM) * 27000 // (FAR_CM - NEAR_CM)  # %100–%59
152            if time.ticks_diff(now, last_pulse) >= period:
153                last_pulse = now
154                if sound_on and not water_alert:
155                    tone(2000, 30)
156            vib.duty_u16(strength if time.ticks_diff(now, last_pulse) < PULSE_MS else 0)
157    elif mode == "alarm":
158        vib.duty_u16(65535 if time.ticks_diff(now, mode_t) % 1000 < 150 else 0)
159        if time.ticks_diff(now, last_beep) >= 1000:
160            last_beep = now
161            tone(2000, 150)                           # bulma sesi / locator beep
162    else:
163        if time.ticks_diff(now, sos_t) >= abs(SOS[sos_i]) * UNIT_MS:
164            sos_i = (sos_i + 1) % len(SOS)
165            sos_t = now
166        on = SOS[sos_i] > 0
167        if on != sos_on:
168            sos_on = on
169            if on:
170                tone(3000)
171            else:
172                quiet()
173            vib.duty_u16(65535 if on else 0)
174
175    if time.ticks_diff(now, last_bat) >= 30000:
176        last_bat = now
177        v = bat.read_u16() * 3.3 / 65535 * 2
178        print("Pil / Battery:", round(v, 2), "V")
179        if v < 3.4 and mode == "walk":
180            tone(800, 400)
181
182    time.sleep_ms(2)

Tips voor een presentatie op een techniekwedstrijd

De slimme stok is een bekend verschijnsel op techniekwedstrijden en schoolwedstrijden (meer ideeën vind je in ons artikel projectideeën voor techniekwedstrijden), dus wat de jury imponeert is niet dat de stok trilt maar hoe goed je het probleem definieert en hoe eerlijk je je oplossing meet. De sterkste projecten beginnen met een gesprek met een slechtziende of blinde persoon of een belangenorganisatie: als je van hen hoort welke obstakels een echt probleem zijn, of ze trilling of geluid verkiezen en hoe zwaar de stok mag zijn, krijgt je project zowel richting als een krachtig verhaal.

  1. Probleem: De witte stok kan obstakels boven heuphoogte niet detecteren en plassen blijven onopgemerkt. Leg het uit met concrete voorbeelden uit je interviews.
  2. Doel: Een toevoeging ontwerpen die obstakels op lichaams- en hoofdhoogte minstens 1 seconde van tevoren met trilling meldt, zonder het gewicht van de stok of de manier waarop hij wordt gebruikt veel te veranderen.
  3. Methode: Toon je sensorkeuze (HC-SR04, JSN-SR04T, ToF) met je redenen, de montagehoek met de berekening en de trilmapping met zijn formule.
  4. Resultaten: Presenteer de resultaten van de onderstaande tests in tabellen en grafieken en neem ook de gevallen op waarin het misging.
  5. Conclusie en aanbevelingen: Geef duidelijk aan wat het project oplost, zijn beperkingen (glas, zachte oppervlakken, regen, detecteren van de val van de stok in plaats van die van de gebruiker) en de volgende stap.
TestHoe je het doetWaarde om vast te leggen
AfstandsnauwkeurigheidTelkens 10 metingen op 30, 60, 100 en 150 cm van een muurGemiddelde fout (cm) en grootste afwijking
Soorten obstakelsMuur, persoon, paal van 5 cm, struik, glazen deur, stoffen gordijnHoe vaak van de 10 elk obstakel wordt gedetecteerd
ReactietijdSlowmotionvideo met de telefoon: het obstakel verschijnt en de eerste trillingVertraging in milliseconden
WaterdetectieDompel de punt in 0,5, 1, 2 en 3 cm waterVanaf welke diepte hij waarschuwt
Valdetectie20 keer laten vallen en 100 tikken op de grondAantal juiste en valse alarmen
BatterijduurLaat hem draaien vanaf een volle lading tot hij uitschakeltTijd in uren en eindspanning
Gewicht en balansWeeg hem op een keukenweegschaal, meet de afstand vanaf het handvatToegevoegd gewicht (g) en koppel (kg·cm)
Voer gebruikerstests uit met vrijwilligers met een blinddoek in een lege, veilige gang, altijd met een helper naast hen; test nooit in de buurt van verkeer. Maak voor elke test met mensen een toestemmingsformulier en controleer welke ethische documenten de wedstrijdregels vereisen. De jury zal heel waarschijnlijk vragen "ziet hij glazen deuren?", "wat gebeurt er in de regen?" en "wat gebeurt er als de batterij leeg is?"; bereid je antwoorden vooraf voor met de gegevens uit je testtabellen.

Ideeën voor verbeteringen

  • Waarschuwing voor trappen en gaten: Een tweede HC-SR04 die schuin naar beneden en naar voren wijst, ziet normaal de grond op een constante afstand; wordt de meting plotseling langer, dan is er een trede omlaag of een gat voor je.
  • Spraakberichten: Gebruik een DFPlayer Mini om opgenomen zinnen als "obstakel voor je", "water" of "batterij bijna leeg" in een oortje af te spelen in plaats van piepjes.
  • Telefoon-app: Gebruik de Bluetooth BLE van de ESP32 om het batterijniveau en de instellingen op een telefoon te tonen en het bereik daar aan te passen.
  • Richting: Plaats twee afzonderlijke motoren links en rechts in het handvat en laat met trilling zien aan welke kant het obstakel zit.
  • Slaapstand: Schakel de sensoren uit als de MPU6050 ziet dat de stok al minuten niet is bewogen; met ESP32 deep sleep wordt de batterijduur vervielfacht.
  • Zichtbaarheid 's nachts: Gebruik een LDR om na het donker een led aan de punt van de stok te laten knipperen, zodat bestuurders de gebruiker van ver opmerken.

Veelgemaakte fouten en hoe je ze oplost

VerschijnselWaarschijnlijke oorzaakOplossing
De stok trilt non-stopDe sensor wijst naar de grond of naar de stok zelfVerhoog de montagehoek en houd de ruimte voor de sensor vrij
Af en toe trilling zonder redenEen enkele foute echo of een andere ultrasoonbron in de buurtHet mediaanfilter zit er al in; neem zo nodig de mediaan van 5 metingen
De motor draait niet bij grote afstandenDe PWM-waarde ligt onder de aanloopdrempel van de motorHoud de minimale sterkte boven 150 en bevestig de motor met rubber
De Arduino herstart als de motor draaitDe motorstroom trekt de voeding omlaag, of er is geen diodeGebruik een kant-en-klare module en voeg een condensator van 100 µF toe aan de voeding
De MPU6050 leest altijd 0 of een vaste waardeSDA en SCL verwisseld, adres is 0x69, of de chip slaaptZoek het adres met een I2C-scanner en controleer of 0 naar register 0x6B wordt geschreven
Valse alarmen door tikken op de grondIMPACT_G is laag en de kantelhoekdrempel ligt dicht bij de loophoekMeet de kanteling met de testsketch en verhoog LYING_DEG naar 75
De watermelding stopt nooit of klinkt nooitVerkeerde drempel of geoxideerde banenMeet de droge en natte waarden opnieuw en vervang zo nodig de sensor
De buzzer is stil of speelt altijd dezelfde toonEr zit een actieve buzzer inGebruik een passieve buzzer voor tone()
De sms wordt niet verstuurdDe SIM800L is niet geregistreerd op het netwerk, de voeding is zwak of de pincode van de simkaart is ingeschakeldControleer of de led van de module elke 3 seconden knippert, schakel de pincode uit en voed de module vanaf de 18650
Test bij het oplossen van problemen de onderdelen één voor één: gebruik eerst de testsketch om te controleren of de afstand, de watersensorwaarde en de kanteling kloppen en upload dan de volledige code. Reageert de MPU6050 niet, dan vindt de scannersketch in het artikel Wat is I2C zijn adres. Reset het board zichzelf als de trilling begint, dan is de oorzaak bijna altijd de voeding; het artikel Arduino blijft resetten lost dit probleem stap voor stap op.

Een slimme stok brengt afstandsmeting, haptische feedback, gebeurtenisdetectie met een bewegingssensor en voedingsontwerp samen in één project, en omdat het een echte behoefte aanpakt, is het een van de zinvolste Arduino-projecten die je kunt bouwen. Begin met de basiscode in deze gids, vul je testtabellen in en voeg dan de water-, val- en GPS-lagen één voor één toe. In de BlueGrays-app vind je afstandsmeting met de HC-SR04, een parkeersensor, geluid met een buzzer en ESP32-meldingsprojecten stap voor stap met schakelschema's en kant-en-klare code, zodat je elk onderdeel van je stok eerst afzonderlijk kunt uitproberen.

Veelgestelde vragen

Hoe werkt een slimme blindenstok?

Een HC-SR04-ultrasoonsensor bij het handvat zendt geluidsgolven uit en berekent de afstand tot het obstakel voor je uit de tijd die de echo nodig heeft om terug te komen. Op basis van die afstand stuurt de Arduino een trilmotor in het handvat aan: hoe dichterbij het obstakel, hoe sneller en sterker de trilling. In geavanceerdere versies detecteert een watersensor aan de punt plassen en merkt een MPU6050 op wanneer de stok valt.

Welke componenten heb ik nodig voor een slimme Arduino-stok?

Voor de basisversie volstaan een Arduino Nano, een HC-SR04-ultrasoonsensor, een trilmotormodule, een passieve buzzer en jumperdraden. De volledige versie voegt een waterniveausensor, een MPU6050, een knop, een 18650-cel met TP4056-oplaadmodule en MT3608-boostmodule toe. Om de locatie te versturen heb je een ESP32, een NEO-6M-GPS en een SIM800L-GSM-module nodig.

Hoe ver kan een slimme stok obstakels detecteren?

De HC-SR04 kan van 2 tot 400 cm meten, maar een stok gebruikt meestal een limiet van 150 cm. Voor iemand die ongeveer 1 meter per seconde loopt, is dat een waarschuwing van 1,5 seconde voordat hij het obstakel bereikt. Een veel groter bereik leidt tot constante trilling op drukke plekken en tot gebruikers die de waarschuwingen negeren.

Hoe weet een slimme stok dat hij is gevallen?

De MPU6050-versnellingsmeter wordt 50 keer per seconde uitgelezen. Blijft de stok na een klap boven 2,5 g 2 seconden plat en bewegingloos liggen, dan wordt hij als gevallen beschouwd en begint een zoekpiep. Wordt de stok binnen 20 seconden niet opgepakt of de knop niet ingedrukt, dan klinkt een SOS; de ESP32-versie stuurt op dat moment de locatie per sms.

Hoe lang werkt een slimme Arduino-stok op een batterij?

De schakeling verbruikt gemiddeld ongeveer 50 mA. Een enkele 18650-cel van 2600 mAh met TP4056-oplaadmodule en MT3608-boostmodule houdt hem ongeveer 25–30 uur aan de praat, wat bij twee uur gebruik per dag neerkomt op ongeveer twee weken. Een 9V-PP3-batterij gaat maar 8–10 uur mee en wordt afgeraden omdat de spanning inzakt als de motor draait.

Kan ik GPS-locatie delen aan een slimme stok toevoegen?

Ja. Gebruik je een ESP32 in plaats van een Arduino en voeg je een NEO-6M-GPS-module toe, dan kun je de breedte- en lengtegraad van de stok uitlezen. Met een SIM800L-GSM-module gaat de locatie tijdens een SOS als kaartlink per sms naar een familielid; is er Wi-Fi, dan werkt ook een Telegram-bot. GPS werkt buiten, maar krijgt binnen meestal geen fix.

Alle projecten bekijken
Afstand meten met HC-SR04 (Serial-weergave)
AR-27Beginner

Afstand meten met HC-SR04 (Serial-weergave)

De HC-SR04-sensor werkt net als een vleermuis die in het donker zijn weg vindt: hij stuurt een geluid uit dat je niet kunt horen, luistert naar de echo en meet hoe ver het object voor hem staat.

4.6(50)
82
Een buzzer gebruiken
AR-13Beginner

Een buzzer gebruiken

Heb je je ooit afgevraagd hoe een deurbel of alarm geluid maakt? De Arduino laat een kleine buzzer met korte tussenpozen piepen: piep, pauze, piep, pauze.

4.7(92)
170
Frequentie instellen met een buzzer
AR-14Gemiddeld

Frequentie instellen met een buzzer

Met vier knoppen bestuur je het geluid van een buzzer: één start het geluid, één stopt het en de andere twee maken het hoger of lager.

4.6(69)
120
Parkeersensor met HC-SR04
AR-28Gemiddeld
Premium

Parkeersensor met HC-SR04

Een minversie van de parkeersensor van een auto: hoe dichterbij iets komt, hoe sneller de pieptonen.

4.8(64)
86
ESP32 HC-SR04 ultrasone afstandssensor
ES-14Gemiddeld

ESP32 HC-SR04 ultrasone afstandssensor

De ultrasone sensor HC-SR04 meet afstand door te timen hoe lang zijn geluidspuls erover doet om van een voorwerp terug te kaatsen (time of flight). In dit project stuurt de ESP32 een puls van 10 microseconden naar de TRIG-pin en leest hij de echotijd met pulseIn() van de ECHO-pin. De afstand wordt in cm getoond op een 16x2 I2C-LCD. De HC-SR04 werkt op 5V, dus de ECHO-pin heeft een spanningsdeler nodig, anders raakt de 3,3V-GPIO van de ESP32 beschadigd.

4.9(29)
48
ESP32 parkeersensor (HC-SR04 + 5-ledbalk + buzzer + OLED)
ES-38Gevorderd
Premium

ESP32 parkeersensor (HC-SR04 + 5-ledbalk + buzzer + OLED)

De ESP32-versie van een parkeersensor voor auto's! De HC-SR04-ultrasoonsensor meet de afstand tot het voorwerp ervoor. Naarmate je dichterbij komt, vult een balk van 5 leds zich (groen → geel → rood) en piept de buzzer sneller. Heel dichtbij (onder 10 cm) klinkt een continu alarm en branden alle leds. Het SSD1306 OLED-display toont de live afstand in cm in grote tekst, plus een statusbericht.

14
Obstakelvermijdende robot
AR-81Gevorderd
Premium

Obstakelvermijdende robot

Zin om een slim voertuig te bouwen dat zelf zijn weg vindt? De obstakelvermijdende robot scant voortdurend zijn omgeving dankzij de ultrasone sensor voorop.

5.0(38)
49
ESP32-bewegingsalarm (PIR + buzzer + LED + Telegram)
ES-41Gevorderd
Premium

ESP32-bewegingsalarm (PIR + buzzer + LED + Telegram)

Een slim beveiligingsalarm: als de PIR-sensor beweging detecteert, gaat de buzzer af, licht de LED op en krijgt de eigenaar direct een Telegram-melding. Een afkoeltijd van 30 seconden beperkt hoe vaak het alarm zich herhaalt; valse detecties van de PIR-sensor filtert dit niet weg. Gebruik het thuis, in een garage, een berging of een studeerkamer.

9