Input devices

This week I really channeled the idea: "You make mistakes, but that's how you learn" (or something like htat)

Soldering guides from Kris

Erwin's lesson

There are two types of signals:

Analog, which is continuous and we measure points along the wave.

Digital, which is either on or off.

ADC analog to digital converters converts voltage to a value. They come in different resolutions, for instance: 8bit (0-255) can measure in 255 steps.

GPIO

general purpose input-output

• GPIO pins read either low or high (two states).
• LOW: 0 - 1/3VCC vs. HIGH: 2/3VCC - VCC.
• The reading is undefined between 1/3 and 2/3.
• A pull-up resistor connects the pin to VCC, ensuring it reads HIGH when not driven.
• A pull-down resistor connects the pin to ground, ensuring it reads LOW when not driven.

The purpose of pull-up/pull-down resistors is to prevent the pin from "floating" in an indeterminate state, which could lead to unpredictable behavior or noise sensitivity.

NB. Many microcontrollers have internal pull-up/pull-down resistors that can be enabled in software.

Interfaces - protocol

ie. how components communicate.

• 1wire/two wire (twi) communicates over gnd and vcc -- data transmitted over the one cable.
• I2C: uses 7 bit addresses clock and data signals (different to Serial, which uses baudrate).
• SPI: exchanges bits between microcontrollers or sensor + MCU -- uses pins instead of addresses.
• PWM: for noisy environments.
• Serial: Rx / Tx receive transmit with a baudrate. Serial runs on 1 to 1 communication, meaning you need a new serial port for other devices.

Bitbanging is the practice of using software to do the job instead relying of certain hardware.

SI system

The 7 core values that we use (aka The SI system):

• seconds
• meters
• grams
• amperes
• kelvins
• moles
• candelas

Everything else is defined by these values, for example, Volts.

1V = 1kg⋅m²⋅s⁻³⋅A⁻¹

Button noise

There's a small amount of noise when you push in a button, just before the button has totally bridged the connection.

Input noise can mess up your readings.

There are two main ways to deal with the noise:

• In software (ignore first 10 ms)
• Using a capacitor

When taking the software approach, MCU's with an Aref (analog reference) signal can be used to show what the clean voltage is as a reference.

The other approach is using a capacitor:

Group project

During the group assignment we set up input devices with an Arduino (connected to a bread board).

Microwave radar (RCWL-0516)

This sensor didn't seem to be making readings very well. The output pin of the sensor was connected to an LED on the breadboard. The LED flashes didn't correlate with the movements we made.

The multimeter indicated that there were no broken circuits.

There was also a bit of confusion around which side of the PCB the sensor was. Ultimately though, after extensive debugging and still no improvement, we opted to move on and check a sensor that we knew was in good working condition.

We tried our best, but decided to move on.

Ultrasonic (HCSR04)

This is Henk's favorite, now obsolete, sensor. In 2018, he documented about using it to measure the thickness of ice.

The sensor has four pins, two of which are for emitting and receiving ultrasonic pulses. To get a better idea of how the sensor worked, we hooked up a logic analyzer to some of the pins.

To better understand the readings, we decided to hook the sensor up to a logic analyzer (Irja took good notes on this).

Input values from the sensor (on Arduino's serial monitor):

Here we can see the relationship between echo and trigger signals.

The sensor takes 180.92 ms to process an Out of range value. While it processes that, no other signals are sent out, which results in a delay.

We also connected the logic analyzer to the serial communication. The 3rd row gives back a reading when values are printed in the serial monitor. Here, Sam wrote something in the serial monitor. The bottom row shows that.

Individual project

My first step was getting familiar with Arduino again and setting up the ESP32 board.

My initial focus was to get each component on the Henkduino board to do it's most basic function. The LED to turn on and off. The button to turn the LED on and off. To get readings from the phototransistor in the Serial Monitor.

It took me ages to figure out why the LED wasn't blinking. I had tested it with the multimeter at Waag, so I knew that the connection was ok. In the end, it turned out the issue was that I had the ledPin defined as D3 rather than D2.

Once I got all of the pins correctly defined, everything worked. YEEHAW!

This was my first spiral / most basic code, to check that everything worked:

const int ledPin = D2; // define LED
const int buttonPin = D10; // define button
const int photoPin = D0; // define phototransistor

int buttonState = 0; // define the button's initial state with a value

void setup() {
  Serial.begin(9600); // set up communication frequency with the computer
  pinMode(ledPin, OUTPUT); // define pin type
  pinMode(buttonPin, INPUT);
  pinMode(photoPin, INPUT);

}
void loop() {
  int lightLevel = analogRead(photoPin); // read the photoPin's value and define it as an integer
  Serial.println(lightLevel); // print that value
  delay(100);

  buttonState = digitalRead(buttonPin); // Read button state

  if (buttonState == HIGH) {           // If button is pressed
    digitalWrite(ledPin, HIGH);        // Turn LED on
  } else {
    digitalWrite(ledPin, LOW);         // Turn LED off
  }
}

VL53L1X project (with programmer)

I2C - I2C is a two-wire serial communication protocol using a serial data line (SDA) and a serial clock line (SCL).

Multiplexer - an electronic device that allows multiple input signals to be selected and transmitted over a single output line.

Programmer - a device used to upload code or firmware to a microcontroller.

Breakout board - an electronic device that allows multiple input signals to be selected and transmitted over a single output line

Most of the Fab academy documentation I found used the Adafruit breakout board for the sensor that I was hoping to use.

As we didn't have any available at Waag, I decided to try and make my own.

After some searching, I stumbled on Sparkfun's breakout board. It that came with a nice schematic!

Sparkfun schematic PDF

I attempted to recreate the breakout board in KiCad, but there were some discrepancies. The Pololu breakout board schematic that I found after seemed like a better fit for what I was doing.

Jumpers

There was a bit of confusion in the SparkFun schematic around what Jumpers were. My understanding is that they are connections to pull-up resistors that can be soldered or unsoldered depending on if there are already pull up resistors in the circuit or not.

Pololu schematic PDF

I was running out of time so I decided to simplify my project. However, I learned a lot about the VL53L1X.

Resources specific to the VL53L1X:

• SparkFun Arduino library
• SparkFun VL53L1X breakout board
• VL153L1X guide
• Adrianino

VL53L1X project (with XIAO board)

I2C, XSHUT, INT/GPIO

XSHUT and GPIO1 purposes (AI report)

XSHUT: Power Saving -- The primary reason to use the SHUT pin is to conserve power. When you don't need the sensor to be actively measuring distances, you can pull the SHUT pin LOW to put the sensor into a low-power state. This is important for battery-powered applications.

GPIO1/INT on the VL53L1X is to a digital pin on the microcontroller (optional, for interrupt).

Operating voltage: 2.6V - 3.5V.

NB. The capacitors are used for decoupling and noise filtering, which are essential for stable operation.

GPIO logic

For digital communication, a logic "high" for the VL53L1X will be around 2.8V.

The RP2040 uses 3.3V logic for its GPIO pins. It typically recognizes voltages above about 2V as a logic "high".

This means the 2.8V output from the VL53L1X will be correctly interpreted as a "high" by the RP2040, so there's no issue with direct connection.

Deciding on the XSHUT pull-up resistor

The schematic from the datasheet indicates that we need to use pull-up resistors.

On reset, the RP2040's GPIO pins are configured as inputs with an internal pull-down resistor enabled (50–80 kΩ) unless explicitly configured otherwise.

The VL53L1X's XSHUT pin requires a pull-up to a valid logic high voltage (e.g., 2.8V or 3.3V) to keep the sensor enabled. Without a pull-up resistor, the XSHUT pin would remain low due to the RP2040's default pull-down state, which would disable the sensor.

Adding a 10k pull-up resistor to 3.3V is generally a safe choice. It ensures the XSHUT pin remains in a defined state and protects against floating inputs.

Schematic design

NB. Make sure to check what resistors and capacitors are available in the lab before completing the PCB layout.

NB. Use power flags instead of labels for power and ground.

Digital files

• Kicad files
• F.Cu final png file
• Edge.cuts final png file

Clearance and simulated path view check

The TOF sensor has many different pads and they have a clearance of 0.3mm, but the tool diameter we're used to using was 0.4mm. This resulted in a bad mill.

In the future, make sure to look at the simulated path view to check if the mill looks right. We updated the settings to a tool diameter of 0.3mm and it worked.

There was actually evidence in KiCad that this might be an issue. I wasn't able to draw traces as my settings weren't small enough (0.3mm).

Mill: offset settings

I realized that I was slightly confused about the offset number setting.

For the F.Cu milling I chose and offset of 0, because I wanted to clear out any empty areas, but apparently that wasn't necessary.

Offset number should have been = 4 for this project. Offset number = 1 on Edge.cuts -- we don't need to offset the cutting of the border!

Mill depth on Edge.cuts should start at 0.3 mm not 0.003 in.

Make sure to have the Fill edge cuts box selected on the Gerber to PNG tool for the F.Cu layer.

Soldering the TOF sensor

• Don't use too much solder
• Add reflow
• Dab with tip onto the copper areas being soldered
• Put a tiny bit down and spread it around
• Place component (I found it helped that )
• Use hot airgun to activate the solder (take off protective film over sensor)

Reflow makes the solder spread out and lie flat on the copper.

Careful of the part melting and check with a microscope if the solder has worked.

Test board

Henk gave me an I2C code to check on the controller, but I was having issues with sending code from Arduino.

The loading of the code kept getting stuck on "Resetting /dev/cu.usbmodem101".

After much debugging and learning about boot mode, Sam noticed that, actually, I had my pins set up incorrectly.

WRONG:

HOW IT SHOULD BE:

THE ISSUE (mixing up the schematic numbers from the actual pin numbers):

FIXED:

TRY AGAIN:

I milled a new board, flowed/soldered the parts on, and tested again.

The LEDs on the MCU weren't turning on when docked on the PCB, but they worked fine when not docked. The beep test 'beeped' when I had the multimeter on ground and power. There was a short circuit somewhere.

I took off the capacitors.

Still beeping.

Took off the TOF.

No longer beeping.

Sam reflowed the sensor on and it didn't beep, but I still wasn't able to get an I2C reading in Arduino's Serial monitor.

The week ended without me being able to get the TOF circuit to work.

Useful resources:

• Input devices student reference (good)
• AgriLab instructor

VL53L0/1XV2 breakout board

Hello, this is Dylan from the future (networking week)

I came back to the TOF sensor, so that I would have something to communicate with for networking week. I hooked a TOF breakout board to a XIAO RP2040 and used an example code. Voila! It worked.

/*
This example shows how to take simple range measurements with the VL53L1X. The
range readings are in units of mm.
*/

#include <Wire.h> // Enables I2C communication between the Arduino and the VL53L1X sensor
#include <VL53L1X.h>

VL53L1X sensor;

void setup()
{
  while (!Serial) {}
  Serial.begin(115200);
  Wire.begin();
  Wire.setClock(400000); // use 400 kHz I2C

  // Sets a timeout of 500 ms for sensor operations

  sensor.setTimeout(500);
  if (!sensor.init())
  {
    Serial.println("Failed to detect and initialize sensor!");
    while (1);
  }

  // Use long distance mode and allow up to 50000 us (50 ms) for a measurement.
  // You can change these settings to adjust the performance of the sensor, but
  // the minimum timing budget is 20 ms for short distance mode and 33 ms for
  // medium and long distance modes. See the VL53L1X datasheet for more
  // information on range and timing limits.

  sensor.setDistanceMode(VL53L1X::Long); // "Long" mode allows for measurements up to 4 meters
  sensor.setMeasurementTimingBudget(50000); // How long the sensor spends on each measurement - A longer timing budget improves accuracy but reduces speed

  // Start continuous readings at a rate of one measurement every 50 ms (the
  // inter-measurement period). This period should be at least as long as the
  // timing budget.

  sensor.startContinuous(50);
}

void loop()
{
  Serial.print(sensor.read());
  if (sensor.timeoutOccurred()) { Serial.print(" TIMEOUT"); }

  Serial.println();
}

My Serial Monitor was set to a different baud rate (9600), but the data still appeared.

Why it still worked

• Synchronization of Data: If the data being sent is simple (like plain numbers), and if the Serial Monitor's baud rate is a simple fraction or multiple of the actual baud rate, you might still see readable output. For example:
• 115200 is exactly 12 times faster than 9600. This means that some bits might align well enough for the Serial Monitor to interpret them correctly.
• Short Messages: The data being sent in your code is just a number (the distance in millimeters) followed by a newline character. This simplicity reduces the chances of garbled output.