Week 9 Assignments - Input Devices

Group Assignment

The group assignment for this week was to:

• Probe an input device(s)'s analog levels and digital signals
• Document your work on the group work page and reflect on your individual page what you learned

Outcomes

Link to Group Site

The group assignment page for this week is on the 2025 Charlotte Super Fab Lab group site for Week 9 - Input Devices.

What Was Learned

In the group assignment, we considered 3 types of input devices: digital, analog, and I2C. We were able to see how the signals look for the different types of inputs. This provided us the experience on:

• How to use test equipment to measure these types of input signals
• What to look for in these types of signals as part of assignments and project work going forward

Individual Assignment

The individual assignment for this week was to:

• Measure something: add a sensor to a microcontroller board that you have designed and read it.

Outcomes

Integrated Button Sensor

I selected a button as the input to test. The button used from the Fab Inventory is the B3SN-3112P.

The button connection was integrated into the design of the XIAO ESP32C3 microcontroller board that I designed in week 6 (Electronics Design) and produced in week 8 (Electronics Production). One side of the button has a connection to the XIAO 3.3V power line. The other side of the switch is connected to the XIAO pin D7 (GPIO20) for reading the input voltage. The D7 pin side is also connected to a ground through a 10K pulldown resistor, in order to provide a consistent low voltage value when the button is not pressed. The XIAO can then read the state of the button - 3.3V (HIGH) when pressed and 0V (LOW) when not pressed.

In order to measure the button sensor, I used the Arduino IDE to program the XIAO board. The Arduino IDE provides a set of example programs for inputs. I adapted the DigitalReadSerial example program to measure the button input.

Primary changes were:

• update pin designation for XIAO board / connection (D7)
• added print statments with conditional to describe button state and show the digital read value
• increase delay to better see individual readings

/*
  DigitalReadSerial

  Reads a digital input on pin 2, prints the result to the Serial Monitor

  This example code is in the public domain.

  https://www.arduino.cc/en/Tutorial/BuiltInExamples/DigitalReadSerial

*/

// digital pin 2 has a pushbutton attached to it. Give it a name:
// pin D7 for XIAO ESP32C3
int pushButton = D7;

// the setup routine runs once when you press reset:
void setup() {
  // initialize serial communication at 9600 bits per second:
  Serial.begin(9600);
  // make the pushbutton's pin an input:
  pinMode(pushButton, INPUT);
}

// the loop routine runs over and over again forever:
void loop() {
  // read the input pin:
  int buttonState = digitalRead(pushButton);
  // print out the state of the button:
  Serial.print("Button is ");
  if (buttonState == LOW)
  {
    Serial.print("NOT ");
  }
  Serial.print("pressed.  Value = ");
  Serial.println(buttonState);
  delay(500);  // delay in between reads for stability
}

The measured outputs of the button can be seen in the serial monitor of the Arduino IDE.

Because a button signal can be noisy in the periods when electrical contact is made or released, it can be important to "debounce" the button signal in order to ensure the signal represents a press or release. The previous code had a slight delay between readings to allow settling of the signal.

To do more explicit debouncing, the following code was adapted from the Arduino IDE example program for Debounce. A reading is only shown when there is a (debounced) change in button state.

Primary changes were:

• update pin designation for XIAO board / connection (D7)
• for properly debounced changes, added print statments with conditional to describe button state and show the digital read value
• remove unused code for LED blink

/*
  Debounce

  Each time the input pin goes from LOW to HIGH (e.g. because of a push-button
  press), the output pin is toggled from LOW to HIGH or HIGH to LOW. There's a
  minimum delay between toggles to debounce the circuit (i.e. to ignore noise).

  The circuit:
  - LED attached from pin 13 to ground through 220 ohm resistor
  - pushbutton attached from pin 2 to +5V
  - 10 kilohm resistor attached from pin 2 to ground

  - Note: On most Arduino boards, there is already an LED on the board connected
    to pin 13, so you don't need any extra components for this example.

  created 21 Nov 2006
  by David A. Mellis
  modified 30 Aug 2011
  by Limor Fried
  modified 28 Dec 2012
  by Mike Walters
  modified 30 Aug 2016
  by Arturo Guadalupi

  This example code is in the public domain.

  https://www.arduino.cc/en/Tutorial/BuiltInExamples/Debounce
*/

// constants won't change. They're used here to set pin numbers:
const int buttonPin = D7;  // the number of the pushbutton pin

// Variables will change:
int ledState = HIGH;        // the current state of the output pin
int buttonState;            // the current reading from the input pin
int lastButtonState = LOW;  // the previous reading from the input pin

// the following variables are unsigned longs because the time, measured in
// milliseconds, will quickly become a bigger number than can be stored in an int.
unsigned long lastDebounceTime = 0;  // the last time the output pin was toggled
unsigned long debounceDelay = 50;    // the debounce time; increase if the output flickers

void setup() {
  pinMode(buttonPin, INPUT);

  Serial.begin(9600);
}

void loop() {
  // read the state of the switch into a local variable:
  int reading = digitalRead(buttonPin);

  // check to see if you just pressed the button
  // (i.e. the input went from LOW to HIGH), and you've waited long enough
  // since the last press to ignore any noise:

  // If the switch changed, due to noise or pressing:
  if (reading != lastButtonState) {
    // reset the debouncing timer
    lastDebounceTime = millis();
  }

  if ((millis() - lastDebounceTime) > debounceDelay) {
    // whatever the reading is at, it's been there for longer than the debounce
    // delay, so take it as the actual current state:

    // if the button state has changed:
    if (reading != buttonState) {
      buttonState = reading;
      // print out the state of the button:
      Serial.print("Button is ");
      if (reading == LOW) {
        Serial.print("NOT ");
      }
      Serial.print("pressed.  Digital Read Value = ");
      Serial.println(reading);
    }
  }

  // save the reading. Next time through the loop, it'll be the lastButtonState:
  lastButtonState = reading;
}

External Photoresistor Sensor

My design of the XIAO ESP32C3 microcontroller board included integration of external connectors for power from the board (3.3V, 5V, GND), as well as for general I/O pins (D0-D2/A0-A2, D3-D5, and D8-D10). These connectors can be used to interface with external sensor modules.

A photoresistor changes resistance in response to light levels on the receptor - resistance lowers as the light level increases. So, light levels can be sensed by changes in the resistance level of the photoresistor. In order to sense how the resistance changes in response to light levels, a voltage divider circuit can be used. The photoresistor is coupled in series with a fixed resistor and the voltage level between the two resistances is measured. The measured output voltage is directly related to the value of the resistors. When light levels change, the resistance of the photoresistor changes, and this causes a change in the measured voltage level that can be observed as an analog input to the XIAO board.

A photoresistor breakout board from an Elegoo 37 in 1 Sensor Modules Kit was used for the sensing component. The breakout board includes both the photoresistor and fixed resistor in series as a voltage divider. The breakouut board was connected directly to the XIAO development board with female-to-male Dupont Wire.

In order to measure the photoresistor sensor, I used the Arduino IDE to program the XIAO board. The Arduino IDE provides a set of example programs for inputs. I adapted the AnalogReadSerial example program to measure voltage / resistance / light level changes.

Primary changes were:

• Added min / max reading values
• Added serial outputs for min / max values along with the sensor reading value
• Increased the delay to better see reading changes

/*
  AnalogReadSerial

  Reads an analog input on pin 0, prints the result to the Serial Monitor.
  Graphical representation is available using Serial Plotter (Tools > Serial Plotter menu).
  Attach the center pin of a potentiometer to pin A0, and the outside pins to +5V and ground.

  This example code is in the public domain.

  https://www.arduino.cc/en/Tutorial/BuiltInExamples/AnalogReadSerial
*/

const int photoResistorPin = A0;

const int minReading = 0;
const int maxReading = 4096;

// the setup routine runs once when you press reset:
void setup() {
  // Initialize Sensor Connection
  pinMode(photoResistorPin, INPUT);

  // initialize serial communication at 9600 bits per second:
  Serial.begin(9600);
}

// the loop routine runs over and over again forever:
void loop() {
  // read the input on analog pin 0:
  int sensorValue = analogRead(photoResistorPin);
  // print out the value you read:
  Serial.print("Sensor_Value:");
  Serial.print(sensorValue);
  Serial.print(" Min:");
  Serial.print(minReading);
  Serial.print(" Max:");
  Serial.println(maxReading);
  delay(100);  // delay in between reads for stability
}

The Arduino IDE includes a 'serial plotter" that can do basic plotting of data that is output in the serial monitor. The plotter can plot multiple values, but changes axis values based on the currently visible data points, which can make outputs a bit difficult to follow. The plotter has very little parameterization for the graph characteristics, such as overall scale. In order to provide for some scaling, a constant minimum value (0) and a constant maximum value (4096) are plotted along with the light sensing data points.

The following graph with the serial plotter shows an initial ambient light level with the sensor facing sideways. The sensor is then turned up toward the room lights (increase) and covered several times with a hand (decrease), before being set down sideways to an ambient level.