Tooltron - /trunk/toolbox/main.c - Robotics Club

root / trunk / toolbox / main.c @ 204

History | View | Annotate | Download (8.6 KB)

 /********
  * 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"
 #include "reset.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 struct {
     uint8
 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.
+ *
  * @param which The buttons to read
  * @return TRUE if the buttons are pressed, FALSE otherwise
  */
 inline uint8_t read_button(uint8_t which) {
     return (!(BUT_PORT & (which)));
+}
 /**
  * @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 = eeprom_read_byte((void*)EEPROM_ADDR);
     uint8_t ms_timer=0;
     uint8_t mbuf[PROGD_PACKET_SIZE];    // For reading messages
         /***** 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, addr);
                 // Turn on the tool
                 if (resp == TT_ON) {
                     send_packet(TT_ACK, addr);
                     toggle_led(LED_RED, OFF);
                     toggle_led(LED_YELLOW, ON);
                     state = pwron;
                     reset_timer();
                 // Reset the board
                 } else if (resp == TT_RESET) {
                     send_packet(TT_ACK, addr);
                     reset();
+                }
                 break;
             case pwron:
                 // Make sure the tool isn't on before we apply power
                     if (read_vac() == ON) {
                             ms_timer = 0;
                             state = idiot;
                             break;
+                    }
                 // Wait for a black button press
                 if (read_button(BUT_BLACK)) {
                     toggle_led(LED_YELLOW, OFF);
                     toggle_led(LED_GREEN, ON);
                     toggle_relay(ON);
                     reset_timer();
                     state = toolon;
                 // Timeout waiting for the user
                 } else if ((read_button(BUT_RED)) || (min >= TWAIT)) {
                     state = off;
+                }
                 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;
+}