Head-Mounted Haptic Navigation Device for Visually Impaired Individuals

by RubenLauwers in Circuits > Wearables

302 Views, 5 Favorites, 0 Comments

Head-Mounted Haptic Navigation Device for Visually Impaired Individuals

Frontpage.jpg
Enclosure and headband.jpg
Head-Mounted Haptic Navigation Device for Visually Impaired Individuals



This project is a proof of concept designed to evaluate the effectiveness of haptic feedback for guiding visually impaired individuals using a lightweight device. The results provide a foundation for future development toward a fully functional navigation aid.

Our design uses a headband fitted with two ultrasonic sensors positioned to function like artificial “eyes.” These sensors detect the proximity of objects and send signals to corresponding haptic actuators, also mounted on the headband. The actuators deliver directional vibrations to alert the user about nearby obstacles in real time. Vibration intensity can be adjusted using a potentiometer, allowing users to fine-tune sensitivity based on their preferences or environment. Turning the potentiometer fully to the left powers down the device, making it simple and intuitive to use.

The goal is to make it possible to navigate through inside environments like hospitals.

Supplies

For this project you will need:

1) Hardware:

  1. Sensors: 2x HC-SR04 ultrasonic sensors (for obstacle detection).
  2. Microcontroller: 1x Arduino Micro (for data processing and control).
  3. Haptic feedback: 2x Titan Drake LF Tac Hammer (haptic feedback actuator), 2x DRV2605L drivers (for actuator control)
  4. Power: 1x 9V alkaline battery + 1x 9V Battery Snap Connector.
  5. Connectivity: 1x PCA9548 multiplexer with STEMMA connections and a minimum of 2 channels (for I2C communication).
  6. Sensitivity adjustment: 1x potentiometer 10kΩ (for sensitivity adjustment).
  7. Wiring:
  8. At least … jumper wires (male/male) (75mm)
  9. At least 3 jumper wires female/female (150mm)
  10. 2x Stemma QT cables (50mm long)
  11. 1x VGA cable (1m) or 2x ethernet cables (1m each)
  12. 1x breadboard (165.1mm x 54.4mm)
  13. 2x 2-pin screw terminal block (pitch 5.0 mm)
  14. Wire insulation tape


2) Software:

  1. Arduino IDE


3) Tools:

  1. Wire stripper
  2. wire cutter
  3. Soldering iron


4) Wearable design:

  1. Some kind of headband
  2. A container to keep hardware organized

Background Information

Navigating indoor environments presents persistent and often dangerous challenges for individuals with visual impairments. According to the World Health Organization, over 250 million people globally suffer from moderate to severe visual impairment, many of whom struggle with spatial awareness in complex environments like homes, schools, and public buildings [1], [2].Traditional aids like white canes and guide dogs have limitations: canes require physical contact to detect obstacles, failing to identify overhead or low-lying hazards (e.g., hanging objects, stairs) [3], while guide dogs are costly to train and maintain, and access to such assistance remains limited for many due to financial, logistical, or regional constraints [4].

The emergence of haptic technology presents an opportunity to address these gaps by offering real-time, non-visual feedback through touch, thereby enhancing spatial perception without overwhelming the user’s auditory or cognitive load. Haptic feedback can improve situational awareness by translating spatial information into tactile cues, enabling users to sense their surroundings in a more intuitive and passive manner [5]. Compared to auditory systems, which can interfere with environmental sounds crucial for orientation and safety, haptic systems preserve the auditory channel while offering continuous, location-specific feedback [6].

Several research efforts have explored wearable assistive devices for obstacle detection using ultrasonic, infrared, or computer vision-based approaches [6].However, many existing solutions either lack portability, depend heavily on auditory feedback, or fail to adapt to dynamic environments such as crowded hallways or shifting obstacles like doors. Moreover, a significant knowledge gap remains in creating low-cost, user-friendly haptic systems that provide reliable directional information and allow for customizable sensitivity, which is crucial in varying spatial contexts.

Our project aims to bridge this gap by developing a lightweight, head-mounted haptic navigation device tailored for visually impaired users. By integrating ultrasonic sensors and directional haptic actuators within a compact, adjustable design, our solution seeks to provide real-time feedback about both static and dynamic obstacles in a user-centric and accessible format. This device not only augments environmental awareness but also empowers users to navigate independently and confidently, addressing both safety and social inclusion challenges.

Hardware Overview

Opstelling.png
ArduinoMicro.png

At the heart of the device lies an Arduino Micro, a small and compact microcontroller board. The Arduino Micro serves as the central controller: it reads distance data from the ultrasonic sensors, processes that information, and sends appropriate signals to the haptic actuators in real time. Its small footprint and low power consumption make it well-suited for integration into this lightweight system [7].

All actuators and sensors are connected to the Arduino Micro. The attached schematic provides an overview of how these connections should be assembled. To make the setup easier to follow, we have broken it down into individual tasks. (See step 3 → 5)

Ultrasonic Sensors

UltrasoundSensor.jpg
UltrasoundsOpstelling.png

We begin with the HC-SR04 ultrasonic sensor. Ultrasonic sensors are used for measuring distances with high accuracy, making it well-suited for obstacle detection applications. It operates by emitting ultrasonic sound waves and measuring the time it takes for the echo to return after bouncing off an object. This time-of-flight is then used to calculate the distance, based on the known speed of sound in air.

Each HC-SR04 module includes a transmitter and receiver integrated into a single unit. The transmitter emits pulses at 40 kHz, and the receiver detects the reflected signals. The sensor operates within a voltage range of 4.5 to 5.5V and can measure distances from 2 cm to 400 cm, with a resolution of approximately 3 mm.

The module includes four key pins:

  1. VCC: Supplies power to the module (4.5–5.5V).
  2. GND: Ground connection.
  3. Trig: Trigger pin that initiates the ultrasonic pulse when set high for at least 10 µs.
  4. Echo: Echo pin outputs a pulse whose duration corresponds to the time-of-flight of the ultrasonic wave.

Connect these pins to the Arduino micro as followed (see also the breadboard figure):

Sensor 1:

  1. Vcc → 5V (red)
  2. Trig → D10 (yellow)
  3. Echo → D9 (blue)
  4. GND → GND (black)

Sensor 2:

  1. Vcc → 5V (red)
  2. Trig → D12 (yellow)
  3. Echo → D11 (blue)
  4. GND → GND (black)

Drake Haptic Actuators and DRV2605L Haptic Drivers

Opstelling.png
Drake.png
Drive.png

Next we go to the haptic feedback system, this consists of two Drake Haptic Actuators and two DRV2605L haptic drivers.

Drake Haptic Actuators:

The Drake LF haptic actuator, also known as a TacHammer, is a compact and high-precision haptic motor designed for modern tactile feedback applications. Unlike traditional actuators that rely on springs or flexible structures, the TacHammer employs a solid-state magnetic suspension system. This innovation allows it to produce strong, percussive vibrations with exceptional consistency and responsiveness, while maintaining a lightweight and durable form factor. Ideal for wearable and portable devices.

Drake actuators are categorized by two key performance metrics: their effective frequency range and their peak output, which is measured in root mean square acceleration (Grms) at resonance. The LF model is optimized for low-frequency operation, making it especially suitable for applications that require clear and distinct tactile cues.

In our project, the Drake LF's compact size and reliable vibration output make it a natural fit for our headband design. Its ability to deliver directional, percussive feedback enables users (particularly those with visual impairments) to intuitively sense the location and proximity of obstacles in their environment. [9]

DRB2605L haptic drivers:

The DRV2605L is a low-voltage haptic driver featuring a built-in library of tactile effects and a closed-loop actuator control system. It is designed to deliver high-quality haptic feedback by optimizing actuator performance; improving acceleration consistency, reducing response time, and enhancing braking efficiency. In this project, the DRV2605L is used to drive the Drake haptic actuators, ensuring precise and responsive vibration output. The driver supports both I2C communication and PWM input, allowing for flexible integration into compact and wearable systems like our navigation aid for visually impaired users.

Connection:

To connect the Drake haptic actuator to its driver, connect the + pin to the red wire of the actuator and the pin to the black wire (see schematic). This connection can be made either by soldering or by using a 2-pin screw terminal block with a 5.0 mm pitch. In our setup, we opted for the second option.

PCA9548 Multiplexer

Opstelling.png
PCA9548.jpg

Next we go to the PCA9548 multiplexer, to better understand how the multiplexer works we first introduce you to the I2C Protocol.

I2C Protocol:

I2C (Inter-Integrated Circuit) is a two-wire communication protocol used for connecting multiple devices using just two shared lines: the Serial Clock Line (SCL) and the Serial Data Line (SDA). The SCL line carries the clock signal generated by the controller, while the SDA line transmits data between the controller and connected peripheral devices.

In an I2C network, one device acts as the controller (or master), initiating communication and controlling the clock, while one or more devices serve as peripherals (or slaves). Each peripheral is identified by a unique address, allowing the controller to communicate selectively with devices over the same bus. Data transmission typically begins with the controller sending an address byte, followed by a command or data. Peripheral devices may also respond by sending data back to the controller, using the same two lines under the timing provided by the clock signal.

On Arduino boards, the microcontroller usually serves as the I2C controller. For example, on the Arduino Micro, the SDA and SCL lines are available on pins A4 and A5, respectively. The Arduino Wire library simplifies implementation of the I2C protocol, allowing developers to easily connect and communicate with sensors, displays, and other modules using minimal wiring. This makes I2C a practical and scalable solution for complex hardware setups [8].

PCA9548 multiplexer:

Now back to the PCA9548 multiplexer (see figure), this module allows you to connect multiple I2C devices to a single I2C bus, even if they share the same address. This is especially useful when working with identical I2C components, like multiple DRV2605L haptic drivers, that would otherwise conflict due to address overlap.

The multiplexer has eight independent, bidirectional I2C channels. It routes the main I2C bus (SCL/SDA) to any combination of its eight downstream ports (SC0/SD0 through SC7/SD7), which are selected by writing to the multiplexer’s control register over I2C. This setup prevents address conflicts and allows sequential communication with multiple identical devices.

The I2C address of the PCA9548 can also be configured by connecting the A0, A1, and A2 address pins to either GND or VCC, giving you up to 8 possible address combinations—ideal when using multiple multiplexers in one system.

Connection:

Connect these pins on the PCA9548 to the Arduino Micro as followed:

  1. Vcc → 5V
  2. GND → GND
  3. SDA → SDA (pin 2 on Arduino Micro)
  4. SCL → SCL (pin 3 on Arduino Micro)


DRV2605L Connections:

Connect the SCL/SDA, VCC, and GND of each DRV2605L to a separate channel on the PCA9548 with the STEMMA QT wires:

  1. DRV2605L #1 → Connect to Channel 0 (SC0/SD0)
  2. DRV2605L #2 → Connect to Channel 1 (SC1/SD1)


Address Handling:

Both DRV2605L drivers have the same default I2C address (0x5A), so using separate channels via the PCA9548 avoids address collisions. This can be done in the software. Here you can find a conceptual Arduino Code Example:

#include <Wire.h>

#define PCA9548_ADDR 0x70 // Default address

void selectChannel(uint8_t channel) {
Wire.beginTransmission(PCA9548_ADDR);
Wire.write(1 << channel);
Wire.endTransmission();
}

void setup() {
Wire.begin();

// Select Channel 0 to talk to DRV2605L #1
selectChannel(0);
// Initialize DRV2605L #1...

// Select Channel 1 to talk to DRV2605L #2
selectChannel(1);
// Initialize DRV2605L #2...
}

void loop() {
// Communicate with one device at a time
}


Potentiometer

Totale opstelling (PotMeter).png

Now we go over to the last piece of hardware from this project, the potentiometer. A potentiometer is a variable resistor with three terminals:

  1. Two outer pins: connected GND and 5V.
  2. Middle pin (wiper): moves along the track when you turn the knob or slider, connected to an anolog pin.

As the wiper moves, it divides the resistance between the two ends. This changes the voltage at the middle pin, which makes it useful for:

  1. Adjusting signal levels
  2. Controlling brightness, volume, or speed
  3. Providing user input (like a dial)

For this project the potentiometer will be used to adjust the intensity of the vibrations, allowing users to fine-tune sensitivity based on their preferences or environment.

Connect the potentiometer to the Arduino as shown in the schematic with the middle pin connected to the A4 analog pin of the Arduino.

Software

Download the latest version of the Arduino IDE from https://www.arduino.cc/en/Main/Software

Open the attached code “Code_Project.inu” found at the bottom of this step.

Select boards in Tools -> Board -> Arduino Micro and then select the port that your Arduino is connected to under Tools --> Port.

Hit the upload button to upload the code to the Arduino Micro, now you are ready to go!

Key parts of the code:

Here are the key parts of the code explained, you can apply some changes for your own adjustments.

1) Basics of Arduino programming

Every Arduino program contains two predefined functions: setup and loop. Both are essential and required in almost every program. The first function setup is a function that is called once in the beginning. The moment the Arduino Micro is connected to power and is done with booting the firmware. Therefore, it is useful to initialize variables or pins. Tipp: a board reset is also calling the function setup once after it is done booting. The second function loop is called as long as the Arduino Micro is powered. If a function call for loop is done the function is called again. Thereby, it is useful for the main code and can react to user input for example.

Additionally, it is important to understand the Serial class offered by Arduino. This one is used for the communication with a PC over USB. Serial is a useful tool to input or output data to the developer board. Mostly it is used for debugging purposes.

2) Distance calculations

In the loop() function, the measureDistance function is called to calculate the distance measured by each ultrasonic sensor. This function takes two parameters: trigPin and echoPin, which are connected to the Arduino's digital I/O pins.

long dist[i] = measureDistance(trigPins[i], echoPins[i]);

The trigPin of the ultrasonic sensor sends the sound and the echoPin receives it. If we look at the code we send a 10 microseconds long trig pulse by using a digitalWrite(trig,High), wait for 10µs and then a digitalWrite(trig,Low). This makes the sensor emit an ultrasonic sound wave.

Then we wait for the echoPin to go High (which happens when the sensor receives the reflected sound). The pulseIn() function measures how long the echo pin stays High, that’s the time the sound wave took to go out and come back. The 20000 is the max timeout in microseconds (20 ms) to prevent it from hanging if no echo returns.

Finaly the distance in centimeters is calculated by using the speed of sound (~0.034 cm per microsecond). This is divided by 2 because the sound travels to the object and back.

long measureDistance(int trig, int echo) {
digitalWrite(trig, HIGH);
delayMicroseconds(10);
digitalWrite(trig, LOW);
long duration = pulseIn(echo, HIGH, 20000); // max 20ms
long distance = duration * 0.034 / 2;
return distance;
}

3) Haptic actuator pulse:

The haptic actuators are activated (through the DRV2605L drivers) with a pulse function alternated with a pause time (10 – 350ms) where the actuator is down to create a vibrating motion. This pulse function (shown bellow) generates a PWM (Pulse Width Modulation) signal at a certain intensity and duration, which controls how strong and how long the vibration is.

void pulse(double intensity, double milliseconds) {
int minimumint = 140;
int maximumint = 255;
int pwmintensity = (int)(intensity * (maximumint - minimumint)) + minimumint;

standbyOffB();
PWM13 = pwmintensity;
usdelay(milliseconds);
standbyOnB();
}

This function takes two inputs:

  1. intensity: how strong the vibration should be (a value between 0.0 and 1.0, scaled later).
  2. milliseconds: how long the vibration should last.

First we map the intensity (0.0 to 1.0) to a PWM value between 140 and 255. (140 = minimum vibration and 255 = maximum vibration). This ensures even weak vibrations still feel noticeable.

Than the standbyOffB function is called, this sends an I2C command to the DRV2605L to enable the haptic driver so it can vibrate. The PWM13 variable writes the PWM intensity value to the OCR4A register (PWM13), which controls the actual signal going to the motor.

After a delay of the specified time (in milliseconds) to keep the actuator on for the right length, the DRV2605L is put back in standby to conserve power and prevent continuous vibration.

4) Haptic actuator parameters

In the loop function we can find the following if statement:

if (dist[i] > 0 && dist[i] < 90 && potVal > 5) {
mapPulse(dist[i], mappedVal, &intensity[i], &duration, &pauseTime);
selectMuxPort(i);
pulse(intensity[i], duration);
pause(pauseTime);
}
// else intensity remains 0 (no vibration)

The if statement makes sure that when the measured distance (dist) is above 90mm there will be no haptic feedback. This also happens when the potentiometer value is lower than 5 (all the way to the left), this comes in handy to shut down the haptic feedback if the user desires this.

However if the measured distance is lower than 90mm, the mapPulse function is called:

void mapPulse(double afstand, float mappedVal, double* intensity, double* duration, double* pauseTime) {
//In this function the pulse parameters are determined
if (afstand < 30) {
*intensity = 1.0 * mappedVal; //mappedVal comes from potentiometer to manipulate the intensity and speed of the pulse
*duration = 10.0;
*pauseTime = 20.0 * mappedVal;
} else if (afstand < 60) {
*intensity = 0.5 * mappedVal;
*duration = 20.0;
*pauseTime = 70.0 * mappedVal;
} else if (afstand < 90) {
*intensity = 0.1 * mappedVal;
*duration = 20.0;
*pauseTime = 200.0 * mappedVal;
}
}

The mapPulse() function is used to determine how the haptic feedback should behave based on the distance to an obstacle and the user’s preferred sensitivity, which is set using a potentiometer. It takes in two main inputs: the measured distance from the ultrasonic sensor (dist) and a scaled potentiometer value (mappedVal). Based on the distance, it calculates and outputs three key values: the intensity of the vibration, the duration of the pulse, and the pause time between pulses. These values are passed by reference using pointers so they can be directly used in the main loop.

When an object is very close to the user (less than 30 cm), the function sets the vibration intensity to its highest, by multiplying the potentiometer value (from 0.25 to 1.75) with this intensity can be adjusted. The pulse duration is kept short at 10 milliseconds, and the pause time is also short, scaled to 20 milliseconds times the potentiometer value. This results in a strong, fast, and frequent vibration pattern to alert the user quickly and clearly.

If the object is moderately close (between 30 cm and 60 cm), the intensity is reduced to 0.5 times the mapped potentiometer value. The pulse duration is slightly longer at 20 milliseconds, and the pause time increases to 70 milliseconds times the potentiometer value. This gives a less urgent but still noticeable vibration.

For objects that are farther away but still within the sensor’s detection range (between 60 cm and 90 cm), the vibration intensity is reduced even further to 10% times the mapped value. The pulse duration remains at 20 milliseconds, but the pause time is increased significantly to 200 milliseconds times the potentiometer value. This creates a softer and less frequent feedback, signaling to the user that the obstacle is not immediately nearby.

Downloads

Wearable Design

Enclosure and headband.jpg
Headband.jpg
Hardware Enclosurejpg.jpg
Drawing.jpg
Haptic Navigation System

For our design we chose a headband to attach our ultrasonic sensors and haptic actuators. This makes it easy for the user to put the device on. The sensors and actuators are connected to the hardware enclosure via two Ethernet cables. This enclosure houses the Arduino Micro and all other necessary hardware components, as described in “Step 2: Hardware Overview”.

Wiring and assembly:

To integrate the components into the headband, we made a slit along the fabric to route the wiring internally, allowing the cables to exit at the back. Jumper wires were used to connect to the ultrasonic sensor pins, although soldering is also a viable option for improved durability.

In total, twelve wires are needed:

  1. 2 × 4 wires for the ultrasonic sensors
  2. 2 × 2 wires for the DRV2605L haptic actuators

To organize and protect these wires, we used two Ethernet cables (each containing 8 wires). Alternatively, a VGA cable could be used as it also contains sufficient wiring. All connections are soldered and insulated with wire tape.

Inside the hardware container, the DRV2605L drivers, PCA9548A multiplexer, potentiometer, and Arduino Micro are connected according to the schematic in Step 2. A 9V battery is connected to the Vin and GND pins of the Arduino to provide power when the device is not connected to a PC.

Hardware enclosure:

Then for the hardware enclosure we made a laser cut design as shown in the figure above. You can replicate this by downloading the file attached at the bottom of this step or you can make one yourself.

Discussion

The haptic navigation device was developed to help users detect nearby obstacles through tactile feedback, with the goal of enhancing spatial awareness for visually impaired individuals. During testing, the device successfully delivered clear and intuitive vibration signals that increased in intensity as the user moved closer to an object. This indicates that the prototype addressed its primary goal of offering non-visual environmental awareness.

Users were able to differentiate between distance thresholds based on changes in vibration intensity and pattern, which supports the effectiveness of the system’s core mechanism. These findings suggest the device provides useful and interpretable feedback.

However, there are still some limitations. Some users may find the electronics enclosure bulky, and the connecting cable slightly restrictive to their movement. These factors could affect long-term comfort and ease of use. Another important observation is that adjusting the vibration intensity using the potentiometer while moving can be confusing and lead to misinterpretation. Therefore, we suggest that these settings should ideally be adjusted while the user is stationary.

The wide-angle placement of the sensors introduced a detection bias, with side obstacles being registered earlier than frontal ones, even at equal distances. While the asymmetric vibration signals from the two motors initially caused some disorientation, users generally adapted to this feedback pattern within a short period.

An interesting finding was the system’s sensitivity to overhead structures. The sensors frequently detected low ceilings and doorways as obstacles. This behaviour proved helpful in avoiding overhead hazards, but also led to false warnings in cases where there was no real danger, such as low ceilings without hanging objects. This highlights a trade-off between providing maximum safety and avoiding unnecessary alerts.

In summary, the device demonstrated solid core functionality and provided useful feedback, but also revealed several usability challenges that will need to be addressed in future iterations.

Conclusion and Future Work

This project showed that haptic feedback can be an effective method for communicating proximity information to users. The prototype successfully enabled users to detect nearby obstacles and adapt to the vibration patterns. The system functioned reliably and provided timely warnings, even in situations involving overhead hazards. The concept proved to be feasible and holds promise for practical use in assistive navigation.

Several areas for improvement were identified during testing. Sensor placement can be refined to reduce detection bias and ensure a more balanced awareness of the surroundings. The connecting cable could be made longer or replaced with a wireless solution to improve freedom of movement. Reducing the size of the electronics housing would also contribute to greater comfort. In addition, the user interface for adjusting intensity settings should be reconsidered to avoid confusion during movement. One of the most important technical challenges lies in the development of smarter detection algorithms that can better distinguish between true obstacles and harmless architectural features like low ceilings without hanging elements.

These observations provide valuable guidance for future iterations of the device. They also emphasize the importance of designing for real-world conditions, where both physical ergonomics and environmental variability must be taken into account.

By addressing these areas, the system can evolve into a more practical and comfortable assistive tool. With further development, this haptic navigation concept could become a valuable alternative or complement to traditional aids for people with visual impairments.

References

[1] World Health Organization, World Report on Vision. Geneva, Switzerland: WHO, 2019. [Online]. Available: https://www.who.int/publications/i/item/world-report-on-vision

[2] I. Soltani, J. Schofield, M. Madani, D. Kish, and P. Emami-Naeini, “User-centered insights into assistive navigation technologies for individuals with visual impairment,” arXiv preprint arXiv:2504.06379, Apr. 2025. [Online]. Available: https://www.researchgate.net/publication/390638770_User-Centered_Insights_into_Assistive_Navigation_Technologies_for_Individuals_with_Visual_Impairment

[3] H. Kim, H. Lee, and J. Kim, “Usability evaluation of a smart cane for the visually impaired,” International Journal of Design, vol. 8, no. 1, pp. 103–115, 2014. [Online]. Available: https://yonsei.elsevierpure.com/en/publications/usability-and-design-guidelines-of-smart-canes-for-users-with-vis

[4] T. S. Zhang, “Guide dogs are expensive and scarce. Could robots do their job?,” Communications of the ACM, vol. 68, no. 3, pp. 13–15, Feb. 2025. [Online]. Available: https://cacm.acm.org/news/guide-dogs-are-expensive-and_scarce-could-robots-do-their-job/

[5] J. M. Loomis, R. L. Klatzky, and N. A. Giudice, “Sensory substitution of vision: Importance of perceptual and cognitive processing,” in Assistive Technology for Blindness and Low Vision, CRC Press, 2012, pp. 161–191. [Online]. Available: https://pmc.ncbi.nlm.nih.gov/articles/PMC5044782/

[6] C. Jiang, E. Kuang, and M. Fan, “How can haptic feedback assist people with blind and low vision (BLV): A systematic literature review,” ACM Trans. Access. Comput., vol. 18, no. 1, pp. 1–35, Jan. 2025. [Online]. Available: https://dl.acm.org/doi/abs/10.1145/3711931

[6] D. Dakopoulos and N. G. Bourbakis, “Wearable obstacle avoidance electronic travel aids for blind: A survey,” IEEE Trans. Syst., Man, Cybern. C, Appl. Rev., vol. 40, no. 1, pp. 25–35, Jan. 2010.

[7] Arduino, “Arduino Micro,” Arduino Official Store, [Online]. Available: https://store.arduino.cc/products/arduino-micro. [Accessed: May 24, 2025].

[8] TITAN Haptics. “DRAKE High Definition Haptic Motor Technology.” TITAN Haptics. [Online]. Beschikbaar: https://titanhaptics.com/drake/.

[9] Arduino, “Wire Library,” Arduino Documentation, [Online]. Available: https://docs.arduino.cc/learn/communication/wire/.

[10] Adafruit, “Adafruit JST SH 4-pin to Premium Male Header Cable – 200mm long,” [Online]. Available: https://www.adafruit.com/product/5626.