About 350 million individuals worldwide have visual impairments which prevent them from reading information effectively. Currently, there lacks an affordable, portable, and hands-free solution. I present a novel wearable device for displaying braille texts which can be worn like a wristband.
https://lalopunch.github.io/PPW/index.html
For software, I programmed the device using C++ for functionality. Using packages such as RF24 for wireless communication and adafruit_MPRLS for pressure sensor data. For doing experiments and showing results. I used Python packages such as OpenCV and Matplotlib to visually inspect inflation and plot results for my academic paper.
For mechanical, I used Micro Fluidic Mechanics to calculate the pressure, time, and force needed for consistent tactile feedback. Also utilized Systems and Controls to create a first order system. Using Pump as source and pressure sensor as feedback allowing for better accuracy.
This device consists of a pump, solenoid valves, a pressure sensor and a microfluidic silicone strip. The silicone strip has an array of six air membranes which are aligned in the form of a braille cell. By controlling the inflation of the silicone membranes using the solenoid valves. The membranes form different Braille patterns which provides a tactile braille display to the user.
Below is a simple use case:
1️⃣ Type a message to be sent to the device
3️⃣ Introduce airflow in to the micro tubing system and monitor w/ pressure sensor
5️⃣ Solenoids are activated via braille pattern (Step 2️⃣) allowing pneumatic tactile feedback
2️⃣ (Code) Parses characters and calculates its braille pattern equivalent
4️⃣ Airflow is distributed through all channels and stopped at the solenoids
6️⃣ Step 2 is repeated until all characters have been parsed
First Prototype
classDiagram
class Main{
-setup() void
-loop() void
-communicate Communicate
-pressureSensor : PressureSensor
-convertToBraille(char) : void
-activateSolenoid(int,int) ; void
}
class PressureSensor{
-pressureData : unsigned float
-pressureValue : unsigned long
-update() void
-begin(2i2c_addr:uint8_t) boolean
-getPressureHpa() unsigned float
-getPressurePsi() unsigned float
-lastBrailleCellActivations() unsigned float
-getStatus() uint8_t
}
class adafruit_MPRLS{
external library
}
class SPI{
external library
}
class nRF24L01{
external library
}
class Communicate{
-address[] : const byte
-session : Communication
-begin() void
-sendPacket() unsigned long
-receivePacket() void
}
class RF24{
external library
}
class WirelessComm{
-address[] : const byte
-begin() void
-startListening() void
-openWritingPipe(address : const uint8_t*)
-openReadingPipe(child : uint8_t, address : const uint8_t* )
-setPALevel(level : uint8_t , lnaEnable : bool )
-RF24::RF24(uint8_t:_cepin,uint8_t:_cspin)
}
WirelessComm--|> Communicate
WirelessComm*-- RF24
Main*-- Communicate
PressureSensor*-- adafruit_MPRLS
WirelessComm*-- SPI
WirelessComm*-- nRF24L01
Main*-- PressureSensor
Figure 1 Photos of the prototype and environment used to test system.
Two experiments where done to check the potential and validity of the device.
The first experiment was to measure the response time when air pressure was introduced in to the system. By testing them on different Braille patterns in the silicone strip
The second experiment, the ‘words-per-minute’ was recorded for the prototype by inputting a randomly generated texts and translating that into a sequence of Braille pattern.
Experiment 1
We created a sequence of input patterns which has different number of active membranes, as shown in Figure 1. A step input was used to inflate and deflate for 500 ms between patterns. The system pressure appears to be linearly related to the number of inflated membranes. Additionally, the inflation speed is nearly instantaneous while the deflation speed is much slower with a settling time up to 0.5 seconds. The settling time is less with a smaller number of active membranes.
Experiment 2
In this experiment, we quantify the refresh rate of the current prototype which is limited by the time of activating and deactivating the six solenoid valves. For this purpose, the time to fully deflate membranes was neglected and the system was running at its fastest refresh rate. We acquired five randomly generated paragraphs in literary text from an internet source. We parsed these texts, character by character, to the PC and generated sequences of Braille patterns. Then, these patterns were displayed using our system. The word count increases by one each time a ‘space’ or a special character (e.g., ‘.’) is displayed. For each paragraph, we limited the reading time to 2 minutes and counted the number of whole words our system was able to display during the 2 minutes. We repeated five times for each paragraph and calculated the mean and standard deviation of the ‘word-per-minute’. On average, our current prototype produces 120 words per minutes given any literary texts.
Figure 2 Pressure vs time with an increasing number of active membranes. (Middle) segmented activation/deactivation data for each pattern. (Bottom) A sequence of images of the active membranes (highlighted with red circles) to display the word ‘UTAH’ in Braille.