Electromechanical Refreshable Braille Module

Having access to a printer directly made all the difference when iterating for 20-30 um tolerances. At these sizes, you can't really trust the CAD software anymore, and every assembly has to be empirically tested by printing it out.

In the final few iterations, I made the Cam assembly with the Braille Lower assembly independent of the Braille Upper, so that I could laser into the hole-shaft tolerance needed between the cam shaft and the hole it fit into. 

Depending on the Resin, and printer used to print, I suspect the tolerances in the CAD design may need to be altered. Ive linked the final (so far) of the Braille Cell design below for FUsion 360. You should be able to navigate to the design history and change the hole size as needed if the cam is having a hard time fitting, or is too loose. 

V12 CAD designs can be found here.

I was initially using 1mm steel cores harvested from paperclips, but experimentally found that the steel core doesn't take well to fast voltage changes, and heats up the coil so much, that I had a few failures while testing operational parameters.

So I went back to high school science trying to understand magnetic permeability, and properties of soft iron (and WTF is soft iron anyway) and finally found these Ferrite Rods on Digikey:

they turned out to be a lot more brittle and needed more care in assembly. The metal chuck of the first iteration would just snap the ferrite rod. 

So I redesigned a complete 3D printed chuck, that IMO works even better than the earlier one, and sits nice and centered

Ive updated the Instrusions section with details of how to use the new Coil Winding Jig.

The braille cells made of the ferrite core were found to be:

• Run cooler & with lesser power requirement
• Faster max refresh rate,  from 200ms to 50ms
• Overcomes the issue when the cam magnet is too close to the core, the natural attraction overcomes the opposing magnetic flux, and the cam refuses to flip. the natural magnetic attraction to a ferrite core vs the steel core felt like it was less than half of it.

THe main drawback of using ferrite cores, however, what that if you are not careful with the winding jig, the core would snap. 

In the future, I see this process automated, with the same process used to wind small inductors.

The updated CAD design for the winding jig can be found here.

Two Dots work!! a big achievement, and proves that the concept works as intended.

A few issues that I want to rectify before assembling the rest of the dots though:

-Steel core gets TOO hot too fast, it doesn't like too many polarity changes in a short amount of time, which is a big drawback if I'm trying to active fast refresh times. I will switch to a soft iron/ferrite core for the next iteration.

- Assembly is a real pain in the current version, with the cams wanting to stick to each other before I get the upper and lower halves of the assembly together. Will change over to snap-fit components. 

-Will move the magnets closer to the center of the rotation on the cams, i.e., reduce the concentricity, to reduce the effect of the cam <sometimes> interfering with the other, but works 80% of the time. 

A couple of logs back, we tested the overall mechanism working with a single dot in isolation with the PCB designed and then verified that the PCB boards designed were working with LEDs

Now it's time to assemble them to see if the designed electronics can successfully drive at least one braille dot.

And it works! The assembly process for the braille module can be found in the instructions, so check it out there. 

// Pin configuration
const int MOD_0 = 6;   // A0, A1, A2 of the 1st decoder
const int MOD_1 = 7;
const int MOD_2 = 8;

const int PIN_0 = 9;   // A0, A1, A2 of the 2nd decoder
const int PIN_1 = 10;
const int PIN_2 = 11;

const int RESET = 5;  // Set pin of the 1st decoder
const int SET = 4;  // Reset pin of the 1st decoder


void setup() {
  // Initialize Serial communication for debugging (optional)
  Serial.begin(9600);
  pinMode(MOD_0,OUTPUT);
  pinMode(MOD_1,OUTPUT);
  pinMode(MOD_2,OUTPUT);

  pinMode(PIN_0,OUTPUT);
  pinMode(PIN_1,OUTPUT);
  pinMode(PIN_2,OUTPUT);

  pinMode(SET,OUTPUT);
  pinMode(RESET,OUTPUT);
}

void loop() {
  pinSelect(1);
  moduleSelect(1);
  while(true)
  {
    pinSet();
    delay(50);
    pinOff();
    delay(1000);
    pinReset();
    delay(50);
    pinOff();
    delay(1000);
  }

}

void moduleSelect(int decimalValue) {
  //Ensure the input decimal value is within the valid range (1 to 8)
  //numbering starts from 1, so subract
  decimalValue--;
  if (decimalValue >= 0 && decimalValue <= 7) {
    // Calculate the binary representation of the decimal value
    digitalWrite(MOD_0,(decimalValue >> 0) & 0x01);
    digitalWrite(MOD_1,(decimalValue >> 1) & 0x01);
    digitalWrite(MOD_2,(decimalValue >> 2) & 0x01);
  } else {
    digitalWrite(MOD_0,0);
    digitalWrite(MOD_1,0);
    digitalWrite(MOD_2,0);
  }
}

void pinSelect(int decimalValue) {
  //Ensure the input decimal value is within the valid range (1 to 6)
  //numbering starts from 1, so subract
  decimalValue--;
  if (decimalValue >= 0 && decimalValue <= 5) {
    // Calculate the binary representation of the decimal value
    digitalWrite(PIN_0,(decimalValue >> 0) & 0x01);
    digitalWrite(PIN_1,(decimalValue >> 1) & 0x01);
    digitalWrite(PIN_2,(decimalValue >> 2) & 0x01);
  } else {
    digitalWrite(PIN_0,0);
    digitalWrite(PIN_1,0);
    digitalWrite(PIN_2,0);
  }
}

void pinSet() {
  digitalWrite(SET,1);
  digitalWrite(RESET,0);
}

void pinReset() {
  digitalWrite(SET,0);
  digitalWrite(RESET,1);
}

void pinOff() {
  digitalWrite(SET,0);
  digitalWrite(RESET,0);
}

 The above is the code I used to figure out the ideal on/off time, and 50ms seems to be a safe enough time for the pin to actuator.

The next big thing to test is multiple dots working together, and see how the magnets interfere with each other, and if that causes any issues. 

I tested out the driving electronics using two LEDs connected in opposing polarities, and adjusting the LM317 output to bring down the voltage so as not to burn the LEDs out.

This is what the code looks like running. The via placement for the coils just happened to be the right size to mount a few 0603 package SMD LEDs, so I converted one of the braille module PCBs into a tester. 

The code below shows the functions I'm using to select which pin of which module to actuate. MOD_X and PIN_X are the pin numbering for the input pins of the decoder IC.

void moduleSelect(int decimalValue) {
  //Ensure the input decimal value is within the valid range (1 to 8)
  //numbering starts from 1, so subract
  decimalValue--;
  if (decimalValue >= 0 && decimalValue <= 7) {
    // Calculate the binary representation of the decimal value
    digitalWrite(MOD_0,(decimalValue >> 0) & 0x01);
    digitalWrite(MOD_1,(decimalValue >> 1) & 0x01);
    digitalWrite(MOD_2,(decimalValue >> 2) & 0x01);
  } else {
    digitalWrite(MOD_0,0);
    digitalWrite(MOD_1,0);
    digitalWrite(MOD_2,0);
  }
}

void pinSelect(int decimalValue) {
  //Ensure the input decimal value is within the valid range (1 to 6)
  //numbering starts from 1, so subract
  decimalValue--;
  if (decimalValue >= 0 && decimalValue <= 5) {
    // Calculate the binary representation of the decimal value
    digitalWrite(PIN_0,(decimalValue >> 0) & 0x01);
    digitalWrite(PIN_1,(decimalValue >> 1) & 0x01);
    digitalWrite(PIN_2,(decimalValue >> 2) & 0x01);
  } else {
    digitalWrite(PIN_0,0);
    digitalWrite(PIN_1,0);
    digitalWrite(PIN_2,0);
  }
} 

After the pin/module is selected, the enable pins of the decoder IC are manipulated to change the polarity of the voltage across each pin.

void pinSet() {
  digitalWrite(SET,1);
  digitalWrite(RESET,0);
}

void pinReset() {
  digitalWrite(SET,0);
  digitalWrite(RESET,1);
}

void pinOff() {
  digitalWrite(SET,0);
  digitalWrite(RESET,0);
}

The whole code to test out the addressability of the pins is below:

// Pin configuration
const int MOD_0 = 6;   // A0, A1, A2 of the 1st decoder
const int MOD_1 = 7;
const int MOD_2 = 8;

const int PIN_0 = 9;   // A0, A1, A2 of the 2nd decoder
const int PIN_1 = 10;
const int PIN_2 = 11;

const int RESET = 5;  // Set pin of the 1st decoder
const int SET = 4;  // Reset pin of the 1st decoder


void setup() {
  // Initialize Serial communication for debugging (optional)
  Serial.begin(9600);
  pinMode(MOD_0,OUTPUT);
  pinMode(MOD_1,OUTPUT);
  pinMode(MOD_2,OUTPUT);

  pinMode(PIN_0,OUTPUT);
  pinMode(PIN_1,OUTPUT);
  pinMode(PIN_2,OUTPUT);

  pinMode(SET,OUTPUT);
  pinMode(RESET,OUTPUT);
}

void loop() {
    moduleSelect(1);
    int pin = 1;
    while(true)
    {
        pinSelect(pin);
        pinSet();
        delay(500);
        pinReset();
        delay(500);
        pinOff();
        delay(500);
        pin++;
        if(pin > 6)
        {
            pin = 1;
        }
    }
  

}

void moduleSelect(int decimalValue) {
  //Ensure the input decimal value is within the valid range (1 to 8)
  //numbering starts from 1, so subract
  decimalValue--;
  if (decimalValue >= 0 && decimalValue <= 7) {
    // Calculate the binary representation of the decimal value
    digitalWrite(MOD_0,(decimalValue >> 0) & 0x01);
    digitalWrite(MOD_1,(decimalValue >> 1) & 0x01);
    digitalWrite(MOD_2,(decimalValue >> 2) & 0x01);
  } else {
    digitalWrite(MOD_0,0);
    digitalWrite(MOD_1,0);
    digitalWrite(MOD_2,0);
  }
}

void pinSelect(int decimalValue) {
  //Ensure the input decimal value is within the valid range (1 to 6)
  //numbering starts from 1, so subract
  decimalValue--;
  if (decimalValue >= 0 && decimalValue <= 5) {
    // Calculate the binary representation of the decimal value
    digitalWrite(PIN_0,(decimalValue >> 0) & 0x01);
    digitalWrite(PIN_1,(decimalValue >> 1) & 0x01);
    digitalWrite(PIN_2,(decimalValue >> 2) & 0x01);
  } else {
    digitalWrite(PIN_0,0);
    digitalWrite(PIN_1,0);
    digitalWrite(PIN_2,0);
  }
}

void pinSet() {
  digitalWrite(SET,1);
  digitalWrite(RESET,0);
}

void pinReset() {
  digitalWrite(SET,0);
  digitalWrite(RESET,1);
}

void pinOff() {
  digitalWrite(SET,0);
  digitalWrite(RESET,0);
}

Assembling such tiny components was proving to be quite tiresome on the eyes, so I decided I'd gear up. I got one of these, and am very happy with the purchase, It's almost like I have superpowers! 

I plan to just assemble a single pin with a solenoid winding connected directly to a power supply just to test if the fundamental concept even works ( quite late in the development process to do this IMO, should have been the first thing to do!) before I start integrating it with the electronics. 

Using both metallic and nonmetallic tools makes it easier for you to assemble things together. I used a tweezer that was easily attracted to the magnet in the cams, along with a toothpick to move it about. IMO using plastic tweezers would be better to use. 

The head-mounted magnifier is surely a game changer and keeps both hands free. this is THE WAY to assemble the mechanisms if you prefer not to get headaches during the assembly process.

What the braille cell looks like when assembled. Very neat and professional. Hopefully it works as good as it looks!

It works!! it just started to actuate reliably at 5-6V @ 500uA powered directly from a voltage source. It just needs a short pulse to move the dot one way or the other and just stays there until given the opposite pulse. THe coil would heat up and melt the glue-gun glue keeping it in place, so care should be taken to not keep the coil powered on for too long. 

Once this is hooked to the electronics. I will have more variables to play around with to actuate the dots. 

There is only one other thing that is keeping this mechanism from being complete: that is if the flipping of adjacent cells affects each other, because of the movements of the magnets having influence on the surrounding Cams. If that works, we are in the clear to create a full braille cell!

                     Fig 1. Version 3 Braille Parts printed on a Figure4 3D Printer by 3D Systems

Getting the design right has been a bigger challenge than I initially thought it would be.  I had to go through 7 iterations before things were getting to something that fit together satisfactorily. 

            Fig 2. The various versions of the braille cells printed in SLA in different orientations

I initially was outsourcing to an external vendor who had a 3D systems figure machine with ProBLK 10 resin that produced pretty strong parts at extremely high detail. Even though I was very impressed at first, I quickly realized that things were either too snug a fit and wouldn't allow for easy motion or that there was too much tolerance and the mechanisms would not actuate predictably. 

The orientation the print was printed and what surface was used to support the part played a huge role in the functionality as well. 

                                 Fig 3. The Support tree holding up the Cam and Braille pins

                           Fig 4. Cam cut out from the part tree, with nubs of support still attached.

For the Cam's, arguably the most critical part of the braille cell, choosing to put the support on the curvature was the lesser of the evils. When oriented axially with the Z axis, one of the little axils that the cam spins about used to be too loose and would require close attention to detail when removing the support and post-processing.  When orienting at a 45-degree angle, other issues with the hole for the magnet or the cam riding surface would be affected.

                     Fig 5. The final orientation of the cam chosen, to which support would attach

The highlighted portion was chosen as it is a non-critical surface compared to all the other features and details on the cam as it does not come into contact with anything, and I can be a bit more lenient while removing support material.

                                               Fig 6. Cutting out the supports from the cam

                                       Fig 7. Sanding the surface on 220 grit sandpaper

That was just the story of the iterations I went through with the Cam, and I got fed up waiting in anticipation for 2-3 days for every iteration from the vendor to arrive for the other parts printed in the 3DS Figure 4. It seemed that I had to go through quite a few iterations to get things right and needed a faster solution.

In desperation, I figured I'd give a go at a cheap Anycubic Photon Ultra DLP 3D printer a friend of mine had, just out of curiosity, and I was blown away by the output. 

                                               Fig 8. First print from the Anycubic Photon Ultra

                                    Fig 9. Close-up of parts printed in Anycubic Craftsman Resin

                                         Fig 10. Close-up of some of the fine details

The prints came out as good as if not better than the 3D Systems figure that costs more than 20 times the amount that the Photon ultra costs. I am extremely impressed.

This means that the braille cells can be made at low cost and using affordable DLP 3D printers like the ones from Anycubic. I'm still unsure about the details that an MSLA 3d printer would produce, but the DLP ones are a big A-OK for me. 

                                           Fig 1: Individual Braille Cell PCB's

I had to max out the PCB fabs capability and took a few risks in the design by overriding my tried and tested DRC(Design Rule Check) file in Eagle when it came to the distance of the traces to the edge of the board, drills, and pads, but it seems to have worked. Nothing is shorted, or disconnected, so big win! 

These boards you see in the image above make up one braille-cell model each. You get a good sense of the tiny scale of this, and I'm starting to realize the nightmare this is going to be to solder!

                                               Fig 2: Braille Cell Evaluation Board

I could have gone the simple route and created a driver board for a single braille cell by using 6 H-bridges and 12 MCU pins to test out just a single braille cell function, but I thought I'd stretch myself and figure out how to create a driver board to drive N-number of braille cells that future me can use to create a full braille display consisting of many braille cells, as well as reference schematics for other people to integrate these braille modules into other accessibility products and projects. Let's hope the research and reverse engineering of Flip-Dot Displays work out.

If it does, it means that not only can the individual braille cells be made affordable, but the drive circuitry is incredibly affordable as well. 

The basic BOM  to create the driver part 8-cell braille display for costing purposes is given below. For every additional 8 cells to be added, another pair of Source and Sink drivers and a pair of 74HC238 decoder ICs are needed, in addition to the flyback diodes for each pin. The costs below are considered for an MOQ for 5 boards, and can possibly come down with volume.

11$ for the driver board itself is an amazing cost even at low volume, and I'm really excited about the possibility of creating low-cost refreshable braille computers or integrating braille modules into ATMs, signages, public displays, etc. in the future.

Download the Braille Module Gerber Files here

Download the Braille Cell Evaluation Driver Board Gerber, BOM & Centroid here

I figured that the trickiest parts of the build would be the winding of the ultra-small coils, so I designed a coil winding tool to help with this process and make it easier 

In the future, this step could be completely automated, similar to commercial coil-winding machines.

 I used a couple of drill chucks (https://robu.in/product/3-17mm-mini-electronic-drill-chuck-range-0-5-3-2mm/) and a 4mm shaft gearbox DC motor with an encoder(https://robu.in/product/n20-6v-125rpm-metal-gear-motor-with-encoder-d-type-shaft/) for the winding jig. Ive included the assembly file in the file download section and that should be enough for you to figure out how to assemble it.

Details of the winding process itself will be provided in the instructions section. The winding tool looks very similar to a miniature lathe, with a headstock being one drill chuck connected to the motor, and another drill chuck connected to the headstock. The headstock can move along the length of the took on a dovetail groove that can be locked at a set position to determine the length of the coil to be wound.

There is a tensioning mechanism to center the wire spool and make sure it is taught against the winding. 

All components were 3D printed on an FDM machine. 

I used two 2.5mm diameter - 1mm thickness spacers which were cut on a wire EDM machine to act like flat faces to constrain the coil winding, as well as to give an indication that the maximum allowed diameter of the coil is achieved. The two chucks are tightened on two ends of these spacers to constrain the length of the coil winding.

You can see in the video below that despite the jankiness, it still works very nicely and produces perfectly wound coils.  I used the slot on the EDM cut spacers (That is needed anyway for the wire to cut out the inner hole) to hold one end of the wire when it starts winding. 

The final assembly for the tool can be downloaded here. Export the relevant parts as an STL and print it on an FDM 3D Printer. The design can definitely use some improvements so I've included the source files to make modifications and improvements to the design.

I created an 8 - Braille cell board to evaluate the braille cell functionality. 

A similar schematic as described in the previous log added an Arduino Nano to control the pins. 

I've Added an adjustable LM317, so that I can specify the voltage that is given to drive the pins since this aspect still is to be calibrated.

The final board layout looks like this:

This will be a reference example for a driver/carrier board for individual braille cell modules.

The PCB for the braille cell module is pretty simple:

Ive used vias to which they will be soldered. make sure the Vias has the copper exposed on the solder mask when getting the PCBs made. 

Finally, Ive created an eagle library for the footprint for the braille cells, so it is easy to use the footprint to create custom baseboards as per requirement. 

Download the Braille Cell Evaluation Board Eagle Source Files here

Download the Braille Module Eagle Source Files here

Download the Footprint Library of the braille cell for Eagle here