Tooltron

#include "cardreader.h"

//#define SD

#define CR_CL       (_BV(PIND5))

#define CR_CLK      (_BV(PIND6))

#define CR_DATA     (_BV(PIND7))

#ifdef SD

#define CR_MAX_IDX 4

#else

#define CR_MAX_IDX 6

#endif

#define CR_SS       '%'         // Start sentinal

#define CR_ES       '?'         // End sentinal

// This is only written in the PCINT2 intterupt or in the main loop

// but not concurrently. read_card acts as an implicit lock

volatile cr_flag_t cr_flag;

volatile uint8_t cr_buf[512];

volatile uint16_t cr_buf_idx;

volatile uint8_t read_card;

#ifdef SD

const char cr_dict[] = {'0', '1', '2', '3', '4', '5', '6', '7',

                        '8', '9', ':', ';', '<', '=', '>', '?'};

#else

const char cr_dict[] = {' ', '!', '"', '#', '$', '%', '&', '\'',

                        '(', ')', '*', '+', ',', '-', '.', '/',

                        '0', '1', '2', '3', '4', '5', '6', '7',

                        '8', '9', ':', ';', '<', '=', '>', '?',

                        '@', 'A', 'B', 'C', 'D', 'E', 'F', 'G',

                        'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',

                        'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W',

                        'X', 'Y', 'Z', '[', '\\',']', '^', '_'};

#endif

void card_reader_setup(void) {

    // Turn on pin interrupts for pins D7, D6, D5

    PCICR = _BV(PCIE2);

    PCMSK2 = /*_BV(PCINT23) |*/ _BV(PCINT22) | _BV(PCINT21);

    // Make pins D7, D6, D5 inputs

    DDRD &= ~_BV(DDD7) & ~_BV(DDD6) & ~_BV(DDD5); 

    cr_buf_idx = 0;

    cr_flag = CR_NONE;

    read_card = 0;

}

ISR(PCINT2_vect) {    

    //static uint8_t byte_idx = 0;        // Which bit to store in byte 

    //static uint8_t byte = 0;            // The current character being read

    //static uint8_t parity = 0;          // Current calculated parity

    //static uint8_t parity_error = 0;    // If we saw a parity error this read

    //static uint8_t start_sentinal = 0;  // Saw a start sentinal

    //static uint8_t stop_sentinal = 0;   // Saw a stop sentinal

    static uint8_t reading = 0;         // Currently reading

    //uint8_t rval;   // Current bit read in

    // Only read card if we are expecting it

    if (!read_card) {

        return;

    }

    // Check if the card is inserted or not

    if (!(PIND & CR_CL) && (reading == 0)) {

        //byte_idx = 0;

        //byte = 0;

        //parity_error = 0;

        cr_flag = CR_NONE;

        cr_buf_idx = 0;

        //start_sentinal = 0;

        //stop_sentinal = 0;

        reading = 1;

    } else if (PIND & CR_CL) {

        toggle_led(LED_RED, ON);

        reading = 0;

        //if ((stop_sentinal == 1) && (parity_error == 0)) {

            cr_flag = CR_GOOD;

        //} else {

        //    cr_flag = CR_BAD;

        //}

        return;

    }

    // Read data in on the downtick of the clock

    if (!(PIND & (CR_CLK))) {

        // Read data from card reader and flip since ours inverts

        //rval = (PIND & CR_DATA) ? 0 : 0x40;

        //cr_buf[cr_buf_idx] = (rval == 0) ? '0' : '1';

        cr_buf[cr_buf_idx] = (PIND & CR_DATA) ? 0 : 0x20;

        cr_buf_idx++;

    }

}

void parse_card(void) {

    int32_t i = cr_buf_idx - 1;

    uint8_t start_sentinal = 0;

    uint8_t stop_sentinal = 0;

    uint8_t byte_idx = 0;

    uint8_t byte = 0;

    uint8_t parity;

    while (start_sentinal == 0) {

        byte = (((byte >> 1) & 0x1F) | (cr_buf[i]));

        if (cr_dict[byte] == CR_SS) {

            toggle_led(LED_GREEN, ON);

            start_sentinal = 1;

            rs485_send_byte(cr_dict[byte]);

            // Skip parity bit

            i--;

        }

            i--;

    }

    byte = 0;

    byte_idx = 0;

    parity = 0;

    while (i >= 0) {

        // Parity bit

        if (byte_idx == CR_MAX_IDX) {

            if (!(cr_buf[i]) != (parity % 2)) {

                rs485_send_byte('F');

            }

            rs485_send_byte(cr_dict[byte]);

            // Stop at the stop sentinal

            if (cr_dict[byte] == CR_ES) {

                return;

            }

            byte_idx = 0;

            byte = 0;

            parity = 0;

        // Data bits

        } else {

            byte = (((byte >> 1) & 0x1F) | (cr_buf[i]));

            byte_idx++;

            parity += (cr_buf[i] == 0) ? 0 : 1;

        }

        // Goto next bit in cr_buf

        i--;

    }

}