Week 09 – Input Devices

Assignment and Learning Outcomes

The weekly assignment is:

• Group assignment:
  • Probe an input device’s analog levels and digital signals.
  • As a minimum, demonstrate the use of a multimeter .
  • Optionally, use a logic analyzer for digital communication signals.
• Individual assignment:
  • Measure something: add a sensor to a microcontroller board that you have designed and read it.

The learning outcomes are:

• Understand how to interface input devices to a microcontroller.
• Measure and interpret analog and digital sensor signals.
• Read a physical property through a sensor and process it with code.

Checklist

In this page I answer the required questions:

• Linked to the group assignment page.
• Documented what I learned from interfacing an input device to my microcontroller.
• Documented my design and fabrication process or linked to a previous board.
• Explained how my code works.
• Explained the problems and how I fixed them.
• Included the original design files and source code.
• Included a hero shot of my board.

You can see the group documentation here:

• Group assignment – Input Devices

Group Assignment – Probing Analog Levels and Digital Signals

For the group assignment we analyzed the output of one or more input devices and observed their behaviour using laboratory instruments. The goal was to understand how a sensor or input device behaves electrically, both in analog and digital form.

At minimum, we demonstrated the use of a multimeter we haven´t in Ponferrada osciloscope for try it maybe in the next weeks we will get One. We also reviewed the use of a logic analyzer for digital signals when applicable.

Equipment Used

• Multimeter to measure voltage and continuity.
• Logic analyzer to inspect digital communication signals.
• Microcontroller board with sensor / input device connected.
• Jumper wires and USB connection.

What We Tested

• Analog levels from an input device output pin.
• Digital transitions on communication or switching pins.
• The relationship between the physical property and the measured electrical signal.

Multimeter

First, we used the multimeter to identify the main electrical values present in the circuit: power supply voltage, continuity between lines, and the voltage changes produced by the sensor.

1. Connect the multimeter ground reference to the board GND.
2. Measure the board supply voltage.
3. Probe the sensor output pin.
4. Observe how the voltage changes when the physical condition changes.

Logic Analyzer

For digital signals, especially when using communication protocols, the logic analyzer is very useful because it allows us to inspect logic states, timing, and protocol decoding.

In our case, we also reviewed how the logic analyzer can help verify whether a sensor is sending correct digital information to the microcontroller.

What I Learned from the Group Assignment

• The multimeter is useful for checking static voltages and continuity, but it does not show signal shape over time.
• The logic analyzer is especially useful for digital communications and signal timing.
• Good grounding and correct reference connections are essential to obtain stable measurements.
• The measured electrical signal is directly related to the physical property sensed by the device.

This group assignment helped me understand that reading a sensor is not only about writing code. It is also about knowing what the signal looks like electrically and how the hardware behaves in real conditions.

Individual Assignment – Measure Something

For the individual assignment I added a sensor to a microcontroller board that I had designed and I read the sensor values using code.

My goal this week was to connect a sensor that could also be useful for my final project, following the recommendation from the local instructors.

In this case I used a RGB Color sensor connected to a Seeed XIAO RP2040 . The sensor measures colors , and I read the values through the microcontroller using the Arduino environment.

• Sensor: TCS34725
• Board: Seeed XIAO RP2040
• Signal type: Digital I2C
• Output: Serial monitor reading / plotted values

Board Design and Fabrication

This week I followed a workflow similar to previous electronics weeks. I designed the board in KiCad, prepared the manufacturing files, milled the PCB, soldered the components, and tested the system.

If the board had already been designed in a previous week, this assignment builds on that base by adding the sensor and the necessary connections.

Design Workflow

1. Design the sensor board or adapt a previous board in KiCad.
2. Use the Fab Library for compatible symbols and footprints.
3. Route the traces according to our milling constraints.
4. Export the design files for fabrication.
5. Convert Gerbers if needed and prepare the PNG files for Mods CE.
6. Mill the board and solder the components.

Main Elements of the Board

• Microcontroller module or custom MCU circuit.
• Power connections.
• Sensor input pin and communication bus.
• Programming / debugging header.
• LED or button for debugging.

For the fabrication process I used the same PCB production workflow as in the previous electronics assignment.

Fabrication and Soldering

After finishing the design, I fabricated the board using the in-house PCB milling workflow. Then I soldered the microcontroller connections, sensor, and the remaining components.

Fabrication Workflow

• Export traces and outline.
• Generate the toolpaths in Mods CE.
• Mill the PCB on the machine.
• Clean the board after milling.
• Solder the components carefully.
• Inspect the board for shorts and bad joints.

Interfacing the Sensor

The next step was to connect the sensor to the microcontroller and verify that the board could read the signal correctly.

Depending on the type of sensor, the signal can be:

• Analog, where the voltage level changes continuously with the physical property.
• Digital, where the sensor sends logic states or protocol-based data.

Electrical Connection

• VCC connected to the board supply voltage.
• GND connected to common ground.
• Signal pin connected to the corresponding microcontroller input.

In my case, the sensor output was connected to / SDA-SCL / and power . This allowed the microcontroller to read the physical variable and print the values through the Arduino Serial Monitor.

Code and Reading the RGB Sensor (TCS34725)

To test the RGB color sensor TCS34725, I wrote a program using the Arduino IDE. Unlike a simple analog sensor, this device communicates via I2C, allowing us to read precise values for red, green, blue, and overall light intensity.

How the Code Works

1. The program includes the required libraries: Wire.h for I2C communication and Adafruit_TCS34725.h to control the sensor.
2. An instance of the sensor is created with a specific integration time and gain to adjust sensitivity.
3. In setup(), the serial communication is initialized and the sensor is started using tcs.begin().
4. If the sensor is not detected, the program stops and displays an error message.
5. In loop(), the sensor continuously reads raw color data: red (R), green (G), blue (B), and clear/light (C).
6. The measured values are formatted and sent to the Serial Monitor for visualization.
7. A short delay is added to make the readings easier to observe.

Example Code

    

	

		Arduino color sensor XIAO-RP2040
		
			Show code
			Copy
		
	

	

		
		
#include <Wire.h>
#include "Adafruit_TCS34725.h"

// Sensor configuration (integration time and gain)
Adafruit_TCS34725 tcs = Adafruit_TCS34725(
  TCS34725_INTEGRATIONTIME_50MS,
  TCS34725_GAIN_4X
);

void setup() {
  Serial.begin(115200);
  delay(2000);

  // Initialize the sensor
  if (!tcs.begin()) {
    Serial.println("Error: TCS34725 not found");
    while (1);
  }

  Serial.println("Sensor initialized");
}

void loop() {
  uint16_t r, g, b, c;

  // Read raw RGB and clear light values
  tcs.getRawData(&r, &g, &b, &c);

  // Print formatted values
  Serial.print("Red: ");
  Serial.print(r);

  Serial.print(" , Green: ");
  Serial.print(g);

  Serial.print(" , Blue: ");
  Serial.print(b);

  Serial.print(" , Lumen: ");
  Serial.println(c);

  delay(500);
}