Tooltron

/********

 * This file is part of Tooltron.

 *

 * Tooltron is free software: you can redistribute it and/or modify

 * it under the terms of the Lesser GNU General Public License as published by

 * the Free Software Foundation, either version 3 of the License, or

 * (at your option) any later version.

 *

 * Tooltron 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

 * Lesser GNU General Public License for more details.

 * You should have received a copy of the Lesser GNU General Public License

 * along with Tooltron.  If not, see <http://www.gnu.org/licenses/>.

 *

 * Copyright 2009 Kevin Woo <kwoo@2ndt.com>

 *

 ********/

#include "cardbox.h"

/***** Keypad definitions ******/

#define KEYPORT PORTB

#define KEYPIN PINB

#define KEYDDR  DDRB

/** @brief ROW1 of the keypad */

#define ROW4 (_BV(PB0))

/** @brief ROW2 of the keypad */

#define ROW3 (_BV(PB1))

/** @brief ROW3 of the keypad */

#define ROW2 (_BV(PB2))

/** @brief ROW4 of the keypad */

#define ROW1 (_BV(PB3))

/** @brief COL1 of the keypad */

#define COL4 (_BV(PB4))

/** @brief COL2 of the keypad */

#define COL3 (_BV(PB5))

/** @brief COL3 of the keypad */

#define COL2 (_BV(PB6))

/** @brief COL4 of the keypad */

#define COL1 (_BV(PB7))

#define ADDR 2

/***** Global variables *****/

void init_pins(void) {

  KEYDDR = ROW1 | ROW2 | ROW3 | ROW4;

  //KEYDDR = 0;

  KEYPORT = COL1 | COL2 | COL3 | COL4;

  LEDDDR = LED_RED | LED_YELLOW | LED_GREEN;

  // Turn the LEDs off

  LEDPORT |= LED_RED | LED_GREEN | LED_YELLOW;

  return;

}

/**

 * @brief Sets the LED to the specified state

 *

 * This sets LED which to the specified state. You can use this to set

 * multiple LEDs if you OR the LEDs desired into the which argument.

 *

 * @param which The LEDs to set

 * @parma state The state ON or OFF to set to the LEDs to

 * @return void

 */

void toggle_led(uint8_t which, uint8_t state) {

    if (state == ON) {

        LEDPORT &= ~(which);

    } else {

        LEDPORT |= (which);

    }

}

char get_button(void) {

        char ret = ' ';

    // Row 1 Strobe

  DDRB = (ROW1);

  PORTB = (COL1|COL2|COL3|COL4);

  if(!(PINB&(COL1)))

    ret ='1';

  else if(!(PINB&(COL2)))

    ret ='2';

  else if(!(PINB&(COL3)))

    ret ='3';

  else if(!(PINB&(COL4)))

    ret ='A';

  else {

    DDRB = (ROW2);

    PORTB = (COL1|COL2|COL3|COL4);

    // Row 2 Strobe

    if(!(PINB&(COL1)))

      ret ='4';

    else if(!(PINB&(COL2)))

      ret ='5';

    else if(!(PINB&(COL3)))

      ret ='6';

    else if(!(PINB&(COL4)))

      ret ='B';

    else {

      // Row 3 Strobe

      DDRB = (ROW3);

      PORTB = (COL1|COL2|COL3|COL4);

      if(!(PINB&(COL1)))

        ret ='7';

      else if(!(PINB&(COL2)))

        ret ='8';

      else if(!(PINB&(COL3)))

        ret ='9';

      else if(!(PINB&(COL4)))

        ret ='C';

      else{

        // Row 4 Strobe

        DDRB = (ROW4);

        PORTB = (COL1|COL2|COL3|COL4);

        if(!(PINB&(COL1)))

          ret ='*';

        else if(!(PINB&(COL2)))

          ret ='0';

        else if(!(PINB&(COL3)))

          ret ='#';

        else if(!(PINB&(COL4)))

          ret ='D';

            }

          }

        }

  DDRB = 0;

  PORTB = (COL1|COL2|COL3|COL4);

  return ret;

}

typedef enum {

    req,

    press,

    send,

    ack,

    rsp

} state_t;

int main(void) {

    uint8_t mbuf[PROGD_PACKET_SIZE];

    uint8_t cbuf[21];

    uint8_t clen;

    uint8_t resp;

    uint8_t c;

    uint8_t len;

    uint8_t retries = 0;

    state_t state = req;

    rs485_init(BAUD9600);

    init_pins();

    init_timer();

    card_reader_setup();

    sei();

    while(1) {

        switch(state) {

            case req:

                toggle_led(LED_RED|LED_GREEN|LED_YELLOW, OFF);

                // Start reading cards

                read_card = 1;

                // See if we have a card, otherwise check if we got

                // a message

                if (cr_flag != CR_NONE) {

                    read_card = 0;

                    // Reading failed

                    if (parse_card(&(cbuf[1]), &clen) < 0) {

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

                            toggle_led(LED_RED,ON);

                            _delay_ms(250);

                            toggle_led(LED_RED,OFF);

                            _delay_ms(250);

                        }

                    // Reading is good, wait for a key

                    } else {

                        start_timer();

                        reset_timer();

                        reset_timeout_flag();

                        state = press;

                    }

                    // Reset the card reader flag

                    cr_flag = CR_NONE;

                } else {

                    // Wait for a packet

                    resp = parse_packet(mbuf, &len, ADDR);

                    // Ping Request

                    if(resp == TT_PING){

                        _delay_ms(50);

                        send_packet(TT_ACK, ADDR, NULL, 0);

                    }

                }

                break;

            case press:

                toggle_led(LED_YELLOW,ON);

                cbuf[0] = get_button();

                retries = 0;

                if (seconds > TIMEOUT_SECONDS) {

                    set_timeout_flag();

                    state = send;

                } else if (cbuf[0] != ' ') {

                    state = send;

                } else {

                    _delay_ms(100);

                }

                break;

            case send:

                if (get_timeout_flag() == 1) {

                    toggle_led(LED_RED|LED_YELLOW,ON);

                    _delay_ms(500);

                    toggle_led(LED_RED|LED_YELLOW,OFF);

                    _delay_ms(500);

                    state = req;

                } else {

                    _delay_ms(50);

                    send_packet(TT_KC, ADDR, cbuf, 1 + clen);

                    state = ack;

                }

                break;

            case ack:

                resp = parse_packet(mbuf, &len, ADDR);

                if (resp == TT_ACK) {

                    state = rsp;

                    start_timer();

                    reset_timer();

                    state = rsp;

                } else if (retries == TT_MAX_RETRY) {

                    toggle_led(LED_RED, ON);

                    _delay_ms(1000);

                    toggle_led(LED_RED, OFF);

                    state = req;

                } else {

                    retries++;

                    state = send;

                }

                break;

            case rsp:

                resp = parse_packet(mbuf, &len,  ADDR);

                if (resp == TT_GRANT) {

                    toggle_led(LED_GREEN, ON);

                    _delay_ms(1000);

                    toggle_led(LED_GREEN, OFF);

                    state = req;

                } else if (resp == TT_DENY) {

                    toggle_led(LED_RED, ON);

                    _delay_ms(1000);

                    toggle_led(LED_RED, OFF);

                    state = req;

                } else if (seconds > TT_MAX_RETRY) {

                    toggle_led(LED_RED,ON);

                    _delay_ms(1000);

                    toggle_led(LED_RED, OFF);

                    state = req;

                }

                break;

            default:

                state = req;

                break;

        }

    }

    return 0;

}