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 <util/delay.h>

#include "rs485_int.h"

#include <avr/interrupt.h>

#include <avr/io.h>

#include <tooltron.h>

#include "timer.h"

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

/** @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))

/***** LED definitions *****/

#define LED_RED (_BV(PC5))

#define LED_YELLOW (_BV(PC4))

#define LED_GREEN (_BV(PC3))

#define ADDR 2

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

void init_pins(void) {

  DDRB = 0;

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

  DDRC |= LED_RED | LED_YELLOW | LED_GREEN;

  PORTC |= 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) {

        LED_PORT &= ~(which);

    } else {

        LED_PORT |= (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,

    rsp

} state_t;

int main(void) {

    uint8_t mbuf[PROGD_PACKET_SIZE];

    uint8_t resp;

    uint8_t c;

    state_t state = req;

  rs485_init(BAUD9600); 

  init_pins();

  init_timer();

  sei();

  while(1) {

      switch(state) {

          case req:

              toggle_led(LED_RED|LED_GREEN|LED_YELLOW, OFF);

              // Wait for a packet

              resp = parse_packet(mbuf, ADDR);

              if (resp == TT_GET_KEY) {

                  toggle_led(LED_YELLOW, ON);

                  reset_timer();

                  reset_timeout_flag();

                  start_timer();

                  c = ' ';

                  state = press;

              }

              break;

            case press:

                c = get_button();

                if (seconds > TIMEOUT_SECONDS) {

                    set_timeout_flag();

                    state = send;

                } else if (c != ' ') {

                    state = send;

                }

                break;

        case send:

                if (timeoutflag == 1) {

                    send_packet(TT_TIMEOUT, ADDR);

                    state = req;

                } else {

                    send_packet_data(TT_SEND_KEY, ADDR, &c, 1);

                }

                state = rsp;

                break;

        case rsp:

                resp = parse_packet(mbuf, ADDR);

                if (resp == TT_ACK

    if (timeout_flag == 0) {

        //respond with key pressed

        uart_send_byte(c);

        //wait for response

        c=0;

        reset_timeout_flag();

        reset_timer();

        while((uart_get_byte(&c) < 0) && (seconds < TIMEOUT_SECONDS));

        PORTC |= LED_YELLOW;

        switch(c)

        {

          case TT_ACK:

            PORTC &= ~LED_GREEN;

            break;

          case TT_NACK:

            PORTC &= ~LED_RED;

            break;

          case TT_GET_KEY: //this means the states are messed up

            PORTC &= (~LED_RED & ~LED_YELLOW & ~LED_GREEN);

            break;

          case 0: //timeout

            PORTC &= (~LED_RED & ~LED_YELLOW);

            break;            

        default: //bad packet

            PORTC &= (~LED_RED & ~LED_GREEN);

            break;

        }

        stop_timer();

        _delay_ms(1000);

      }

    } 

  return 0;

}