StackHack.ino

/*
The basic idea is: the signal is going to switch a bunch, then go idle for a while, and repeat.

The idle periods are always at least 10 milliseconds long, so we do the following:

We listen to the input and record the timing between each signal switch into a buffer.

Whenever it has been more than 10 ms from the last signal switch, we read the buffer contents,
parse the message to get the time, go back to the beginning of the buffer
and wait for the signal to start switching again to repeat the whole process.
*/

// Input from the timer
#define TIMER_IN 4

// Size of array that will keep track of timing between signal switches
#define BUFFER_SIZE 80

// Time (in microseconds) between input messages to start processing last message
#define TIME_BETWEEN_MESSAGES 10000

// Time (in microseconds) since last detected signal switch to enter standby
#define STANDBY_TIME 500000

// Serial reading variables
volatile unsigned long durationBuffer[BUFFER_SIZE] = { 0 };
volatile unsigned long currentSignalStart = 0;
volatile bool signalBuffer[BUFFER_SIZE] = { 0 };
volatile int currentBufferIndex = 0;

// Output display variables
uint8_t receivedDigits[6] = { 0 }; // Digits that were last received from the timer
bool parsed = false;
bool standby = false;

void IRAM_ATTR OnSignalSwitch()
{
	// Update duration
	unsigned long now = micros();
	durationBuffer[currentBufferIndex] = now - currentSignalStart; // Store time since last signal switch
	currentSignalStart = now;

	// Update signal
	signalBuffer[currentBufferIndex] = !digitalRead(TIMER_IN); // Previous signal is the opposite of the current signal
	
	// Increment index
	currentBufferIndex = currentBufferIndex + 1;
}

void setup()
{
	// Input pin that receives the timer signal
	pinMode(TIMER_IN, INPUT);
	attachInterrupt(TIMER_IN, OnSignalSwitch, CHANGE);

	Serial.begin(115200);
}

void InterpretDigits()
{
	/*
		Parse message received from timer through UART in the TIMER_IN pin.
		The timer sends 10 bits per byte, the first 2 always being "1 0", marking the start of the byte, and the next 8 being the byte itself.
		The signal stays idle between messages, so the first index of the buffers is skipped to avoid looping through a huge signal duration.
		The first bit that mark the start of the byte is ignored (as explained above), and the second one is bit 0.
		The first byte is composed by bits 1 to 8. The second one is bits 11 to 18, and so on.
		The bits of each byte are sent from LSB to MSB, so they need to be inverted when parsed.
		The MSB (last bit sent) of every byte is always 0, because no bytes sent by the timer are ever greater than 127.

		Each message is composed of 10 bytes:
			Byte  0      (bits  1 to  8): Timer status (running = 32, stopped/idle = 73, different timer brands might have more statuses).
			Bytes 1 to 6 (bits 11 to 18, 21 to 28 and so on): Timer digits, in ASCII, from the minute to the millisecond digit.
			Byte  7      (bits 71 to 78): A checksum of each digit value (raw value, not in ASCII), offsetted by 32.
			Bytes 8 and 9: Control characters CR LF (\r\n), ignored.

		All information is parsed 
	*/

	int bitCounter = 0;
	uint8_t parsedDigits[7] = { 0 };
	uint8_t checksum = 0;

	// Start from buffer index 1
	for (int i = 1; i < currentBufferIndex; i++)
	{
		// Considering a baud rate of 1200 bits per second, calculate how many equal bits were passed at this buffer location
		int signalDuration = int((float(durationBuffer[i]) / (1000000.0f / 1200.0f)) + 0.5f);

		// Count each equal bit within the current signal duration
		for (int j = 0; j < signalDuration; j++)
		{
			// Parse each digit
			for (int digitIndex = 0; digitIndex < 6; digitIndex++)
			{
				// Only need first 4 bits because values go from 0 to 9
				// Get bits 11 to 14, 21 to 24, 31 to 34 and so on until 61 to 64
				const int startIndex = digitIndex * 10 + 11;
				const int endIndex = digitIndex * 10 + 14;
				if ((bitCounter >= startIndex) && (bitCounter <= endIndex))
				{
					// Get byte by OR-ing the bits that are set to HIGH
					// Write byte in reverse direction because message is sent from LSB to MSB
					parsedDigits[digitIndex] |= signalBuffer[i] << (bitCounter - startIndex);
				}
			}

			// Parse checksum (only need first 6 bits because checksum goes from 0 to 50 = 9+5+9+9+9+9)
			if ((bitCounter >= 71) && (bitCounter <= 76))
			{
				checksum |= signalBuffer[i] << (bitCounter - 71);
			}

			bitCounter++;
		}
	}
	
	// Check if sum of digits equals checksum by subtracting each digit from the checksum
	for	(int i = 0; i < 6; i++)
	{
		checksum -= parsedDigits[i];
	}

	// Only copy 'parsedDigits' to 'receivedDigits' if parsed digits sum to the checksum
	if (checksum == 0)
	{
		for (int i = 0; i < 6; i++)
		{
			receivedDigits[i] = parsedDigits[i];
		}
	}
/*
	Serial.print(parsedDigits[0]);
	Serial.print(":");
	Serial.print(parsedDigits[1]);
	Serial.print(parsedDigits[2]);
	Serial.print(".");
	Serial.print(parsedDigits[3]);
	Serial.print(parsedDigits[4]);
	Serial.print(parsedDigits[5]);

	Serial.println(" ");
*/
}

void UpdateDisplay()
{
	// TODO: output to hex, interpolation/extrapolation

	if (!standby)
	{
		Serial.print(receivedDigits[0]);
		Serial.print(":");
		Serial.print(receivedDigits[1]);
		Serial.print(receivedDigits[2]);
		Serial.print(".");
		Serial.print(receivedDigits[3]);
		Serial.print(receivedDigits[4]);
		Serial.print(receivedDigits[5]);
		Serial.println(" ");
	}
	else
	{
		Serial.println("Standby");
	}
}

void loop()
{
	unsigned long timeSinceLastSwitch = micros() - currentSignalStart;

	if (timeSinceLastSwitch < TIME_BETWEEN_MESSAGES) // Still receiving message
	{
		parsed = false;
		standby = false;
	}
	else if (timeSinceLastSwitch < STANDBY_TIME) // Finished receiving message
	{
		// If more than 10 milliseconds have passed since the last signal switch, the message has finished
		if (!parsed)
		{
			// Parse the message if it hasn't been yet
			// If the message is valid, update the received digits
			InterpretDigits();
			parsed = true;
			currentBufferIndex = 0;
		}
	}
	else // Enter standby
	{
		// More than half a second has passed since the last signal switch
		// Assume that the timer is turned off or disconnected, and enter standby mode
		standby = true;
	}

	// Update the LED display
	UpdateDisplay();
}