W9 | Input Devices

The oscilloscope we used was the GW Instek GDS-1152A-U, a digital storage oscilloscope available in our lab. An oscilloscope is a tool that lets you see electrical signals on a screen — instead of just reading a number like a multimeter would, you can actually see the shape of the signal over time, which makes it much easier to understand what a circuit is doing. The "digital storage" part means it can capture and hold a signal on screen, which is very useful when you want to analyze it carefully.

Vertical axis (VOLTS/DIV)

Each square represents a set number of volts. Adjusting this makes the signal appear taller or flatter on screen.

Horizontal axis (TIME/DIV)

Each square represents a set amount of time. Adjusting this zooms in or out on the signal, showing more or fewer pulses at once.

The circuit we tested was a custom-designed red PCB with a XIAO RP2040 microcontroller soldered onto it. The board exposes all pins through headers, making it easy to connect external components and test equipment.

For the tests we connected two components:

• 🖰 D0 — a push button (digital input)
• 🖰 A1 — a potentiometer (analog input)

The following program was running on the XIAO RP2040 during the measurements. It reads both components continuously and prints their values to the Serial Monitor:

#define pinButton D0
#define pinPot A1

bool state;
int valueADC;

void setup() {
  Serial.begin(9600);
  pinMode(pinButton, INPUT);
}

void loop() {
  state = digitalRead(pinButton);
  valueADC = analogRead(pinPot);
  Serial.print("Button state = ");
  Serial.print(state);
  Serial.print("     Potentiometer ADC value = ");
  Serial.println(valueADC);
}
        

1. Connecting the probe
   The oscilloscope probe has two parts: a signal tip and a ground clip. The signal tip connects to the pin being measured, and the ground clip attaches to the GND of the circuit. This step is always necessary — the oscilloscope measures voltage differences and needs a reference point to compare against. Without the ground connection, the measurement is meaningless.
   
   
2. Using Autoset
   Once connected, we pressed the 🖰 Autoset button. This automatically adjusts both VOLTS/DIV and TIME/DIV to display the signal correctly on screen. It was a good starting point, especially when we did not know what the signal would look like.

3. Fine-tuning the scales
   After Autoset, we adjusted the scales manually to get a clearer view:
   • If the signal looked too tall or too flat → adjust VOLTS/DIV
   • If the signal looked too compressed or too stretched → adjust TIME/DIV
   This took some trial and error at first, but it became more intuitive once we understood what each knob does.
   
   
4. Reading the measurements
   The Measure function automatically calculates values like Vmax, Vrms, frequency, duty cycle, and rise time. We did not have to calculate anything manually — the oscilloscope did it for us and displayed the values on the right side of the screen.

The first test was with the push button on pin 🖰 D0. A digital signal has only two possible states — 0 (LOW, 0V) or 1 (HIGH, 3.3V). There is nothing in between. Every time the button was pressed, the signal jumped instantly from 0V to 3.3V, and when released it dropped back to 0V.

On the oscilloscope screen, this looked like a series of clean square pulses. By adjusting TIME/DIV we could zoom in to see individual presses more clearly, or zoom out to see multiple pulses at once. We also used the trigger function to freeze a specific moment of the signal on screen, which made it easier to analyze.

The second test was with the potentiometer on pin 🖰 A1. Unlike the button, the potentiometer generates a continuously varying signal — it can be any value between 0V and 3.3V depending on how far it is rotated.

On screen, this looked completely different from the button. Instead of square pulses, we saw a smooth curve that changed as the potentiometer was turned. Rotating slowly produced a gradual wave, and rotating quickly produced a steeper one. The signal never snapped to a fixed value — it always transitioned smoothly, which is exactly what an analog signal is.

This assignment helped me understand the difference between digital and analog signals more clearly. Seeing the signals directly on the oscilloscope made it easier to relate what the code does with what is actually happening in the circuit. I also learned how basic oscilloscope controls such as VOLTS/DIV, TIME/DIV, Trigger, and Autoset affect the visualization of the signal and help obtain more stable and readable measurements. Finally, I understood that the oscilloscope is useful not only for measuring signals, but also for debugging and verifying how a circuit behaves in real time.

In electronics, an input device is any component that allows a microcontroller to receive information from the physical world. Without input devices, a microcontroller can only execute a fixed set of instructions. Input devices can measure different physical quantities such as temperature, light, distance, pressure, sound, or motion. The microcontroller reads this data, processes it, and uses it to make decisions. The data always flows in one direction: from the physical world into the microcontroller. This is what defines it as an input, in contrast to output devices like LEDs or motors, where the flow is reversed.

Some common examples of input devices include:

• A button — detects when it is pressed
• A temperature sensor — measures ambient temperature
• A distance sensor — measures proximity or range
• An accelerometer — measures acceleration and movement

🔎 In this week's assignment, the input device used is an accelerometer, which will be explained in the following sections.

My final project is a therapeutic robot designed to interact with children and respond according to their emotional state. One of the emotions it addresses is anger, which is divided into three intensity levels — low, medium, and high — since the response needs to match how the child is feeling at that moment.

To measure this in a physical way, the robot uses a toy accessory that the child interacts with during the session. The idea is simple: when a child is angry, they tend to move or handle objects with greater force. An accelerometer can capture this behavior by measuring the intensity of movement — higher acceleration corresponds to more intense motion.

Based on these readings, the robot can trigger different therapy responses.

This Week's Goal

This week's work focused on adding a sensor to a custom-designed microcontroller board and reading its output. The goal was to verify that the MPU-6050 can reliably detect three levels of movement using the board and translate them into a clear visual output through an RGB LED — green, blue, or red — before integrating this logic into the full robot.

The design and fabrication process for this board followed the same workflows covered in Week 6 (Electronics Design) and Week 8 (Electronics Production). The schematic was created in KiCad, the PCB was routed, and the board was milled and assembled in the fab lab. For more detail on these steps, refer to Week 6 and Week 8 documentation.

The accessory board was designed to be compact and to connect directly to the main robot board. Its main components are:

The MPU6050 is a 6-axis Inertial Measurement Unit (IMU). It combines a 3-axis accelerometer and a 3-axis gyroscope in a single chip. For this project, only the accelerometer is used.

The accelerometer measures forces along three axes — X, Y, and Z — and returns a value for each. By combining these three values into a single magnitude, we get a number that represents the total intensity of movement regardless of direction:

The MPU6050 communicates with the microcontroller using I2C (Inter-Integrated Circuit), a two-wire serial protocol designed for short-distance communication between chips on the same board:

• SDA (Serial Data Line) — carries the actual data back and forth between the sensor and the microcontroller
• SCL (Serial Clock Line) — provides the timing signal that keeps both devices synchronized

The MPU6050 module has 8 pins, but only 4 are needed for basic operation: VCC, GND, SDA, and SCL. The remaining pins (XDA, XCL, AD0, INT) are left unconnected. The module connects to the board through the J1 connector using four cables:

1. Libraries

• Wire.h — handles the I2C communication between the XIAO and the MPU6050
• MPU6050.h + I2Cdev.h — give us simple functions to talk to the sensor, so we don't have to write complex low-level code ourselves

2. Reading the Sensor

The MPU6050 gives us three numbers: the acceleration on the X, Y, and Z axes. Instead of working with three separate values, we combine them into one single number that represents the total movement intensity, regardless of direction.

3. Smoothing the Data

Sensor readings are not perfectly stable — they can jump slightly from one reading to the next even without real movement. To fix this, the code keeps a list of the last 5 readings and works with their average instead of reacting to each one individually.

4. Deciding the Level

Once we have the smoothed value, the code decides which level it belongs to — Green, Blue, or Red. To avoid flickering at the boundaries, it uses different thresholds to go up versus go down between levels.

5. Controlling the LED

Finally, the code turns on the correct color based on the current level. Because the RGB LED is common anode, the logic is inverted — a pin set to LOW turns the color ON, and HIGH turns it OFF. The setRGB() function handles this internally.

Problem 1 — Compilation error with pin numbers and MPU6050 not detected

When defining the LED pins at the top of the code using plain integers, Arduino threw this error when trying to compile: "wrong type argument to unary minus". This was confusing because the numbers looked correct. The issue is that on the XIAO ESP32S3, plain integers like 7, 8, 9 are not always interpreted as GPIO pin numbers — the board package needs the D prefix to resolve them correctly. The same problem appeared with the I2C initialization. Wire.begin(4, 5) compiled without errors but the sensor was never found.

✅ Fix

Replace the plain numbers with the D notation — D7, D8, D9 for the LED pins, and Wire.begin(D4, D5) for the I2C bus. Both issues were caused by the same root problem and were fixed the same way.

Problem 2 — LED flickering between Green and Blue

The LED kept switching rapidly between green and blue even without any real movement. The sensor at rest already reads ~9.8 m/s² due to gravity, and the threshold to switch to Blue was set at 11 m/s². That gap is very small, so tiny natural vibrations were enough to cross it back and forth dozens of times per second.

• Gentle movement → small increase above 9.8 → Blue
• Strong shake → large increase above 9.8 → Red

The goal is not to measure displacement, but the intensity of interaction. The MPU-6050 captures that force, and the system translates it into three clear response levels.