Skip to content

Week 9, Input Devices

Objectives

Group assignment:

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 Individual assignment:

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

Group Assignment

In the group assignment we probed 3 different types of input devices, a digital, analog, and I2C. We did this on my dev board and were able to see how the signals should look when they are running properly and gives us a framework for how we might troubleshoot our circuits in the future.

Link to Group Assignment

Measure Something

I decided to explore buttons as my sensor to mesure something. I think this will be the most useful in my final project as I will be using buttons to change the colors or brightness of the LEDs on my camera device. So I wanted to explore both mechanical and capacitive touch options.

Momentary Button

I designed my dev board to have a momentary button so I used this as my measurement device. I set it up such that it is normally reading 0V (Low) and when it is pushed, it goes to 3.3V (High). The button is connected on the board to pin D6 which is also defined as GPIO 21 for defining it in code.

To test the button I wrote a little bit of code that will read the button, serial print the button state to the serial monitor and also turn on the onboard LED when pressed.

Button
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
int pushButton = 21;
int led= 20;

// 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);
  pinMode(led, OUTPUT);

for (int i =0; i<=2; i++){
  digitalWrite (led, HIGH);
  delay (500);
  digitalWrite (led, LOW);
  delay (500);
}

digitalWrite (led, LOW);
}

void loop() {
  // read the input pin:
  int buttonState = digitalRead(pushButton);
  // print out the state of the button:
  Serial.println(buttonState);
  if (buttonState== 1){
    digitalWrite (led, HIGH);
  }
  else{ 
    digitalWrite (led, LOW);
      }

  delay(10);        // delay in between reads for stability
}

While watching the serial monitor while the button is being pushed, it can be seen how the button state changes from 0 to 1 and back, and the LED on the board also reacts appropriately.

Serial output while reading the button

LED off with momentary not pressed.

LED on with momentary pressed.

I took this a step further and had the on-board Neopixel change color with the press of the button. This code was slightly modified from the ChatGPT prompt to "Write arduino code to use a button attached to pin 21 to change the color of an addressable led attached to pin 10 to change color each time the button is pressed. It should use the adafruit neopixel library and the button as an interrupt. The color should start red then change to orange, yellow , green, cyan , blue, magenta , purple, white, then off"

The code as giving by GPT was:

GPT Output
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
#include <Adafruit_NeoPixel.h>

#define LED_PIN     10
#define LED_COUNT   1
#define BUTTON_PIN  21

Adafruit_NeoPixel strip(LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800);

volatile bool buttonPressed = false;
volatile unsigned long lastInterruptTime = 0;
const unsigned long debounceTime = 200; // milliseconds

int colorIndex = 0;

uint32_t colors[] = {
  strip.Color(255, 0, 0),      // Red
  strip.Color(255, 165, 0),    // Orange
  strip.Color(255, 255, 0),    // Yellow
  strip.Color(0, 255, 0),      // Green
  strip.Color(0, 255, 255),    // Cyan
  strip.Color(0, 0, 255),      // Blue
  strip.Color(255, 0, 255),    // Magenta
  strip.Color(128, 0, 128),    // Purple
  strip.Color(255, 255, 255),  // White
  strip.Color(0, 0, 0)         // Off
};

void setup() {
  strip.begin();
  strip.show(); // Initialize all pixels to 'off'

  pinMode(BUTTON_PIN, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(BUTTON_PIN), handleButtonPress, FALLING);
}

void loop() {
  if (buttonPressed) {
    buttonPressed = false;

    // Change LED color
    strip.setPixelColor(0, colors[colorIndex]);
    strip.show();

    // Move to next color in the list
    colorIndex = (colorIndex + 1) % (sizeof(colors) / sizeof(colors[0]));
  }
}

void handleButtonPress() {
  unsigned long currentTime = millis();

  // Debounce check
  if (currentTime - lastInterruptTime > debounceTime) {
    buttonPressed = true;
    lastInterruptTime = currentTime;
  }
}

I modified it slightly with updated pin assignments and turning on the onboard LED.

xiao_devboard_button_and-Neos
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
#include <Adafruit_NeoPixel.h>

int pushButton = 21;
int led= 20;
int LED_COUNT= 1;
int LED_PIN= 10;

Adafruit_NeoPixel strip(LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800);

volatile bool buttonPressed = false;
volatile unsigned long lastInterruptTime = 0;
const unsigned long debounceTime = 200; // milliseconds

int colorIndex = 0;

uint32_t colors[] = {
  strip.Color(255, 0, 0),      // Red
  strip.Color(255, 165, 0),    // Orange
  strip.Color(255, 255, 0),    // Yellow
  strip.Color(0, 255, 0),      // Green
  strip.Color(0, 255, 255),    // Cyan
  strip.Color(0, 0, 255),      // Blue
  strip.Color(255, 0, 255),    // Magenta
  strip.Color(128, 0, 128),    // Purple
  strip.Color(255, 255, 255),  // White
  strip.Color(0, 0, 0)         // Off
};

// 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);
  pinMode(led, OUTPUT);

for (int i =0; i<=2; i++){
  digitalWrite (led, HIGH);
  delay (500);
  digitalWrite (led, LOW);
  delay (500);
}

digitalWrite (led, LOW);

//pinMode(BUTTON_PIN, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(pushButton), handleButtonPress, FALLING);

}

void loop() {

   if (buttonPressed) {
    buttonPressed = false;

    // Change LED color
    strip.setPixelColor(0, colors[colorIndex]);
    strip.show();

    // Move to next color in the list
    colorIndex = (colorIndex + 1) % (sizeof(colors) / sizeof(colors[0]));
  }
}

void handleButtonPress() {
  unsigned long currentTime = millis();

  // Debounce check
  if (currentTime - lastInterruptTime > debounceTime) {
    buttonPressed = true;
    lastInterruptTime = currentTime;
    digitalWrite (led, HIGH);
  }
}

Touch Sensing

I also wanted to explore the use of touch sensing as I feel like it could be a good option for changing modes for my final project.

My first instinct was to test out the Freetouch library. This was listed in the Fab Academy documents for the week and felt like a good place to start. Unfortunately, when I went to compile it for the XIAO ESP32C3 it would not compile. Then I explored other options and found the [CapacitiveSensor[(https://docs.arduino.cc/libraries/capacitivesensor/)] library. However, it too would not compile to the C3.

Compilation error when trying free touch.

I then tried to compile it for the XIAO SAMD21 and they both compiled. As I want to keep the wireless communication of the C3 for my project I wanted to find an alternative way. However, I can come back to this later if I want.

Then I remembered that using a simple analog soil moisture sensor would react to touch. I used these while delivered smart agriculture bootcamps a a simple way to test the sensor output was to just touch it an watch the values change.

So, I hooked up a soil moisture sensor from an Arduino kit we have in the lab and hooked it up to A0 on the C3. I uploaded my code for analog reading, and I could see a small but distinct change from about 4 counts to 18-26 counts. This is a small change (~.015V) but is predictable.

Analog Read
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
int sensorPin = 2;    // select the input pin for the potentiometer
int sensorPin2 = 3; 
int ledPin = 20;      // select the pin for the LED
int sensorValueA0 = 0;  // variable to store the value coming from the sensor
int sensorValueA1 = 0; 


void setup() {
  // declare the ledPin as an OUTPUT:
  pinMode(ledPin, OUTPUT);
  pinMode (sensorPin, INPUT);
  pinMode (sensorPin2, INPUT);

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

void loop() {
  // read the value from the sensor:
  sensorValueA0 = analogRead(sensorPin);
  sensorValueA1 = analogRead(sensorPin2);
  Serial.print("A0= ");
  Serial.print(sensorValueA0);
  Serial.print("     A1= ");
  Serial.println(sensorValueA1);

  delay(500);
}

Moisture sensor hooked up to test touch sensing.

Serial output from the sensor showing the increase when sensor was touched.

I took it a step further and added a red LED on pin D7 and used a 330 Ohm resistor to connect it to ground. Then I added some code for the LED to turn on when touched.

Analog Read
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
int sensorPin = 2;    // select the input pin for the potentiometer
int sensorPin2 = 3; 
int ledPin = 20;      // select the pin for the LED
int sensorValueA0 = 0;  // variable to store the value coming from the sensor
int sensorValueA1 = 0; 


void setup() {
  // declare the ledPin as an OUTPUT:
  pinMode(ledPin, OUTPUT);
  pinMode (sensorPin, INPUT);
  pinMode (sensorPin2, INPUT);

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

void loop() {
  // read the value from the sensor:
  sensorValueA0 = analogRead(sensorPin);
  sensorValueA1 = analogRead(sensorPin2);
  Serial.print("A0= ");
  Serial.print(sensorValueA0);
  Serial.print("     A1= ");
  Serial.println(sensorValueA1);

  if (sensorValueA0 > 11){
    digitalWrite(ledPin, HIGH);
  }
  else{
 digitalWrite(ledPin, LOW);
  }
  delay(500);
}

Once this was uploaded I could see that the LED was reacting to my touch. There is no reason it could not also be used to control the index of the different colored lights of the neopixel as was demostrated with the button above.

Testing the touch capability of the moisture sensor.

Manufactured Board

Before the end of the week the manufactured development board that I ordered from JLC PCB arrived! So, I quickly built one up and gave it a test. I used the same components that I built the one that I milled.

Bare boards when they arrived.

Fully populated board with XIOA installed.

I started by testing the LED pin with simple blink code and that worked. Then I uploaded the Neopixel color change with button push code from above and the button changed the color of the pixel on the board as I expected.

Testing the touch capability of the moisture sensor.