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>

 *

 ********/

/** @file main.c

 *  @brief Contains the main function for the toolbox code.

 *

 *  @author Suresh Nidhiry (snidhiry@andrew.cmu.edu)

 *  @author Kevin Woo (kwoo@2ndt.com)

 */

//Includes

#include <avr/io.h>

#include <avr/interrupt.h>

#include <avr/eeprom.h>

#include <stdint.h>

#include <util/delay.h>

#include <tooltron.h>

#include <toolbox_pindefs.h>

#include "jumptable.h"

/***

 * TWAIT - minutes to wait before green button is pressed to kill power

 * TWARN - minutes until warning (blink yellow, allow more time with green button)

 * TMAX  - minutes until power is killed (unless tool is on)

 */

#define TWAIT   1

#define TWARN   1

#define TMAX    2

uint8_t sec;

uint8_t min;

typedef enum {

    wait,   // wait for a turn on packet

    pwron,  // poweron

    idiot,  // user tried to hit green with the machine switch on

    toolon, // tool on

    warn,   // time warning

    off     // tool off

} state_t;

/**

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

    }

}

/**

 * @brief Sets the relay to a particular state

 *

 * @param state Sets the relay to either ON or OFF

 * @return void

 */

void toggle_relay(uint8_t state) {

    if (state == ON) {

        RELAY_PORT |= RELAY;

    } else {

        RELAY_PORT &= ~RELAY;

    }

}

/**

 * @brief Returns the current value of the AC voltage sense

 *

 * @return ON if AC voltage is detected, OFF otherwise

 */

inline uint8_t read_vac(void) {

    return (!(VAC_PORT & VAC_SENSE));

}

/**

 * @brief Returns the current value of the buttons

 *

 * You can read multiple buttons at once but it will only return TRUE

 * if all of the buttons are pressed. You should OR the buttons together

 * while passing them into which.

 *

 * Software debounce is written in to protect against vibration

 * transients, definable by BUTTON_DEBOUNCE. Specifically, for the

 * button to not be pressed it only needs to read 0 once, but needs to

 * read 1 BUTTON_DEBONCE times in a row to return TRUE.

 *

 * @param which The buttons to read

 * @return TRUE if the buttons are pressed, FALSE otherwise

 */

inline uint8_t read_button(uint8_t which) {

    uint8_t count = 0;

    while(!(BUT_PORT & (which))){

        if(++count > BUTTON_DEBOUNCE) {

            return TRUE;

        }

    }

    return FALSE;

}

/**

 * @brief Initialize the hardware timer to be a realtime clock

 *

 * This will set timer 1 to cause an interrupt every 1 second assuming

 * you are using a 8MHz clock. The global sec and min counters are 

 * reset as well.

 *

 * @return void

 */

void init_timer(void) {

    // Clear timmer on OCRA1 Compare match

    // No prescale

    TCCR1B |= _BV(WGM12) | _BV(CS12);

    // 1 second @ 8MHz clock

    OCR1A = 0x7A12;

    TIMSK = _BV(OCIE1A);

    sec = 0;

    min = 0;

}

/**

 * @brief Resets the timer

 * @return void

 */

void reset_timer(void) {

    sec = 0;

    min = 0;

}

/**

 * @brief Timer1 interrupt vector

 *

 * This counts the seconds and minute since the last reset. Automatically

 * resets the seconds once it rolls over to 60s and increments minutes.

 *

 * @note minutes may overflow if you let it run long enough. There are no

 * checks against this

 */

ISR(TIMER1_COMPA_vect) {

    if (sec == 59) {

        sec = 0;

        ++min;

    } else {

        ++sec;

    }

}

int main(void) {

    state_t state = wait;

    // This reads the node addr

    uint8_t addr = read_addr();

    uint8_t ms_timer=0;

    uint8_t mbuf[PROGD_PACKET_SIZE];    // For reading messages

    uint8_t len;

        /***** Start Start-up Sequence *****/

    // We are initializing the pins and the RS485 in the bootloader

        sei();                                //Enable interrupts

        init_timer();                //Set registers for timer

        /***** End Start-up Sequence *****/

    uint8_t resp;

        while(1) {

        switch (state) {

            case wait:

                // Reset the lights and relay

                toggle_led(LED_RED, ON);

                toggle_led(LED_YELLOW | LED_GREEN, OFF);

                toggle_relay(OFF);

                // Wait for a packet

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

                // Turn on the tool

                if (resp == TT_GRANT) {

                    send_packet(TT_ACK, addr, NULL, 0);

                    toggle_led(LED_RED, OFF);

                    toggle_led(LED_YELLOW, ON);

                    state = pwron;

                    reset_timer();

                } else if (resp == TT_PING) {

                    _delay_ms(50);

                    send_packet(TT_ACK, addr, NULL, 0);

                }

                break;

            case pwron:

                // Make sure the tool isn't on before we apply power

                if (read_vac() == ON) {

                    ms_timer = 0;

                    state = idiot;

                    break;

                }

                // First check for timeout or red button press

                if ((read_button(BUT_RED)) || (min >= TWAIT)) {

                    state = off;

                }

                // If time is not expired, give access on green press

                else if (read_button(BUT_BLACK)) {

                    toggle_led(LED_YELLOW, OFF);

                    toggle_led(LED_GREEN, ON);

                    toggle_relay(ON);

                    reset_timer();

                    state = toolon;

                } 

                break;

            case idiot:

                // We can safely exit this state if the tool is switched off

                if (read_vac() == OFF) {

                    state = pwron;

                    toggle_led(LED_RED, OFF);

                    toggle_led(LED_YELLOW, ON);

                    break;

                }

                // The user has cancelled the tooltron request

                if (read_button(BUT_RED)) {

                    state = off;

                    break;

                }

                // Blink code

                if(ms_timer >= 100) {

                    toggle_led(LED_YELLOW, ON);

                    toggle_led(LED_RED, OFF);

                    if(ms_timer >= 200) {

                        ms_timer = 0;

                    }

                } else {

                    toggle_led(LED_YELLOW, OFF);

                    toggle_led(LED_RED, ON);

                }

                _delay_ms(2);

                ms_timer++;

                break;

            case toolon:

                // Give the tool power until the red button is pressed

                if ((read_button(BUT_RED)) && (read_vac() == OFF)) {

                        state = off;

                        toggle_relay(OFF);

                // Time is about to expire

                } else if (min >= TWARN) {

                    toggle_led(LED_GREEN, OFF);

                    state = warn;

                }

                break;

            case warn:

                // Blink the LED

                        if(ms_timer >= 100) {

                            toggle_led(LED_YELLOW, ON);

                            if(ms_timer >= 200) {

                                ms_timer = 0;

                            }

                        } else {

                            toggle_led(LED_YELLOW, OFF);

                        }

                // User turns off the tool if it's safe

                if (read_button(BUT_RED) && read_vac() == OFF) {

                    toggle_relay(OFF);

                    state = off;

                // Time extension

                } else if (read_button(BUT_BLACK)) {

                    toggle_led(LED_GREEN, ON);

                    toggle_led(LED_YELLOW, OFF);

                    reset_timer();

                    state = toolon;

                // Time expired and it's safe to turn off

                } else if ((min >= TMAX) && (read_vac() == OFF)) {

                    toggle_relay(OFF);

                    state = off;

                }

                        _delay_ms(2);

                        ms_timer++;

                break;

            case off:

                toggle_led(LED_GREEN | LED_YELLOW, OFF);

                toggle_led(LED_RED, ON);

                state = wait;

                break;

            default: state = wait;

        }     

        }

        return 0;

}