ACIO.cpp

#include <stdio.h>

#include "ACIO.h"
#include "Debug.h"

/* Length of an ACIO packet without payload or checksum */
#define HEADER_LENGTH         5

/* Minimum packet length including header and checksum */
#define MINIMUM_PACKET_LENGTH (HEADER_LENGTH + 1)

/* Start of Message */
#define SOM                   0xAA

/* Location of various parts of the protocol */
#define ID_LOCATION           0
#define COMMAND_HIGH_LOCATION 1
#define COMMAND_LOW_LOCATION  2
#define LENGTH_HIGH_LOCATION  3
#define LENGTH_LOW_LOCATION   4

/* Number of times to try initializing a reader by sending baud probe */
#define INITIALIZATION_TRIES  8

/* Number of return baud probes to receive before we consider ourselves initialized */
#define MIN_PROBES_RECEIVED   5

#define WAIT()                Sleep( 100 )
#define LONGWAIT()            Sleep( 1000 )

ACIO::ACIO()
{
	/* Initialize readers first */
	printf( "Initializing readers" );
    InitReaders();
	printf( "\n" );

	/* Get version of all readers */
    for( unsigned int x = 0; x < readerCount; x++ )
    {
		/* Print out reader version in debug mode */
		const char * const version = getReaderVersion( serial, x );
		char * typestring;
		reader_type_t type = getReaderType( serial, x );

		switch( type ) {
			case TYPE_UNKNOWN:
				typestring = "unknown";
				break;
			case TYPE_READER:
				typestring = "reader";
				break;
			case TYPE_DISPENSER:
				typestring = "dispenser";
				break;
			case TYPE_LEDBOARD:
				typestring = "LED board";
				break;
			case TYPE_IOBOARD:
				typestring = "IO board";
				break;
		}

		DEBUG_PRINTF( "Reader %d is type %s version %s\n", x + 1, typestring, version );

        /* Walk init routine */
        initReader( serial, x, 0 );
        initReader( serial, x, 1 );
        initReader( serial, x, 2 );

        /* Set ready for keys only */
        setReaderState( serial, x, STATE_EJECT );
    }

	/* For key input debouncing */
	old_keypresses = (unsigned int *)malloc(sizeof(unsigned int) * readerCount);
}

ACIO::~ACIO(void)
{
	/* Kill memory used for keypresses */
	free(old_keypresses);

	/* Close the reader so we can let the game talk to it */
	for( unsigned int y = 0; y < readerCount; y++ )
	{
		setReaderState( serial, y, STATE_EJECT );
	}
	CloseHandle( serial );
}

bool ACIO::getCardInserted(int reader)
{
	unsigned int currentpresses;
	getReaderState( serial, reader, &state, &currentpresses, cardId );
	return (state == STATE_READ || state == STATE_INSERTED);
}

/**
 * TODO: For some reason this returns one card read in the past. So, on first
 * read it returns garbage, on second read it returns the first card, etc. Fix
 * that at some point.
 */
void ACIO::getCardID(int reader, unsigned char *outCardId)
{
	while( !getCardInserted(reader) ) { requestCardId( serial, reader ); }
	while( !getCardInserted(reader) ) { requestCardId( serial, reader ); }
	memcpy(outCardId, cardId, CARD_LENGTH);
}

reader_keypress_t ACIO::getPressedKey(int reader)
{
	unsigned int currentpresses;
	getReaderState( serial, reader, &state, &currentpresses, cardId );
	unsigned int keypresses = currentpresses & (~old_keypresses[reader]);
	old_keypresses[reader] = currentpresses;

	if (keypresses & 0x0002 )
	{
		return KEY_1;
	}
	if (keypresses & 0x0020 )
	{
		return KEY_2;
	}
	if (keypresses & 0x0200 )
	{
		return KEY_3;
	}
	if (keypresses & 0x0004 )
	{
		return KEY_4;
	}
	if (keypresses & 0x0040 )
	{
		return KEY_5;
	}
	if (keypresses & 0x0400 )
	{
		return KEY_6;
	}
	if (keypresses & 0x0008 )
	{
		return KEY_7;
	}
	if (keypresses & 0x0080 )
	{
		return KEY_8;
	}
	if (keypresses & 0x0800 )
	{
		return KEY_9;
	}
	if (keypresses & 0x0001 )
	{
		return KEY_0;
	}
	if (keypresses & 0x0010 )
	{
		return KEY_00;
	}
	if (keypresses & 0x0100 )
	{
		return KEY_BLANK;
	}

	return KEY_NONE;
}

void ACIO::requestCardInsert(int reader)
{
    setReaderState( serial, reader, STATE_EJECT );

    /* Walk init routine again.  For some reason, it reads the same
     * card ID the second time through, so I just reinit. */
    initReader( serial, reader, 0 );
    initReader( serial, reader, 1 );
    initReader( serial, reader, 2 );

	setReaderState( serial, reader, STATE_NOT_READY );
	setReaderState( serial, reader, STATE_GET_READY );
	setReaderState( serial, reader, STATE_READY );
}

void ACIO::requestCardEject(int reader)
{
	setReaderState( serial, reader, STATE_EJECT );
}

HANDLE ACIO::openSerial( const _TCHAR *arg, int baud )
{
    HANDLE hSerial = CreateFile(arg, GENERIC_READ | GENERIC_WRITE, 0, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
	if (hSerial == INVALID_HANDLE_VALUE) { return hSerial; }

	int rate;

	switch( baud )
	{
		case 4800:
			rate = CBR_4800;
			break;
		case 9600:
			rate = CBR_9600;
			break;
		case 19200:
			rate = CBR_19200;
			break;
		case 38400:
			rate = CBR_38400;
			break;
		case 57600:
			rate = CBR_57600;
			break;
		case 115200:
			rate = CBR_115200;
			break;
		default:
			rate = CBR_9600;
			break;
	}

    DCB dcbSerialParams = {0};

    dcbSerialParams.DCBlength = sizeof(dcbSerialParams);
    dcbSerialParams.BaudRate = rate;
    dcbSerialParams.ByteSize = 8;
    dcbSerialParams.StopBits = ONESTOPBIT;
    dcbSerialParams.Parity = NOPARITY;
	dcbSerialParams.fOutxCtsFlow = 0;
	dcbSerialParams.fOutxDsrFlow = 0;
	dcbSerialParams.fDtrControl = DTR_CONTROL_DISABLE;
	dcbSerialParams.fDsrSensitivity = 0;
	dcbSerialParams.fOutX = 0;
	dcbSerialParams.fInX = 0;
	dcbSerialParams.fRtsControl = RTS_CONTROL_DISABLE;

    SetCommState(hSerial, &dcbSerialParams);

    COMMTIMEOUTS timeouts = { 0 };

    timeouts.ReadIntervalTimeout = 1;
    timeouts.ReadTotalTimeoutConstant = 1;
    timeouts.ReadTotalTimeoutMultiplier = 1;

    SetCommTimeouts(hSerial, &timeouts);
    return hSerial;
}

const unsigned char * const ACIO::getPacketData(
	unsigned int *readerId,
    unsigned int *command,
    unsigned int *len,
    unsigned int *checksum,
    const unsigned char * const packet,
    unsigned int length
) {
	/* Exit early if we didn't get a good packet */
	if (length < MINIMUM_PACKET_LENGTH) { return NULL; }

    for( unsigned int i = 0; i <= length - MINIMUM_PACKET_LENGTH; i++ )
    {
        const unsigned char * const data = &packet[i];

        if( data[0] != SOM )
        {
            /* Get command */
            *readerId   = data[ID_LOCATION];
            *command    = (data[COMMAND_HIGH_LOCATION] << 8) | data[COMMAND_LOW_LOCATION];
            *len        = (data[LENGTH_HIGH_LOCATION] << 8) | data[LENGTH_LOW_LOCATION];
            *checksum   = data[(*len) + HEADER_LENGTH];
            return data + HEADER_LENGTH;
        }
    }

    return NULL;
}

unsigned char ACIO::calcPacketChecksum( const unsigned char * const data )
{
    unsigned char *packet = (unsigned char *)data;

    /* Dirty */
    while( 1 )
    {
        /* Get to start of packet */
        if( packet[0] == SOM )
        {
            packet++;
            continue;
        }

        unsigned int length = ((packet[LENGTH_HIGH_LOCATION] << 8) | packet[LENGTH_LOW_LOCATION]);
        unsigned int sum = 0;

        /* Skip SOM, not part of packet CRC */
        for( unsigned int i = 0; i < length + HEADER_LENGTH; i++ )
        {
            sum += packet[i];
        }

        return sum & 0xFF;
    }
}

int ACIO::probeReader( HANDLE hSerial )
{
    const unsigned char packet_probe[] = {
		0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
		0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
		0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
		0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
	};
    unsigned char data[1024];
    DWORD length;

	WriteFile( hSerial, packet_probe, sizeof( packet_probe ), &length, 0 );
	ReadFile( hSerial, data, sizeof( data ), &length, 0 );

	if (length < MIN_PROBES_RECEIVED)
	{
		return 0;
	}

	for (unsigned int i = 0; i < length; i++)
	{
		if (data[i] != 0xAA)
		{
			return 0;
		}
	}

	/* Clear out any additional init the reader sends */
	while (true)
	{
		ReadFile( hSerial, data, sizeof( data ), &length, 0 );
		if (length == 0)
		{
			return 1;
		}
	}
}

unsigned int ACIO::getReaderCount( HANDLE hSerial )
{
    const unsigned char count_probe[] = { 0xAA, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x02, };
    unsigned char data[1024];
    DWORD length;

    WriteFile( hSerial, count_probe, sizeof( count_probe ), &length, 0 );
    WAIT();
    ReadFile( hSerial, data, sizeof( data ), &length, 0 );

    unsigned int readerId;
    unsigned int command;
    unsigned int len;
    unsigned int checksum;
    const unsigned char * const payload = getPacketData( &readerId, &command, &len, &checksum, data, length );

    if( payload == NULL ) { return 0; }
    if( len != 1 ) { return 0; }

    return payload[0];
}

void ACIO::initReader( HANDLE hSerial, unsigned int id, int whichInit )
{
    unsigned int init_length[3] = { 7, 7, 8 };
    unsigned char init_probe[3][8] = { { 0xAA, (id + 1), 0x00, 0x03, 0x00, 0x00, 0xFF, },
                                       { 0xAA, (id + 1), 0x01, 0x00, 0x00, 0x00, 0xFF, },
                                       { 0xAA, (id + 1), 0x01, 0x30, 0x00, 0x01, 0x00, 0xFF, } };
    unsigned char data[1024];
    DWORD length;

    /* Fix up checksum since ID is variable */
    init_probe[whichInit][init_length[whichInit] - 1] = calcPacketChecksum( init_probe[whichInit] );

    WriteFile( hSerial, init_probe[whichInit], init_length[whichInit], &length, 0 );
    WAIT();
    ReadFile( hSerial, data, sizeof( data ), &length, 0 );
}

const char * const ACIO::getReaderVersion( HANDLE hSerial, unsigned int id )
{
    unsigned char version_probe[] = { 0xAA, (id + 1), 0x00, 0x02, 0x00, 0x00, 0xFF, };
    static char version[33] = { 0x00 };
    unsigned char data[1024];
    DWORD length;

    /* Fix up checksum since ID is variable */
    version_probe[6] = calcPacketChecksum( version_probe );

    WriteFile( hSerial, version_probe, sizeof( version_probe ), &length, 0 );
    WAIT();
    ReadFile( hSerial, data, sizeof( data ), &length, 0 );

    unsigned int readerId;
    unsigned int command;
    unsigned int len;
    unsigned int checksum;
    const unsigned char * const payload = getPacketData( &readerId, &command, &len, &checksum, data, length );

    if( payload != NULL && len == 44 )
    {
        memcpy( version, &payload[12], 32 );
        version[32] = 0x00;

        /* Spaces, for display */
        for( int i = 0; i < 32; i++ )
        {
            if( version[i] == 0x00 ) { version[i] = 0x20; }
        }
    }

    return (const char * const)version;
}

reader_type_t ACIO::getReaderType( HANDLE hSerial, unsigned int id )
{
    unsigned char version_probe[] = { 0xAA, (id + 1), 0x00, 0x02, 0x00, 0x00, 0xFF, };
    static char code[5] = { 0x00 };
    unsigned char data[1024];
    DWORD length;

    /* Fix up checksum since ID is variable */
    version_probe[6] = calcPacketChecksum( version_probe );

    WriteFile( hSerial, version_probe, sizeof( version_probe ), &length, 0 );
    WAIT();
    ReadFile( hSerial, data, sizeof( data ), &length, 0 );

    unsigned int readerId;
    unsigned int command;
    unsigned int len;
    unsigned int checksum;
    const unsigned char * const payload = getPacketData( &readerId, &command, &len, &checksum, data, length );

    if( payload != NULL && len == 44 )
    {
        memcpy( code, &payload[8], 4 );
        code[4] = 0x00;

		if (strcmp(code, "ICCA") == 0) {
			return TYPE_READER;
		}
		if (strcmp(code, "ICCB") == 0) {
			return TYPE_READER;
		}
		if (strcmp(code, "ICCC") == 0) {
		  return TYPE_READER;
		}
		if (strcmp(code, "HBHI") == 0) {
			return TYPE_DISPENSER;
		}
		if (strcmp(code, "LEDB") == 0) {
			return TYPE_LEDBOARD;
		}
		if (strcmp(code, "HDXS") == 0) {
			return TYPE_LEDBOARD;
		}
		if (strcmp(code, "KFCA") == 0) {
			return TYPE_IOBOARD;
		}
    }

    return TYPE_UNKNOWN;
}

void ACIO::getReaderState( HANDLE hSerial, unsigned int id, card_state_t *state, unsigned int *keypresses, unsigned char *cardId )
{
    unsigned char state_probe[] = { 0xAA, (id + 1), 0x01, 0x34, 0x00, 0x01, 0x10, 0xFF, };
    unsigned char data[1024];
    DWORD length;

    /* Fix up checksum since ID is variable */
    state_probe[7] = calcPacketChecksum( state_probe );

    /* Sane return */
    *keypresses = 0;

    WriteFile( hSerial, state_probe, sizeof( state_probe ), &length, 0 );
    WAIT();
    ReadFile( hSerial, data, sizeof( data ), &length, 0 );

    unsigned int readerId;
    unsigned int command;
    unsigned int len;
    unsigned int checksum;
    const unsigned char * const payload = getPacketData( &readerId, &command, &len, &checksum, data, length );

    if( payload != NULL && len == 16 )
    {
        *keypresses = (payload[14] << 8) | payload[15];

        *state = STATE_UNKNOWN;
        switch( payload[1] )
        {
            case 0x00:
                *state = STATE_REMOVED;
                break;
            case 0x10:
                *state = STATE_FRONT_SENSOR;
                break;
            case 0x30:
                *state = STATE_INSERTED;
                break;
            default:
                if( VERBOSE_DEBUG ) fprintf( stderr, "Unknown card state %02X!\n", payload[1] );
                break;
        }

        if( payload[0] != 0x00 && payload[11] == 0x00 && *state == STATE_INSERTED )
        {
            memcpy( cardId, &payload[2], CARD_LENGTH );
            *state = STATE_READ;
        }
    }
}

void ACIO::setReaderState( HANDLE hSerial, unsigned int id, reader_state_t state )
{
    unsigned char state_request[] = { 0xAA, (id + 1), 0x01, 0x35, 0x00, 0x02, 0x10, 0xFF, 0xFF, };
    unsigned char data[1024];
    DWORD length;

    /* Set state */
    switch( state )
    {
        case STATE_NOT_READY:
            state_request[7] = 0x00;
            break;
        case STATE_GET_READY:
            state_request[7] = 0x03;
            break;
        case STATE_READY:
            state_request[7] = 0x11;
            break;
        case STATE_EJECT:
            state_request[7] = 0x12;
            break;
        default:
            if( VERBOSE_DEBUG ) fprintf( stderr, "Unknown reader state %02X!\n", state );
            state_request[7] = 0xFF;
            break;
    }

    /* Fix up checksum since ID is variable */
    state_request[8] = calcPacketChecksum( state_request );

    WriteFile( hSerial, state_request, sizeof( state_request ), &length, 0 );
    WAIT();
    ReadFile( hSerial, data, sizeof( data ), &length, 0 );
}

void ACIO::requestCardId( HANDLE hSerial, unsigned int id )
{
    unsigned char id_request[] = { 0xAA, (id + 1), 0x01, 0x31, 0x00, 0x01, 0x10, 0xFF, };
    unsigned char data[1024];
    DWORD length;

    /* Fix up checksum since ID is variable */
    id_request[7] = calcPacketChecksum( id_request );

    WriteFile( hSerial, id_request, sizeof( id_request ), &length, 0 );
    WAIT();
    ReadFile( hSerial, data, sizeof( data ), &length, 0 );
}

void ACIO::InitReader(const _TCHAR *comport)
{
	HANDLE hSerial = NULL;
	const unsigned int baudrate[2] = { 57600, 9600 };

	/* Loop until some thread claims the handle, and then exit */
	while (serial == NULL)
	{
		for (unsigned int baud = 0; baud < 2; baud++)
		{
			DEBUG_PRINTF("Attempting to probe readers on %ls,%d\n", comport, baudrate[baud]);
			hSerial = openSerial( comport, baudrate[baud] );

			if (hSerial == INVALID_HANDLE_VALUE)
			{
				DEBUG_PRINTF("Couldn't open com port!\n");
				WAIT();
				continue;
			}

			/* Ensure we start fresh */
			PurgeComm( hSerial, PURGE_RXABORT | PURGE_RXCLEAR | PURGE_TXABORT | PURGE_TXCLEAR );

			/* Init */
			for (int i = 0; i < INITIALIZATION_TRIES; i++)
			{
				if( probeReader( hSerial ) )
				{
					/* Get count */
					unsigned int count = getReaderCount( hSerial );
					if (count > 0)
					{
						/* Make sure at least one is a reader */
						for( unsigned int x = 0; x < count; x++ )
						{
							/* Print out reader version in debug mode */
							if (getReaderType( hSerial, x ) == TYPE_READER)
							{
								DEBUG_PRINTF( "Saw %d readers!\n", count );
								serial = hSerial;
								readerCount = count;
								return;
							}
						}
					}
				}

				if (serial != NULL)
				{
					/* Exit early if we lost the race */
					break;
				}
			}

			/* Failed, close */
			CloseHandle( hSerial );
		}
	}
}

void ACIO::InitReaders()
{
	/* Walk serial chain, finding readers */
    const _TCHAR *comport[4] = { L"COM1", L"COM2", L"COM3", L"COM4" };
	thread_context_t threadContexts[4];
	HANDLE threadHandles[4];
	const char *pattern[4] = { "\b\b\b   ", "\b\b\b.  ", "\b\b\b.. ", "\b\b\b..." };
	unsigned int pno = 0;

	/* Init the global serial handle */
	serial = NULL;

	/* Put a space into location where we will be backspacing, for laziness */
	NON_DEBUG_PRINTF( "   " );
	DEBUG_PRINTF( "...\n" );

	/* Kick off threads for finding the right serial port */
	for (unsigned int i = 0; i < 4; i++)
	{
		threadContexts[i].acio = this;
		threadContexts[i].port = comport[i];
		threadHandles[i] = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)initThread, &threadContexts[i], 0, NULL);
	}

	/* Try to open the reader indefinitely */
	while( serial == NULL )
	{
		/* Wait for threads to find the readers */
		NON_DEBUG_PRINTF( "%s", pattern[((pno++) / 10) % 4] );
		WAIT();
	}

	/* Join on threads */
	for (unsigned int i = 0; i < 4; i++)
	{
		WaitForSingleObject(threadHandles[i], INFINITE);
	}
}