trennfix/sw: Fixed a bit beauty.

[eisenbahn.git] / trennfix / sw / mm / src / mm_switch.c

/******************************************************************************
 *
 *  Trennfix firmware -  mm_switch.c
 *
 *  Maerklin Motorola switch command receiver
 *
 *  Copyright (C) 2017 Philipp Hachtmann
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 *****************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <avr/io.h>
#include <avr/eeprom.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>

#include <util/delay.h>
#include <stdint.h>

#include <config/hardware.h>
#include <mm/mm_switch.h>


/*
 *
 * Check for stuff we need
 *
 */
#if !defined(MM_TSTART) || !defined(MM_SENSE) || !defined(MM_TIMER_INT_VECT)

#error Missing needed MM_... macro!

#endif

/*
 *    Private global variables
 */

#ifndef MM_USE_REGISTER_VARS

static volatile uint8_t mm_bitno = 0;
static uint8_t shift_command;
static uint8_t shift_function;
static uint8_t shift_address;
uint8_t mm_time_h = 0;
uint8_t mm_time_l = 0;
uint8_t mm_bit_val = 23;
static uint8_t mm_flavor;
static uint8_t mm_polarity = 1;
static uint8_t mm_last_was_short = 0;

#endif

/*
 * Lookup trinary nibble
 *
 * This was implemented using a switch statement before.
 * Changing the lookup to a table did only add two bytes
 * of memory and saved ca. 50 bytes program memory.
 */
static const uint8_t nibble_table[16]={
	[0x0] = 0,
	[0xc] = 1,
	[0x8] = 2,
	[0x3] = 3,
	[0xf] = 4,
	[0xb] = 5,
	[0x2] = 6,
	[0xe] = 7,
	[0xa] = 8
};
#define lookup_nibble(nibble) nibble_table[nibble & 0xf]
 
static uint8_t __attribute__((unused)) lookup_decoder(uint8_t mm_byte)
{
	uint8_t low;
	uint8_t high;
	uint8_t retval;

	if (mm_byte == 0)
		return 80;
	low = lookup_nibble(mm_byte >> 4);
	high = lookup_nibble(mm_byte & 0xf);
	if (!low)
		return 0;

	/*	retval = 9 * high + low; */
	retval = high << 3;
	retval += high;
	retval += low;
	return retval;
}

static uint8_t __attribute__((unused)) lookup_command(uint8_t mm_command)
{
	uint8_t res;
	/*
	 * Check for aabbccdd condition
	 * 
	 *        a  a  b  b  c  c  d  d   mm_command
	 *   XOR  a  b  b  c  c  d  d  0   mm_command << 1
	 * Mask   1  0  1  0  1  0  1  0   0xaa
	 *
	 * Must be zero!
	 *
	 */

	if ((mm_command ^ (mm_command << 1)) & 0xaa)
		return 0;
	/*
	 * Protocol differences:
	 * =====================
	 *
	 * I have an old "central control" 6022 and a "control unit" 6021
	 * for measurements and test. It is assumed that the 6022 outputs
	 * old MM1 format while the 6021 definitively outputs MM2 telegrams.
	 * 
	 * In MM1, switch commands are different from MM2 with respect what
	 * happens if you release a button.
	 *
	 * When you press a button, both protocols send
	 *
	 * <aaaaaaaa><00><aabbcc11>
	 *
	 * where a = 1, b = 2, c = 4 and the keys are numerated from 0 to 7
	 * in the order 1 red, 1 green, 2 red, 2 green and so on.
	 * 
	 * The last two bits correspond to "on" state of the button/coil.
	 *
	 * When a key is released under MM1 protocol, the sequence sent is
	 * analogue to the button down sequence:
	 * 
	 * <aaaaaaaa><00><aabbcc00> where abc again represents the button's
	 * address and the last bits now signal "off".
	 *
	 * MM2 handles this differently:
	 * Whenever any key from the addressed decoder is released, the sequence
	 * <aaaaaaaa>00<00000000> is sent - not only for key 0, but for all
	 * keys!
	 *
	 * While MM1 presents the theoretical possibility to press several keys
	 * independently and simultaneously (which my keyboard does NOT
	 * support), MM2 supports only one key at a time (besides strange
	 * sequences like "one down, another down, all up"...
	 * 
	 * A decoder that strictly adheres to the MM1 standard would not work
	 * properly with MM2 control units. As far as I know all K83/K84
	 * decoders always worked with MM2 control units. That means that
	 * they reduce the commands to the possibilities of MM2 from the
	 * beginning.
	 *
	 * Possible use cases for the old protocol button release commands:
	 *   - Determine if the protocol is MM1 or MM2
	 *   - Implement hidden evil features into the controller which can
	 *     only be summoned by old MM1 gear or selfmade control telegram
	 *     generators.
	 *
	 * What this code now actually does:
	 * =================================
	 *
	 * When key pressed (aabbcc11), it will send out the key number in the
	 * range 1-8 and 0 if it gets any key up command and therefore ignore
	 * the key number if it is transmitted with the key up command.
	 *
	 */
	if (!(mm_command & 0x01))
		res = 0;
	else
		res = (mm_command & 0x80) * 1 + (mm_command & 0x20) * 0x02
			+ (mm_command & 0x08) * 0x04 + 1;
	return res;
}

/* We will shift from right to left.
 * XXXXXXXX        XX          XXXXXXXX
 * shift_address   shift_function  shift_command
 *
 * The bits 7 downto 2 of shift_function are ignored.
 *
 * First comes the C implementation of the shift routine.
 * It is usually not used anymore, but I left it for
 * illustration purposes.
 * The real shift function is written in assembly and saves many instructions.
 */
#if 0
void shift(uint8_t value)
{
	shift_address <<= 1;
	if (shift_function & 2)
		shift_address |= 1;
	shift_function <<= 1;
	if (shift_command & 0x80)
		shift_function |= 1;
	shift_command <<= 1;
	if (value)
		shift_command |= 1;
}
#else

void shift(uint8_t value)
{
	asm("ror %[val]                 ; Shift value right into carry\n\t"
	    "rol %[cmd]                 ; and shift to command reg\n\t"
	    "mov __tmp_reg__, %[func]   ; save function value \n\t"
	    "rol %[func]                ; Shift up function value\n\t"
	    "ror __tmp_reg__            ; shift bit 1\n\t"
	    "ror  __tmp_reg__           ;          down to carry\n\t"
	    "rol %[addr]                ; And we're at the address\n\t"
	    : [cmd] "=r" (shift_command), [func] "=r" (shift_function),
	      [addr] "=r" (shift_address)
	    : "0" (shift_command), "1" (shift_function),
	    "2" (shift_address), [val] "r" (value)
	    );
}
#endif

static void mm_feed_bit(uint8_t bit, uint8_t seen_style)
{
	static volatile uint8_t shift_command_first;
	static volatile uint8_t shift_function_first;
	static volatile uint8_t shift_address_first;
	uint8_t address;
	uint8_t command;

	if (mm_bitno == 0)
		mm_flavor = seen_style;
	else
		if (seen_style != mm_flavor) {
			mm_bitno = 0;
			return;
		}
			
	shift(bit);
	mm_bitno++;
	if (mm_bitno == 18) { /* Save first received word */
		shift_address_first  = shift_address;
		shift_function_first = shift_function;
		shift_command_first  = shift_command;
	} 

	if (mm_bitno == 36) {

		if ((shift_command == shift_command_first) &&
		    (shift_address == shift_address_first) &&
		    (shift_function == shift_function_first)) {
			address = lookup_decoder(shift_address);
			if (mm_flavor == MM_FLAVOR_DRIVE) {
				mm_switch_drive(address, shift_function,
						shift_command);
			} else {
				trigger();
				command = lookup_command(shift_command);
				mm_switch_command(address, command);
			}				
		}
		
	}
}

/*
 *  The timeout interrupt vector does nothing else
 *  than incrementing the mm_time_h round counter.
 *
 *  It is written in naked assembly because we want to avoid pushing
 *  and popping of all upper registers.
 */
void __attribute__((naked)) MM_TIMER_INT_VECT(void)
{
	asm("push r0       ; save r0 \n\t"
	    "in r0, __SREG__    \n\t"
#ifdef MM_USE_REGISTER_VARS
	    "inc %[th]          \n\t"
#else
	    "push r1            \n\t"
	    "lds r1, mm_time_h     \n\t"
	    "inc r1             \n\t"
	    "sts  mm_time_h, r1    \n\t"
	    "pop r1             \n\t"
#endif
	    "out __SREG__, r0    \n\t"
	    "pop r0              \n\t"
	    "reti                \n\t"
#ifdef MM_USE_REGISTER_VARS
	    :: [th] "r" (mm_time_h)
#endif
	    );
}

/*
 * Another naked interrupt trampoline
 *
 * Here we first save the timer value as fast as possible, then we jump (!)
 * into the "official" interrupt handler with all its decorations.
 */
void __attribute__((naked)) PCINT0_vect(void)
{
#ifdef MM_USE_REGISTER_VARS
	asm("in %[tl], %[tmr]   \n\t"
	    "rjmp __vector_pinchange  \n\t"
	    :: [tl] "r" (mm_time_l), [tmr] "I" (_SFR_IO_ADDR(TCNT0))
	    );
#else
	asm("push r0         \n\t"
	    "in r0, %[tmr]   \n\t"
	    "sts mm_time_l, r0  \n\t"
	    "pop r0          \n\t"
	    "rjmp __vector_pinchange  \n\t"
	    :: [tmr] "I" (_SFR_IO_ADDR(TCNT0))
	    );
#endif
}

/* Pin change interrupt vector, here we have a bit more time */
ISR(__vector_pinchange){
	/* First kill off that timer */
	MM_TSTART;  /* Restart timer */
	
	/* Account for not yet handled timer overflow */
	if (TIFR & _BV(TOV0)) {
		mm_time_h++;
		TIFR |= _BV(TOV0);
	}
	
	mm_bit_val = !MM_SENSE;

	uint16_t duration = mm_time_h << 8;
	duration += mm_time_l;
	mm_time_h = 0;

	/*
	 * The nominal length of a bit cycle is 208 us.
	 * This consists of 8 parts, each 26 us:
	 * 1 d d d d d d 0
	 *
	 * That means that the 1 pulse is 7 * 26 = 182us
	 * and the short pulse is 1 * 26 = 26us.
	 *
	 * Reality seems to look not as that exact. I measure
	 * 26us for the clock pulse, but 196 for the long pulse.
	 *
	 */

#define D_MATCH(d, v) ((duration > (d * 2 - 2 * v)) && (duration < (d * 2 + 2 * v)))

	if (D_MATCH(26, 4)) {
		if (mm_last_was_short)
			mm_polarity = mm_bit_val;
		mm_last_was_short = 1;

		if (mm_bit_val == mm_polarity)
			mm_feed_bit(0, MM_FLAVOR_DRIVE);
	} else {
		mm_last_was_short = 0;
	}

	if (mm_flavor == MM_FLAVOR_DRIVE) {
		if (duration > 4096) { /* Maerklin inter package timeout 2ms */
			mm_bitno = 0;
			goto done;
		}
	} else {
		if (duration > 2000) { /* Maerklin inter package timeout 1ms */
			mm_bitno = 0;
			goto done;
		}
	}
	
	if (mm_bit_val != mm_polarity)
		goto done;

	if (D_MATCH(182, 25)) mm_feed_bit(1, MM_FLAVOR_DRIVE);
	if (D_MATCH(91, 17))  mm_feed_bit(1, MM_FLAVOR_SWITCH);
	if (D_MATCH(13, 4))   mm_feed_bit(0, MM_FLAVOR_SWITCH);
 done:
	mm_switch_pinchange_callback();
 }


void __attribute__((weak))mm_switch_pinchange_callback(void)
{
}

void __attribute__((weak))mm_switch_drive(uint8_t decoder, uint8_t function,
					  uint8_t command)
{
}

void __attribute__((weak))mm_switch_command(uint8_t address, uint8_t command)
{
}


/******************************************************************************
 *                        The end :-)
 */