Input Devices

Why Not Just digitalRead()?

Copper pads without debounce or pull-up resistors are floating capacitive sensors, not digital switches. A raw digitalRead() produces flickering touch state and unreliable triggering. Several environmental factors all feed into the reading simultaneously:

• Humidity — changes the dielectric between finger and pad
• Grounding — whether you're on rubber, barefoot, touching metal
• Body capacitance — varies person to person: hand size, contact area, rings
• Laptop charger noise — switching supply noise couples into unshielded traces

Charge-time measurement reads a continuous value rather than a binary threshold. Environmental drift shifts the number, but the gap between untouched (~3–5) and touched (~20–140) stays large enough to threshold reliably.

The Charge-Time Method

The GPIO pin acts as both the charge source and the sensor:

1. Discharge: Set pin OUTPUT LOW. Drains any charge on the pad to ground.
2. Switch to INPUT_PULLUP: The internal pull-up (~30–50kΩ) begins charging the pad capacitance.
3. Count: Loop until the pin reads HIGH, until voltage crosses ~0.7×VCC.
4. Read: Count is proportional to τ = R × C. More capacitance (finger) → longer charge time → higher count.

Think of it like filling a bucket with a fixed-rate tap. Small bucket (no finger) fills fast. Big bucket (finger adds capacitance) fills slow. The count tells you the bucket size.

The OLED as Debugger

I ran a calibration sketch that wrote the raw count from each pad live to the display:

// Calibration sketch, live counts on OLED
u8g2.clearBuffer();
u8g2.setCursor(31, 30);
u8g2.print("L:"); u8g2.print(left);
u8g2.setCursor(31, 45);
u8g2.print("R:"); u8g2.print(right);
u8g2.sendBuffer();

With this running, I could watch the numbers change in real time as I touched and released each pad, with bare fingertip, full palm, through a sleeve, with the charger plugged in. The display updated every 20ms, fast enough to see the count respond to contact.

Measured Values

Across multiple conditions and people:

• No touch (noise floor): Left ~3–5, Right ~3–5
• Light fingertip graze: Left ~18–35, Right ~20–40
• Full pad contact: Left ~80–140, Right ~70–120

The gap between noise (~5) and a real touch (~20+) is large and consistent across conditions. Threshold set at 10 — comfortably above noise, triggered by even a light graze. Both pads must exceed threshold simultaneously to prevent accidental triggers from setting the board down.

readTouch() — The Core Sensing Function

Takes a pin number, runs the charge-discharge cycle, returns a count. The cap of 300 prevents an infinite loop if a wire is disconnected or a pad is shorted to VCC.

long readTouch(int pin) {
  pinMode(pin, OUTPUT);
  digitalWrite(pin, LOW);  // discharge pad to ground
  delay(1);

  pinMode(pin, INPUT_PULLUP); // start charging via internal ~40kΩ pull-up

  long count = 0;
  while (digitalRead(pin) == LOW && count < 300) {
    count++; // count loops until voltage crosses logic threshold
  }
  return count;
}

Detection Logic — Both Pads Required

A single-pad trigger is too easy to hit accidentally. Requiring both pads simultaneously changes the interaction from a tap to a deliberate two-hand hold — the card held between your palms.

long left  = readTouch(TOUCH_LEFT);   // pin 4
long right = readTouch(TOUCH_RIGHT);  // pin 5

bool touched = (left > 10) && (right > 10);

The Scrolling Marquee

When touched, the OLED draws a string at xPos and decrements xPos each frame. The bounds 31 and 95 are the left and right edges of the Grove OLED's visible crop window — the SSD1306 operates a 128×64 framebuffer but only X:31→95 is physically visible on the 64×48 panel. Full explanation in Week 10: Output Devices →

if (touched) {
  const char* message = facts[currentFact];
  u8g2.drawStr(xPos, 40, message);

  xPos -= 14; // 14px per frame at 20ms delay

  int textWidth = strlen(message) * 6; // 6x12 font: 6px per char

  if (xPos < -textWidth + 31) { // text has exited left edge of visible window
    currentFact++;
    if (currentFact >= factCount) currentFact = 0;
    xPos = 95; // reset to right edge of visible window
  }
} else {
  u8g2.drawStr(40, 40, "Hold Me");
}
u8g2.sendBuffer();
delay(20);

Full Source Code

#include <Arduino.h>
#include <U8g2lib.h>

U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(
  U8G2_R0,
  /* clock=*/ 9,
  /* data=*/ 8,
  /* reset=*/ U8X8_PIN_NONE
);

#define TOUCH_LEFT  4
#define TOUCH_RIGHT 5

const char* facts[] = {
  "Loves Gilda",
  "New To BCN",
  "From India",
  "FAB LAB Noob",
  "Loves Emotional Design",
  "Built This Board with sweat blood and tears",
  "Created Whiff",
  "Has Congenital Anosmia",
  "She/ Her/ A11y"
};

const int factCount = 8; // note: 9 strings, 8 cycle — "She/Her/A11y" unreachable (known bug)

int currentFact = 0;
int xPos = 95;

long readTouch(int pin) {
  pinMode(pin, OUTPUT);
  digitalWrite(pin, LOW);
  delay(1);
  pinMode(pin, INPUT_PULLUP);
  long count = 0;
  while (digitalRead(pin) == LOW && count < 300) count++;
  return count;
}

void setup() {
  delay(1000);
  u8g2.begin();
  u8g2.setFont(u8g2_font_6x12_tf);
}

void loop() {
  long left  = readTouch(TOUCH_LEFT);
  long right = readTouch(TOUCH_RIGHT);
  bool touched = (left > 10) && (right > 10);

  u8g2.clearBuffer();
  if (touched) {
    const char* message = facts[currentFact];
    u8g2.drawStr(xPos, 40, message);
    xPos -= 14;
    int textWidth = strlen(message) * 6;
    if (xPos < -textWidth + 31) {
      currentFact++;
      if (currentFact >= factCount) currentFact = 0;
      xPos = 95;
    }
  } else {
    u8g2.drawStr(40, 40, "Hold Me");
  }
  u8g2.sendBuffer();
  delay(20);
}

1. digitalRead() — flickering, unreliable UI

The first attempt used digitalRead() with a threshold. Touch state flickered, triggered inconsistently, and caused the UI to blink. Copper pads are floating capacitive sensors, not buttons, binary reads can't handle environmental drift. Fix: charge-time measurement. A continuous count robust to drift; the gap between noise and touch stays large regardless of charger noise or humidity.

2. USB serial never worked — no way to print debug values

USB CDC didn't enumerate on ATSAMD11 with NO_BOOTLOADER. Serial Monitor stayed blank the entire project. This would have been the expected calibration path, print counts, observe, set threshold. Fix: the OLED became the debugging surface. Ended up being faster: real hardware, real time, no driver indirection.

3. factCount = 8 with 9 facts, last fact unreachable

The array has 9 strings but factCount = 8, so "She/ Her/ A11y" never displays, the cycle wraps to 0 before reaching index 8. This is a known bug in the current code, documented here rather than silently fixed. The board still demonstrates the full concept correctly across the 8 cycling facts.