TTP229 Touch Pad - 2025.05.05

#pragma once
// TTP229 16-Key Touch Pad
// info@muman.ch, 2025.05.06

/*
SERIAL INTERFACE
The keypad has a 2-wire interface with clock and data signals.
It is not I2C or SPI!
To start, it toggles the data line low/high, then each data bit is
clocked out on the falling edge of clock.
The start pulse is only 70..100uS (it is 70uS on my module). This 
is much too short to be polled - most pulses will be missed if the 
microcontroller is doing anything else at all. 
To solve this problem, an interrupt is used to detect the rising edge. 
Once detected, you have several milliseconds to clock in the key data.
Note that not all pins can be used as interrupts. This depends on the 
microcontroller. For example, on the Uno only pins 2 and 3 can be used 
for interrupts.

JUMPERS
The keypad's behaviour can be configured by tying certain key pins 
(TPx) to GND via a 1 Meg ohm resistor. Most modules already have the 
pull-down resistors fitted, so only the jumper is needed.
See the data sheet for details.

DATA SHEET
https://www.sunrom.com/download/SUNROM-TTP229-BSF_V1.1_EN.pdf

USAGE EXAMPLE
  #include "TTP229TouchPad.h"
  using namespace MattLabs;
  TTP229TouchPad touchPad;

  void setup() 
  {
    // interrupt data pin 2
    // clock pin 4
    // 16 keys (jumper TP2 is in)
    touchPad.begin(2, 4, 16);
  }

  void loop 
  {
    // Poll using touched(), then use readKeys() to get the key
    // depressions, one bit for each key bit15=key16..bit0=key1
    if (touchPad.touched()) {
      unsigned int key = touchPad.readKeys();
    }
  }
*/

namespace MattLabs
{
	class TTP229TouchPad
	{
	private:
		int datPin, clkPin;
		int numKeys;
		unsigned long tRisingEdge;
		bool readBit();
		static void risingEdgeInterrupt();
		static unsigned long tLastRisingEdge;
		static bool risingEdge;

	public:
		void begin(int dataPin, int clockPin, int numberOfKeys);
		bool touched();
		unsigned int readKeys();
	};

	unsigned long TTP229TouchPad::tLastRisingEdge = 0;
	bool TTP229TouchPad::risingEdge = false;

	// Set 'numberOfKeys' to 8 or 16 according to the TP2 jumper
	void TTP229TouchPad::begin(int dataPin, int clockPin, int numberOfKeys)
	{
		datPin = dataPin;
		clkPin = clockPin;
		numKeys = numberOfKeys;
		tRisingEdge = 0;

		pinMode(datPin, INPUT);
		pinMode(clkPin, OUTPUT);
		digitalWrite(clkPin, 1);	// active low, falling edge clock

		attachInterrupt(digitalPinToInterrupt(datPin), risingEdgeInterrupt, RISING);
	}

	// Rising edge interrupt
	// register only after 32mS (Tresp for 16 keys)
	void TTP229TouchPad::risingEdgeInterrupt()
	{
		unsigned long t = micros();
		unsigned long elapsed = t - tLastRisingEdge;
		// skip the data pulses
		if (elapsed < 32000)
			return;
		tLastRisingEdge = t;
		risingEdge = true;
	}

	// Did we get a rising edge interrupt?
	// Has a key been pressed or released?
	bool TTP229TouchPad::touched()
	{
		noInterrupts();
		bool b = risingEdge;
		risingEdge = false;
		interrupts();
		return b;
	}

	// Reads 8 or 16 keys according to 'numberOfKeys'
	// returns a bit for each key, bit15=key16..bit0=key1
	// returns 0 if all keys released
	// this takes about 75uS
	unsigned int TTP229TouchPad::readKeys()
	{
		if (!digitalRead(datPin)) {
			// should be high after rising edge
			return 0;
		}
		delayMicroseconds(10);	// Tw

		unsigned int keys = 0;
		unsigned int mask = 1;
		for (int i = 0; i < numKeys; ++i) {
			if (readBit())
				keys |= mask;
			mask <<= 1;
		}
		return keys;
	}

	// Clocks in a single bit
	bool TTP229TouchPad::readBit()
	{
		digitalWrite(clkPin, LOW);
		delayMicroseconds(2);
		bool b = !digitalRead(datPin);
		digitalWrite(clkPin, HIGH);
		delayMicroseconds(2);
		return b;
	}

}