Yes — what you’re describing is very doable, and there are multiple ways to build or buy it depending on your exact needs. Here’s a breakdown of how you can approach it:

You want:

1. A touch-sensitive surface you can draw on with your fingertip.
2. A way to capture that drawing as a 2D matrix of dots (i.e., pixels).
3. A button or trigger that sends that matrix to another device (e.g. to display, transmit, or save).

• Touchpad or digitizer (e.g. old laptop trackpad, Wacom tablet, or DIY resistive/capacitive pad)
• Microcontroller with USB or SPI support (e.g. Arduino, ESP32, or Raspberry Pi Pico)

• You draw a shape or letter on the pad.
• It captures the path or the touch pressure coordinates.
• On trigger (e.g. button press), the device converts this path to a bitmap or dot matrix.
• The matrix is sent via serial, SPI, I²C, or even RF/Bluetooth depending on your setup.

• 2.4" or 3.5" resistive touchscreen LCD with SPI or parallel interface (common in Arduino projects)
• Can be used with Arduino Uno, Mega, or STM32

• The screen detects finger pressure.
• On drawing, it samples X-Y coordinates and maps them to pixels.
• On button press, a bitmap of drawn region is converted to a matrix (e.g. 128×64 dots).
• You send the data wherever you want.

• Draw with a finger on a touchscreen laptop or tablet.
• Use a small Python script to convert drawn stroke to matrix of dots.
• Press keyboard or on-screen button to send the matrix via serial (USB, Bluetooth).

• Binary (0 = off, 1 = on)
• Hexadecimal byte rows
• ASCII art
• Raw bitmap for OLED/LED display

Example 5×7 matrix for "A":

00100
01010
10001
11111
10001
10001
10001

Using an ESP32 + Capacitive Touch + OLED:

• ESP32 handles touch grid.
• When you draw, it maps touches to pixels on a small 32×32 or 64×64 array.
• Button sends it via UART or displays on OLED.

• MakeyMakey or M5Stack TouchPad
• Adafruit 2.8" TFT Touch Shield
• Wacom Bamboo Slate (digitizes paper drawings)

Would you like help building a schematic, code sample, or recommendation for a part that fits your use case (e.g. Z80 or Arduino)?

Yes, absolutely — you can build a touch-sensitive grid using copper pads or tracks, and detect fingertip touches to generate a binary matrix. This is actually a classic method for DIY input surfaces, and here’s exactly how it can work.

You create a grid of horizontal and vertical copper strips or pads — say, a 5×5 or 8×8 matrix. Each intersection represents a "pixel" or bit.

When you touch across a horizontal and vertical line (or bridge two pads), you complete a circuit (via your finger's skin conductivity or pressure), and the microcontroller detects this intersection as "touched".

• Lay out horizontal and vertical copper strips or traces on a PCB or even on a plastic/wood surface using copper tape.

• Keep a small gap at each crossing (not physically connected).

• Your finger bridges the horizontal and vertical at the point of touch.

• Use a row/column scanning approach:

  • Drive one row HIGH, all others LOW or Hi-Z.

  • Read all columns. If a touch bridges a row and column, you’ll see the column pin pulled high.

  • Repeat for each row.

This is the same technique used in keypad matrix scanning.

• Allocate a buffer in RAM, e.g., uint8_t matrix[8] for an 8×8 grid.

• When touch is detected at (row, col), set the corresponding bit:

  matrix[row] |= (1 << col);  // Set the touched bit
  

• Add a button wired to the microcontroller.

• On press:

  • The matrix is frozen

  • Output it over serial, SPI, or save it

  • Or send to display/OLED

• Use digital pins for rows/columns.

• Skin completes the circuit (weakly) between a HIGH row and a floating column.

• You may need pull-down resistors or high-impedance reads.

• Measure capacitance change at each intersection.

• More complex but allows no-pressure touch (like phone screens).

• Requires analog readings or a touch-sensing IC (e.g. TTP229).

Say you touch the letter "L" on a 5×7 pad grid:

1 0 0 0 0  
1 0 0 0 0  
1 0 0 0 0  
1 0 0 0 0  
1 0 0 0 0  
1 1 1 1 0  

You can store that in your matrix[7] buffer and send it or display it.

• Finger-drawn characters as dot matrix input for Z80/OLED

• DIY stylus interface

• Music sequencer pad

• Replacement for a keyboard matrix

Would you like me to help:

• Design the schematic?

• Write code to scan such a grid?

• Adapt this to Z80 assembly?

Let me know how far you want to take this.

We can — and in fact, that’s the basis of capacitive touch sensing, the same tech used in smartphone screens and touch buttons.

Here’s how and why it works:

Your body holds an electric charge and acts like a grounded capacitor plate. When you bring your finger close to a PCB pad, it changes the capacitance of that pad relative to ground.

The microcontroller can detect this tiny change — that’s capacitive touch sensing.

1. Each copper pad on the PCB holds a small electrical field.

2. When a finger approaches or touches it:

   • It adds capacitance to the system (like adding a second capacitor plate).

   • This slows down charging/discharging of that node.

3. The microcontroller measures how long it takes the pad to charge or discharge.

4. A threshold is set: if capacitance is above a certain point → Touch detected.

• Use CapacitiveSensor or touchRead() (ESP32)

• Connect each pad to a GPIO pin

• Finger touch increases capacitance

• Software detects the delay in response

int val = touchRead(T0); // ESP32 built-in capacitive pin
if (val < threshold) {
  // Finger touched
}

• Build a simple RC (resistor-capacitor) circuit on each pad.

• When a finger touches the pad:

  • Capacitance goes up → RC time constant increases

  • Detect longer rise/fall time with a microcontroller

• ICs like TTP223, TTP229, CAP1208, or AT42QT1070

• They handle all the sensing, debouncing, and thresholds

• Output a clean HIGH/LOW signal per pad

You can make a 7×14 capacitive touch grid using just PCB pads and software scanning. Want help drawing the actual pad layout or picking a microcontroller with 14+ capacitive inputs?