Tooltron

    // XXX change this back to off later

    rs485_toggle_transmit(RS485_TX_ON);

	//rs485_toggle_transmit(RS485_TX_ON);

    //rs485_toggle_transmit(RS485_TX_OFF);

#ifndef __CARDREADER_H__

#define __CARDREADER_H__

#include <avr/io.h>

#include <avr/interrupt.h>

#include <stdint.h>

#include "main.h"

#include "rs485_int.h"

typedef enum {

    CR_NONE,

    CR_GOOD,

    CR_BAD

} cr_flag_t;

typedef enum {

    CR_IDLE,

    CR_SS,

    CR_DATA

} cr_state_t;

extern volatile cr_flag_t cr_flag;

extern volatile uint8_t read_card;

extern volatile uint8_t cr_buf[512];

extern volatile uint8_t cr_buf_idx;

void card_reader_setup(void);

#endif

#include "main.h"

    card_reader_setup();

    toggle_led(LED_GREEN|LED_YELLOW|LED_RED, OFF);

    read_card = 0;

    rs485_send_byte('s');

        while(1) {

            read_card = 1;

            if (cr_flag != CR_NONE) {

                read_card = 0;

                //if (cr_flag == CR_GOOD) {

                    for (c = 0; c < cr_buf_idx; c++) {

                        rs485_send_byte(cr_buf[c]);

                    }

                    /*

                } else {

                    toggle_led(LED_YELLOW|LED_RED, ON);

                    _delay_ms(1000);

                    toggle_led(LED_YELLOW|LED_RED, OFF);

                }*/

                cr_flag = CR_NONE;

            }

        }

#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 uint8_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_idx++;

    }

/*

        if (start_sentinal == 0) {

            byte = (((byte >> 1) & 0x3F) | (rval));

            if (cr_dict[byte] == CR_SS) {

                //cr_buf[cr_buf_idx] = CR_SS;

                //cr_buf_idx++;

                toggle_led(LED_GREEN, ON);

                start_sentinal = 1;

                byte_idx = CR_MAX_IDX;

                //byte = 0;

                //parity = 1;

            }

        // This is the parity bit

        } else if (byte_idx == CR_MAX_IDX) {

            // This failed the parity check

            //if (rval != parity) {

            //    parity_error = 1;

            // Passes the parity check

            //} else {

                // Only commit if we found the start and we haven't hit the end

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

                    cr_buf[cr_buf_idx] = cr_dict[byte];

                    // Detect an end sentinal

                    //if (cr_dict[byte] == CR_ES) {

                    //    stop_sentinal = 1;

                    //}

                cr_buf_idx++;

                //cr_buf[cr_buf_idx] = '|';

                //cr_buf_idx++;

            //}

            byte_idx = 0;

            byte = 0;

            parity = 1;

        // Normal bits

        } else {

            byte = (((byte >> 1) & 0x3F) | (rval));

            parity ^= rval;

            byte_idx++;

        }*/

    }

//}