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.

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.
| Onderdeel | Taak | Opmerking |
|---|---|---|
| Arduino Nano (Uno voor prototypes) | Meet, beslist en stuurt de motor en buzzer aan | De Nano past bij een stok omdat hij klein en licht is |
| HC-SR04-ultrasoonsensor | Meet de afstand tot het obstakel voor je | 5 V, ongeveer 15 mA; JSN-SR04T voor gebruik in de regen |
| Trilmotormodule | Geeft het obstakel door aan de hand via trilling | Kant-en-klare module met transistor en diode |
| Passieve buzzer | Meldingen voor water, val, SOS en batterij | Passief, dus hij kan verschillende tonen spelen |
| Waterniveausensor | Waarschuwt als de punt van de stok in water komt | 1–2 cm boven de punt, alleen onder spanning tijdens het meten |
| MPU6050 (GY-521) | Detecteert dat de stok is gevallen en plat ligt | I2C, adres 0x68 |
| Drukknop | Geluid aan/uit, alarm annuleren, SOS bij lang indrukken | Onder de duim geplaatst |
| 18650-cel + TP4056 + MT3608 | Mobiele voeding, opladen via USB, boost naar 5 V | Gebruik een beschermde TP4056 (met DW01) |
| 2 weerstanden van 100 kΩ | Deler om de batterijspanning te meten | Het middelpunt gaat naar A0 |
| Schakelaar en behuizing | Aan/uit en bescherming | 3D-geprint of een klein projectdoosje |




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 afstand | Typische obstakels die hij opmerkt |
|---|---|---|
| 0° | Ongeveer 55–95 cm | Banken, afvalbakken, de carrosserie van een geparkeerde auto |
| 15° | Ongeveer 95–135 cm | De romp van een persoon, fietsstuur, de laadbak van een vrachtwagen |
| 25° | Ongeveer 120–170 cm | Borden, 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.
| Sensor | Bereik | Voordelen | Nadelen |
|---|---|---|---|
| HC-SR04 | 2–400 cm | Goedkoop, eenvoudig, brede kegel | Niet waterdicht, heeft moeite met zachte oppervlakken |
| JSN-SR04T | Ongeveer 25–450 cm | Waterdichte probe, werkt in de regen | Ziet niets dichterbij dan 25 cm, duurder |
| VL53L1X (laser-ToF) | Tot 4 m | Klein, licht, smalle bundel | Bereik daalt in zonlicht, 3,3 V I2C |
| Sharp GP2Y0A02 (infrarood) | 20–150 cm | Analoge uitgang, eenvoudige code | Laat zich foppen door donkere en glimmende oppervlakken, verbruikt ongeveer 33 mA |
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.
| Afstand | Pulsinterval | Trilsterkte (PWM) | Betekenis voor de gebruiker |
|---|---|---|---|
| Verder dan 150 cm | Geen trilling | 0 | De weg is vrij |
| 150 cm | 900 ms | 150 | Er is een obstakel voor je |
| 100 cm | 575 ms | 194 | Obstakel nadert, wees voorzichtig |
| 60 cm | 315 ms | 229 | Vertraag, maak je klaar om van richting te veranderen |
| 40 cm | 185 ms | 247 | Heel dichtbij |
| 30 cm of dichterbij | Continu | 255 | Stop |

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.
| Aansluiting | Arduino Uno / Nano | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| HC-SR04 VCC | 5V | VIN (5 V) | VBUS of de 5 V-rail |
| HC-SR04 TRIG | D9 | GPIO 18 | GP2 |
| HC-SR04 ECHO | D10 (direct) | GPIO 19, via een 1 kΩ / 2 kΩ-deler | GP3, via een 1 kΩ / 2 kΩ-deler |
| IN van de trilmodule | D5 (PWM) | GPIO 25 | GP15 |
| Passieve buzzer (+) | D8 | GPIO 26 | GP16 |
| Knop (andere pootje naar GND) | D2 | GPIO 27 | GP14 |
| Watersensor + | D7 | GPIO 33 | GP22 |
| Watersensor S | A1 | GPIO 34 (ADC1) | GP26 (ADC0) |
| MPU6050 SDA | A4 | GPIO 21 | GP4 |
| MPU6050 SCL | A5 | GPIO 22 | GP5 |
| MPU6050 VCC | 5V | 3V3 | 3V3 |
| Batterijmeting (middelpunt van de 100k/100k-deler) | A0 | GPIO 35 (ADC1) | GP28 (ADC2) |
| NEO-6M GPS TX / RX | Geen | GPIO 16 / GPIO 17 | Geen |
| SIM800L TXD / RXD | Geen | GPIO 13 / GPIO 23 | Geen |
Stap voor stap bouwen: begin met de basisstok
- 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.
- Sluit VCC en GND van de HC-SR04 aan op de rails, TRIG op D9 en ECHO op D10.
- 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.
- 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.
- 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.
- Werkt alles, voeg dan de watersensor, de MPU6050 en de knop toe en ga verder met de volledige code.
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.

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.

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.
| Fase | Voorwaarde | Duur | Wat gebeurt er? |
|---|---|---|---|
| WALK | Totale versnelling overschrijdt 2,5 g | Onbeperkt | Gaat naar SETTLE; obstakelmeldingen blijven doorlopen |
| SETTLE | Wacht tot het schudden stopt | 1 s | Gaat naar CHECK |
| CHECK | Kanteling moet boven 70° blijven en versnelling tussen 0,8 en 1,2 g | 2 s | Terug naar WALK als de voorwaarde breekt, ALARM als hij standhoudt |
| ALARM | Elke seconde een piep en trilling zodat de stok te vinden is | 20 s | Geannuleerd door een druk op de knop of door de stok op te pakken (kanteling onder 60°) |
| SOS | ... --- ... in morsecode met geluid, led en trilling | Tot geannuleerd | Een 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.
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.
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}- 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.
- 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.
- 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.
- 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.
- 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.
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 instelling | Wat 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_MS | Valgevoeligheid 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.
| Voedingsbron | Gewicht | Ong. looptijd (50 mA) | Oordeel |
|---|---|---|---|
| 9V-PP3-batterij (ongeveer 500 mAh), naar VIN | 45 g | 8–10 uur | Niet aanbevolen: de spanning zakt in als de motor draait, niet oplaadbaar |
| 4 × AA NiMH (2000 mAh), naar de 5V-pin | Ongeveer 120 g | 35–40 uur | Zwaar; bereikt 5,6 V als hij vol is, wat tegen de limiet aan zit |
| 1 × 18650 + TP4056 + MT3608 | Ongeveer 55 g | 25–30 uur | Aanbevolen: licht, opladen via USB, beveiligd |
| 2 × 18650 in serie (7,4 V), naar VIN | Ongeveer 105 g | 45–50 uur | Gaat lang mee maar is zwaar, heeft een aparte laadschakeling nodig |
| Powerbank (10.000 mAh) | 200 g of meer | Meerdere dagen | Zwaar; de meeste powerbanks schakelen uit bij lage stroom |

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.
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.
| Onderdeel | Ong. gewicht |
|---|---|
| Arduino Nano | 7 g |
| HC-SR04 | 9 g |
| MPU6050 (GY-521) | 2 g |
| Trilmodule + passieve buzzer | 5 g |
| Waterniveausensor en kabel | 8 g |
| 18650-cel | 45–48 g |
| TP4056 + MT3608 + schakelaar | 8 g |
| 3D-geprinte doos en klemmen | 40–50 g |
| Draden, schroeven, klittenband | 10–15 g |
| Totaal | Ongeveer 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.

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.
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.
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.
- Probleem: De witte stok kan obstakels boven heuphoogte niet detecteren en plassen blijven onopgemerkt. Leg het uit met concrete voorbeelden uit je interviews.
- 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.
- Methode: Toon je sensorkeuze (HC-SR04, JSN-SR04T, ToF) met je redenen, de montagehoek met de berekening en de trilmapping met zijn formule.
- Resultaten: Presenteer de resultaten van de onderstaande tests in tabellen en grafieken en neem ook de gevallen op waarin het misging.
- 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.
| Test | Hoe je het doet | Waarde om vast te leggen |
|---|---|---|
| Afstandsnauwkeurigheid | Telkens 10 metingen op 30, 60, 100 en 150 cm van een muur | Gemiddelde fout (cm) en grootste afwijking |
| Soorten obstakels | Muur, persoon, paal van 5 cm, struik, glazen deur, stoffen gordijn | Hoe vaak van de 10 elk obstakel wordt gedetecteerd |
| Reactietijd | Slowmotionvideo met de telefoon: het obstakel verschijnt en de eerste trilling | Vertraging in milliseconden |
| Waterdetectie | Dompel de punt in 0,5, 1, 2 en 3 cm water | Vanaf welke diepte hij waarschuwt |
| Valdetectie | 20 keer laten vallen en 100 tikken op de grond | Aantal juiste en valse alarmen |
| Batterijduur | Laat hem draaien vanaf een volle lading tot hij uitschakelt | Tijd in uren en eindspanning |
| Gewicht en balans | Weeg hem op een keukenweegschaal, meet de afstand vanaf het handvat | Toegevoegd gewicht (g) en koppel (kg·cm) |
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
| Verschijnsel | Waarschijnlijke oorzaak | Oplossing |
|---|---|---|
| De stok trilt non-stop | De sensor wijst naar de grond of naar de stok zelf | Verhoog de montagehoek en houd de ruimte voor de sensor vrij |
| Af en toe trilling zonder reden | Een enkele foute echo of een andere ultrasoonbron in de buurt | Het mediaanfilter zit er al in; neem zo nodig de mediaan van 5 metingen |
| De motor draait niet bij grote afstanden | De PWM-waarde ligt onder de aanloopdrempel van de motor | Houd de minimale sterkte boven 150 en bevestig de motor met rubber |
| De Arduino herstart als de motor draait | De motorstroom trekt de voeding omlaag, of er is geen diode | Gebruik een kant-en-klare module en voeg een condensator van 100 µF toe aan de voeding |
| De MPU6050 leest altijd 0 of een vaste waarde | SDA en SCL verwisseld, adres is 0x69, of de chip slaapt | Zoek het adres met een I2C-scanner en controleer of 0 naar register 0x6B wordt geschreven |
| Valse alarmen door tikken op de grond | IMPACT_G is laag en de kantelhoekdrempel ligt dicht bij de loophoek | Meet de kanteling met de testsketch en verhoog LYING_DEG naar 75 |
| De watermelding stopt nooit of klinkt nooit | Verkeerde drempel of geoxideerde banen | Meet de droge en natte waarden opnieuw en vervang zo nodig de sensor |
| De buzzer is stil of speelt altijd dezelfde toon | Er zit een actieve buzzer in | Gebruik een passieve buzzer voor tone() |
| De sms wordt niet verstuurd | De SIM800L is niet geregistreerd op het netwerk, de voeding is zwak of de pincode van de simkaart is ingeschakeld | Controleer of de led van de module elke 3 seconden knippert, schakel de pincode uit en voed de module vanaf de 18650 |
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.
Projecten om hierna te bouwen
Alle projecten bekijken
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.

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.

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.

Parkeersensor met HC-SR04
Een minversie van de parkeersensor van een auto: hoe dichterbij iets komt, hoe sneller de pieptonen.

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.

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.

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.

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.
Meer artikelen
BlueGrays-app
Bouw deze schakeling stap voor stap op je telefoon
Schakelschema, code en onderdelenlijst op één scherm. Meer dan 500 Arduino-, ESP32- en Pico-projecten om te bouwen.
Scan met je telefoon
Richt je camera op de code en de appstore van je telefoon opent.
of open de store

