Week 09 — Input Devices

Individual Assignment Requirements

• Measure something: add a sensor to a microcontroller board that you have designed and read it.
• Demonstrate workflows used in sensing with input devices and a microcontroller.
• Document the design and fabrication process of the board used.
• Explain how the code works.
• Include problems encountered and how they were solved.
• Provide original design files and source code.
• Include a hero shot of the board.

Learning Outcomes

• Understand how analog and digital signals are read by a microcontroller.
• Work with multiple types of sensors and input devices.
• Visualize sensor data using displays and serial tools.
• Relate physical phenomena (temperature, motion, position) to digital readings.

System Overview – Input Devices Integration

This assignment focuses on exploring how a microcontroller can sense and interpret physical phenomena through different types of input devices. For this purpose, I worked with both analog and digital sensors connected to a custom PCB designed in a previous week, using a XIAO ESP32C3 as the main processing unit.

System Workflow

The system follows a structured data flow:

• Sensor input: physical signals (position, temperature, motion)
• Microcontroller processing: ADC conversion or digital communication
• Data transformation: scaling, mapping, or filtering
• Output: OLED display visualization and Serial Plotter monitoring

The objective was to measure and visualize different variables such as position, temperature, humidity, and motion. Each sensor was tested individually and the acquired data was displayed in real time using an SSD1306 OLED display, as well as analyzed through the Arduino IDE Serial Plotter to better understand signal behavior.

This approach allowed me to compare how analog signals (continuous values) and digital signals (discrete communication protocols) are handled by the microcontroller, and how each type of sensor requires a different strategy for reading and processing data.

All experiments were implemented on the same hardware platform, enabling a modular and efficient workflow for testing multiple input devices without modifying the base system.

Complete system setup showing the custom PCB, XIAO ESP32C3, multiple input devices, and real-time visualization on the OLED display.

This assignment focuses on exploring how a microcontroller can sense and interpret physical phenomena through different types of input devices. For this purpose, I worked with both analog and digital sensors connected to a custom PCB designed and fabricated in a previous week (Week 08 – Electronics Production), using a XIAO ESP32C3 as the main processing unit.

Simulation Validation – Wokwi

Before implementing the circuits on physical hardware, all experiments were first simulated using Wokwi. This allowed me to validate both the code logic and the system behavior in a controlled environment.

By simulating the circuits, I was able to perform early debugging, verify pin configurations, test communication protocols (such as I2C), and ensure that each component behaved as expected before connecting it to the real PCB.

This approach significantly reduced development time and minimized the risk of hardware errors, such as incorrect wiring or component damage. It also provided a clearer understanding of signal flow and system interaction, especially when working with multiple devices simultaneously.

Using simulation as a first step helped bridge the gap between conceptual design and physical implementation, ensuring that the transition to real hardware was smoother and more reliable.

Experiment 1 – Potentiometer (Analog Input)

In this first experiment, I used a potentiometer as an analog input device to understand how continuous signals are read by the microcontroller. The potentiometer outputs a variable voltage depending on its position, which is converted into a digital value using the ADC (Analog-to-Digital Converter).

The XIAO ESP32C3 features a 12-bit ADC resolution, meaning the analog signal is mapped into a digital range from 0 to 4095. This allows a detailed and precise representation of the physical movement of the potentiometer.

The measured values were visualized in two ways: first, on an SSD1306 OLED display for real-time feedback, and second, using the Arduino IDE Serial Plotter, which allowed observing the continuous variation of the signal as the potentiometer was rotated.

This experiment demonstrates how analog inputs provide smooth transitions compared to digital signals, making them ideal for measuring variables such as position, light, or temperature.

Potentiometer connected to analog input pin (Wokwi simulation).

Circuit Connection

Potentiometer:
• VCC → 3.3V
• GND → GND
• Signal → D1 (ADC input)

Display SSD1306:
• VCC → 3.3V
• GND → GND
• SDA → D4 (I2C SDA XIAO)
• SCL → D5 (I2C SCL XIAO)

Program Code

// ANALOG READING (0 - 4095)
// POTENTIOMETER TEST

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

// DISPLAY CONFIG
#define heigth 64 
#define width  128
#define rst   -1
Adafruit_SSD1306 oled(width, heigth, &Wire, rst);

// PIN
#define potentiometer D0  

void setup() {
  boardBegin();

  Serial.println("POTENTIOMETER - ANALOG INPUT TEST");

  oled.clearDisplay();
  oled.setTextSize(2);
  oled.println("POTENTIOMETER");
  oled.println("ANALOG INPUT");
  oled.display();

  delay(4000);
}

void loop() {

  int sensorReading = analogRead(potentiometer);

  oled.clearDisplay();
  oled.setTextSize(1);
  oled.setCursor(0, 0);

  oled.println("POTENTIOMETER DATA");
  oled.println("RANGE : (0 - 4095)\n");

  oled.print("POSITION_LEVEL: ");
  oled.println(sensorReading);

  Serial.print("POSITION_LEVEL:");
  Serial.println(sensorReading);

  oled.display();

  delay(100);
}

void boardBegin(){

  pinMode(potentiometer, INPUT);

  Serial.begin(115200);
  Wire.begin();

  if(!oled.begin(SSD1306_SWITCHCAPVCC, 0x3C)){
    Serial.println("Oled Display NOT Found...");
    for (;;);
  }

  oled.setTextColor(WHITE);
  oled.clearDisplay();
  oled.setTextSize(1);
  oled.setCursor(5, 5);
}
  

Code Explanation

• Libraries and Communication: The Wire.h library enables I2C communication, which is required for the OLED display. The Adafruit_GFX and Adafruit_SSD1306 libraries provide high-level functions to control graphics, text rendering, and display buffer management.
• Display Initialization: The OLED display is defined as an object with a resolution of 128x64 pixels. Inside the boardBegin() function, the display is initialized using oled.begin() with the I2C address 0x3C. If the display is not detected, the program stops execution using an infinite loop, which is useful for debugging hardware connections.
• Pin Configuration: The potentiometer is connected to pin D0, which is configured as an input using pinMode(). This pin is used by the ADC to measure the analog voltage.
• Analog-to-Digital Conversion (ADC): The function analogRead() converts the input voltage into a digital value. Since the ESP32C3 uses a 12-bit ADC, the output range is from 0 to 4095. This means small variations in voltage are translated into fine numerical changes, allowing precise detection of the potentiometer position.
• Main Loop Behavior: In the loop() function, the system continuously reads the analog value, updates the display, and sends the data through the serial port. This creates a real-time feedback system where any physical interaction with the potentiometer is immediately reflected in both outputs.
• OLED Display Rendering: Before printing new data, the display buffer is cleared using oled.clearDisplay(). Text properties such as size and cursor position are configured with setTextSize() and setCursor(). The data is written into a memory buffer and only becomes visible when oled.display() is executed. This buffered approach prevents flickering and ensures smooth updates.
• Serial Communication and Plotting: The sensor value is sent using Serial.print() and Serial.println(). This allows the Arduino IDE Serial Plotter to interpret the incoming data as a continuous signal. As a result, the potentiometer movement can be visualized as a real-time graph, making it easier to analyze signal stability, noise, and responsiveness.
• Timing Control: A delay of 100 ms is introduced to control the refresh rate. This prevents excessive data flooding in the Serial Plotter and ensures stable visualization on the OLED display without flickering or performance issues.

System in Operation

Experiment 2 – Analog Temperature Sensor

In this experiment, I used an analog temperature sensor to measure thermal variation. Unlike the previous case, this sensor represents temperature as a continuous voltage signal, which is read by the microcontroller using the ADC.

Since no calibrated reference in degrees Celsius was available, a relative measurement approach was implemented. The system was normalized using a percentage scale, where 0% corresponds to ambient temperature and 100% corresponds to the temperature of a soldering iron when the sensor is placed close to it.

The ESP32C3 reads the analog signal with a 12-bit resolution (0–4095), and then the map() function is used to convert this raw range into a normalized scale from 0 to 100%. This allows an intuitive interpretation of temperature variation even without an absolute reference.

As in the previous experiment, the processed data is displayed on the OLED screen and simultaneously sent to the Serial Plotter, enabling visualization of how the temperature changes dynamically when the sensor is exposed to different heat sources.

Analog temperature sensor connected to the microcontroller (Wokwi simulation).

Circuit Connection

Analog Temperature Sensor:
• VCC → 3.3V
• GND → GND
• X Axe → D0 (ADC input)

Display SSD1306:
• VCC → 3.3V
• GND → GND
• SDA → D4 (I2C SDA XIAO)
• SCL → D5 (I2C SCL XIAO)

Program Code

// ANALOG READING (0 - 4095)
// TEMPERATURE NORMALIZATION (0 - 100%)

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

// DISPLAY CONFIG
#define heigth 64 
#define width  128
#define rst   -1
Adafruit_SSD1306 oled(width,heigth,&Wire,rst);

// PIN
#define sensor D0  

void setup() {
  
  boardBegin();

  Serial.println("TEMPERATURE SENSOR TEST");

  oled.clearDisplay();
  oled.println("TEMP SENSOR TEST");
  oled.display();

  delay(2000);
}

void loop() {

  int sensorReading = analogRead(sensor);

  // Map raw ADC values to percentage scale
  sensorReading = map(sensorReading, 1000, 250, 0, 100);

  oled.clearDisplay();
  oled.setCursor(0, 10);

  oled.println("TEMP SENSOR DATA");
  oled.println("RANGE : (0 - 100%)\n");

  oled.print("TEMPERATURE_LEVEL: ");
  oled.print(sensorReading);
  oled.println("%");

  Serial.print("TEMPERATURE_LEVEL:");
  Serial.println(sensorReading);

  oled.display();

  delay(100);
}

void boardBegin(){

  pinMode(sensor, INPUT);

  Serial.begin(115200);
  Wire.begin();

  if(!oled.begin(SSD1306_SWITCHCAPVCC, 0x3C)){
    Serial.println("Oled Display NOT Found...");
    for (;;);
  }

  oled.setTextColor(WHITE);
  oled.clearDisplay();
  oled.setTextSize(1);
  oled.setCursor(5, 5);
}
  

Code Explanation

• Reuse of Previous Structure: This program follows the same structure as the potentiometer experiment, including OLED initialization, Serial communication, and continuous reading inside the loop(). These elements are reused to maintain a consistent workflow for data acquisition and visualization.
• Analog Temperature Reading: The temperature sensor outputs a voltage that varies according to thermal conditions. This signal is read using analogRead(), producing a 12-bit value between 0 and 4095, similar to the previous experiment.
• Experimental Calibration: Instead of using predefined values, two reference points were obtained experimentally: ambient temperature (~1000) and soldering iron temperature (~250). These values define the working range of the sensor in this setup.
• Normalization using map(): The key difference in this experiment is the use of the map() function. This function converts the raw ADC values into a percentage scale from 0 to 100. The mapping is inverted (1000 → 0%, 250 → 100%) due to the sensor's response when exposed to heat.
• Relative Measurement Approach: Since no absolute temperature reference (°C) is available, the system works with a normalized scale. This allows interpreting temperature variation in a meaningful way without requiring precise calibration.
• Data Visualization: The mapped value is displayed as a percentage on the OLED screen and sent to the Serial Plotter. This makes it possible to observe how temperature changes over time as the sensor moves between ambient conditions and the heat source.

System in Operation

Experiment 3 – Joystick Control (Analog Input)

In this experiment, a joystick module was used as a dual analog input device to control the position of a square displayed on the OLED screen. The joystick contains two potentiometers, one for each axis (X and Y), allowing two-dimensional movement.

A key challenge in this experiment was understanding that the joystick has a mechanical return to its center position. This means that the analog reading cannot be directly mapped to the position of the square. Instead, the readings must be interpreted as relative changes (movement direction), not absolute position.

Initially, it was assumed that the center value would be exactly 2048 (midpoint of a 12-bit ADC). However, experimental measurements showed that the real center values were different for each axis (X ≈ 2222, Y ≈ 2159). This caused unintended movement of the square even when the joystick was not being touched.

This issue was solved by calibrating the center values and introducing a threshold range. Only when the deviation exceeds this threshold, the position of the square is updated, allowing stable and controlled movement.

The system also demonstrates how basic geometric shapes can be drawn on the OLED display using graphic functions, enabling simple interactive interfaces.

Joystick module connected as dual analog input (X and Y axes).

Circuit Connection

Joystick:
• VCC → 3.3V
• GND → GND
• X Axe → D1 (ADC input)
• Y Axe → D2 (ADC input)
• Select Button → D3 (digital input)

Display SSD1306:
• VCC → 3.3V
• GND → GND
• SDA → D4 (I2C SDA XIAO)
• SCL → D5 (I2C SCL XIAO)