10. Input devices

Input Devices. This week I’ll keep it fairly simple, Mostly just expanding on things from Week 9. My original plan for this week was to experiment using a Time of Flight sensor as contactless end-stop of sorts. But I ended up having to scrap that idea due to time limitations. What I settled on was designing a board for the VL53L1X Time of Flight sensor.

Hero Shot

Research

Initially I wanted to make a board and solder the sensor itself onto it. But looking at the datasheet and comparing similar boards I realized it’d take me far too long to prep and solder since I’d have to do reflow. So it was way more convenient to use a ready made board instead so I used the Adafruit VL53L1X.

Reading through the Data Sheet for the ToF sensor itself I saw the device pinout (Page 4) and immediately realized this would be a huge pain to mill on the Roland MDX-20 with our current setup.

Here’s a diagram of the footprint from the data sheet, It is Tiny:

So I moved on using the Adafruit VL53L1X.

Design

I mostly followed the learning page from Adafruit. Main things here was checking the pin-out and figuring what I needed to use.

• Pins I used:
  • VIN - Voltage In. 5V from the Xiao RP2040
  • GND - Common ground.
  • SCL - Serial Clock for I2C
  • SDA - Serial Data for I2C


• Pins I didn't use:
  • GPIO - Interrupt output pin.
  • XSHUT - Shutdown pin

Here’s the KiCad Schematic I made based off this:

I had to use a 1X5 socket footprint rather than the necessary 1x4. The Fab Library didn’t include a 1X4 socket by default and I figured the easiest thing to do was to leave a pin unpopulated.

Here’s the PCB Editor view:

Notice anything wrong? Neither do I but as the milling shows the line width was definitely off somehow. I thought I forgot to set the design rules properly but checking the KiCad backups dated to then shows the correct line width. Even the .svg export has the correct line width of .450 mm. I’m still not sure what went wrong but I’ll go into more detail in a bit.

After exporting everything and moving onto the actual milling process I started off milling. This is done using the same process as I used in Electronics Production. Fabmodules running on a raspberry pi using a Roland Modela MDX-20. I went through the usual steps. Making sure to zero the Z axis while holding the bit down as I tightened the set screw. But the cut I got barely scratched the surface of the copper. Here’s a photo I took:

This would make for some fantastic engraving art but it’s not exactly what I intended. I paused the cut as soon as I noticed. Here’s how to do it smoothly on the Roland Modela MDX-20 on Fabmodules:

1. Press the “View” Button
2. Hold down the “Up” and “Down” Buttons simultaneously
3. Check whether the LEDs are blinking.
4. If they’re blinking. Hit Cancel on the server UI. In our case the Pi-Top running fabmodules.

After pausing everything I adjusted the Z-height and started over. That resulted in this cut:

Immediately there’s several things wrong here. The traces are way too thin and the toolpath didn’t cut two of the pads on the Xiao. Luckily those were not pads I’m using here. Here’s the board after removing it from the mill:

I lapped the PCB before soldering and everything that mattered was correct when measured with a multimeter so I’m considering this an OK-ish PCB. I do have a few theories on what went wrong though:

• I didn’t hold down the bit enough while tightening the set screw

• I accidentally used the incorrect bit (The usual 1/64th bit was not in it’s usual position but this one was on the table next to the mill and appeared visually identical, I think I’m competent at gauging bits from my 100+ hours on the shopbot)

• There was debris between the set-screw and bit resulting in it getting loose.

• The bit was worn out from other students using it.

After this happened I went through all the design files to make sure I hadn’t made any mistakes there. But the design rules were correct and the Inkscape .svg had the correct line width. My exported PNG was the correct DPI and I did select the right settings when generating the toolpaths. So I’m genuinely not sure what happened. Luckily it didn’t matter since my circuit was perfectly functional.

After making sure everything was correct with a multimeter I lapped the rough edges down with a 2000 grit sanding sponge and got to soldering. Soldering was simple enough since I’m only using sockets, Trickiest part was cutting the socket strips to the correct length. The method I found best was using my Leatherman to cut into one of the pins on the socket. Cutting between two pins always broke both of them so it seems better to use one of them as a sacrificial cut. Putting solder on two of the pin surfaces for each socket before soldering made positioning easier.

Here’s the board after soldering with the RP2040 and ToF board installed:

Programming

For this week I initially wanted to use the Time of Flight board as a sort of contactless endstop. But ultimately I ran out of time trying to program it so I ended up using the example Arduino code from Adafruit. That was all done inside the Arduino IDE.

Here’s the program I used, Credits to Kattni Rembor on Adafruit.

show / hide full code

#include "Adafruit_VL53L1X.h"

#define IRQ_PIN 2
#define XSHUT_PIN 3

Adafruit_VL53L1X vl53 = Adafruit_VL53L1X(XSHUT_PIN, IRQ_PIN);

void setup() {
  Serial.begin(115200);
  while (!Serial) delay(10);

  Serial.println(F("Adafruit VL53L1X sensor demo"));

  Wire.begin();
  if (! vl53.begin(0x29, &Wire)) {
    Serial.print(F("Error on init of VL sensor: "));
    Serial.println(vl53.vl_status);
    while (1)       delay(10);
  }
  Serial.println(F("VL53L1X sensor OK!"));

  Serial.print(F("Sensor ID: 0x"));
  Serial.println(vl53.sensorID(), HEX);

  if (! vl53.startRanging()) {
    Serial.print(F("Couldn't start ranging: "));
    Serial.println(vl53.vl_status);
    while (1)       delay(10);
  }
  Serial.println(F("Ranging started"));

  // Valid timing budgets: 15, 20, 33, 50, 100, 200 and 500ms!
  vl53.setTimingBudget(50);
  Serial.print(F("Timing budget (ms): "));
  Serial.println(vl53.getTimingBudget());

  /*
  vl.VL53L1X_SetDistanceThreshold(100, 300, 3, 1);
  vl.VL53L1X_SetInterruptPolarity(0);
  */
}

void loop() {
  int16_t distance;

  if (vl53.dataReady()) {
    // new measurement for the taking!
    distance = vl53.distance();
    if (distance == -1) {
      // something went wrong!
      Serial.print(F("Couldn't get distance: "));
      Serial.println(vl53.vl_status);
      return;
    }
    Serial.print(F("Distance: "));
    Serial.print(distance);
    Serial.println(" mm");

    // data is read out, time for another reading!
    vl53.clearInterrupt();
  }
}

I did make an effort to read into the demo code. It’s mostly doing things from the VL53L1X library but most of I can at least intuit. For example in the main loop it does the following:

  if (vl53.dataReady()) {
    // new measurement for the taking!
    distance = vl53.distance();
    if (distance == -1) {
      // something went wrong!
      Serial.print(F("Couldn't get distance: "));
      Serial.println(vl53.vl_status);
      return;
    }
    Serial.print(F("Distance: "));
    Serial.print(distance);
    Serial.println(" mm");

    // data is read out, time for another reading!
    vl53.clearInterrupt();
  }

If the vl53 returns dataReady as true. It starts the loop and sets distance to whatever the vl53 reports.

If the distance equals =1 it prints an error but otherwise it prints the Distance before clearing an interrupt.

Reading through the code and pin definitions at the start I maybe should have connected GPIO and XSHUT but the code functioned without them even when running it for longer periods and the measurements were accurate to within 5mm for most surfaces. I did notice some of the lighting in the lab interefered with the sensor but never too much. The laser wavelength is 940nm infrared. Which should not be affected by indoor lighting but is affected by sunlight.

The lab here in Reykjavik may be getting an Xtool-F1 Ultra in the near future. In which case I might be able to make fine enough traces to make the footprint for the VL53L1X in-house. Adafruit does provide a schematic for the board:

I might use this schematic as a test for the laser’s PCB-making capabilities if I have the opportunity.

Here’s the KiCad Project file for this week:

Filename	Type	Program	Link
KiCadTimeOfFlightFun	.zip	KiCad	Link