Input devices
"You make mistakes, but that's how you learn" (or something like htat)
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/Txreceive 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 analyser (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 analyser 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 familar 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!
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 cofusion 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.
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:
VL53L1X project (with XIAO board)
I2C, XSHUT, INT/GPIO
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
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: