Tooltron - / - Diff - Robotics Club

Revision 202

     #include <avr/wdt.h>
     /**
      * This function resets the board, resetting the hardware back to almost the
      * same state as a power on reset. Note that you must do the following in
      * this order upon reset or the process will fail:
+     *
      * 1. Reset WDRF in MCUSR to 0
      * 2. call wdt_diable() to disable the watchdog in the right order
      * 3. Set WDTCSR to clear out all traces of the watchdog timer
      **/
     void reset(void) {
         wdt_enable(WDTO_15MS);
         while(1);
+    }

     //Includes
     #include <avr/io.h>
     #include <avr/interrupt.h>
     #include <avr/eeprom.h>
     #include <stdint.h>
     #include <util/delay.h>
     #include <tooltron.h>
     #include "jumptable.h"
     #include "reset.h"
     #include <toolbox_pindefs.h>
     #define TOOLBOX
     #define RELAY       _BV(PORTD4)
     #define VAC_SENSE   _BV(PIND3)
     #define BUT_RED     _BV(PINB4)
     #define BUT_BLACK   _BV(PINB3)
     #define LED_GREEN   _BV(PORTB2)
     #define LED_YELLOW  _BV(PORTB1)
     #define LED_RED     _BV(PORTB0)
     #define ON      0x01
     #define OFF     0x00
     /***** change ADDR ****/
     #define ADDR 18
     #define DELIM '^'
     #define SERVER 1
     #define TURNON 'O' 'O''0'
     /***
      * TWAIT - minutes to wait before green button is pressed to kill power
      * TWARN - minutes until warning (blink yellow, allow more time with green button)
-...
     uint8_t min;
     typedef enum {
         sd,     // start delimitor
         src,    // src
         dest,   // destination
         data,   // data
         cs,     // checksum
         ack,    // send ack
         wait,   // wait for a turn on packet
         pwron,  // poweron
         idiot,  // user tried to hit green with the machine switch on
         toolon, // tool on
-...
         off     // tool off
     } state_t;
     void init_pins(void) {
         DDRB = 0x00;
         DDRB = _BV(DDB0) | _BV(DDB1) | _BV(DDB2) | _BV(DDB5);
         DDRD = _BV(DDB4);
         PORTB = 0x00;
+    }
     /**
      * @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) {
             PORTB &= ~which;
             LED_PORT &= ~(which);
         } else {
             PORTB |= which;
             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) {
             PORTD |= RELAY;
             RELAY_PORT |= RELAY;
         } else {
             PORTD &= ~RELAY;
             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 (!(PIND & VAC_SENSE));
         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 (!(PINB & 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
         OCR1AH =0x7A;
         OCR1AL =0x12;
         OCR1A = 0x7A12;
         TIMSK = _BV(OCIE1A);
-...
         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++;
             ++min;
         } else {
             sec++;
             ++sec;
+        }
+    }
     int main(int argc, char **argv) {
         state_t state = sd;
         uint8_t packet[3];
     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
     	init_pins();		//Set pin directions
         rs485_init(51);
     	/***** End Start-up Sequence *****/
         uint8_t r;
         uint8_t resp;
         packet[0] = 0x00;
         packet[1] = 0x00;
         packet[2] = 0x00;
     	while(1) {
             switch (state) {
                 case sd:
                 case wait:
                     // Reset the lights and relay
                     toggle_led(LED_RED, ON);
                     toggle_led(LED_YELLOW, OFF);
                     toggle_led(LED_GREEN, OFF);
                     toggle_led(LED_YELLOW | LED_GREEN, OFF);
                     toggle_relay(OFF);
                     while ((rs485_get_byte(&r)) < 0);
                     if (r == DELIM) {
                         state = src;
+                    }
                     break;
                 case src:
                     while ((rs485_get_byte(&r)) < 0);
                     if (r == DELIM) {
                         state = src;
                     } else {
                         packet[0] = r;
                         state = dest;
+                    }
                     break;
                 case dest:
                     while ((rs485_get_byte(&r)) < 0);
                     // Wait for a packet
                     resp = parse_packet(mbuf, addr);
                     if (r == DELIM) {
                         packet[0] = 0x00;
                         state = src;
                     } else if (r == ADDR) {
                         packet[1] = r;
                         state = data;
                     } else {
                         packet[0] = 0x00;
                         state = sd;
+                    }
                     break;
                 case data:
                     while ((rs485_get_byte(&r)) < 0);
                     if (r == DELIM) {
                         packet[0] = 0x00;
                         packet[1] = 0x00;
                         state = src;
                     } else {
                         packet[2] = r;
                         state = cs;
+                    }
                     break;
                 case cs:
                     while ((rs485_get_byte(&r)) < 0);
                     // Turn on the tool
                     if (resp == TT_ON) {
                         send_packet(TT_ACK, addr);
                     if (r == (packet[0] ^ packet[1] ^ packet[2])) {
                         if (packet[2] == TT_TON) {
                             state = ack;
                             break;
+                        }
                         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();
+                    }
                     packet[0] = 0x00;
                     packet[1] = 0x00;
                     packet[2] = 0x00;
                     state = sd;
                     break;
                 case ack:
                     rs485_send_byte(DELIM);
                     rs485_send_byte(ADDR);
                     rs485_send_byte(SERVER);
                     rs485_send_byte('A');
                     rs485_send_byte(ADDR ^ SERVER ^ 'A');
                     toggle_led(LED_RED, OFF);
                     toggle_led(LED_YELLOW, ON);
                     state = pwron;
                     reset_timer();
                     break;
                 case pwron:
     	      if (read_vac() == ON) {
     		ms_timer = 0;
     		state = idiot;
     		break;
+    	      }
                     // 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);
-...
                         reset_timer();
                         state = toolon;
                     // Timeout waiting for the user
                     } else if ((read_button(BUT_RED)) || (min >= TWAIT)) {
                         state = off;
+                    }
                     break;
     	    case idiot:
     	      if (read_vac() == OFF) {
     		state = pwron;
     		toggle_led(LED_RED, OFF);
     		toggle_led(LED_YELLOW, ON);
     		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;
+                    }
     	      if (read_button(BUT_RED)) {
     		state = off;
     		break;
+    	      }
                     // The user has cancelled the tooltron request
                     if (read_button(BUT_RED)) {
                         state = off;
                         break;
+                    }
     	      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);
+    	      }
                     // 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;
                     _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:
     		if(ms_timer >= 100) {
     		  toggle_led(LED_YELLOW, ON);
                     // 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);
+    		}
     		            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++;
     		        _delay_ms(2);
     		        ms_timer++;
                     break;
                 case off:
                     toggle_led(LED_GREEN, OFF);
                     toggle_led(LED_YELLOW, OFF);
                     toggle_led(LED_GREEN | LED_YELLOW, OFF);
                     toggle_led(LED_RED, ON);
                     state = sd;
                     state = wait;
                     break;
                 default: state = sd;
                 default: state = wait;
+            }
+    	}
     	return 0;

trunk/toolbox/reset.h (revision 202)
	1	#ifndef __RESET_H__
	2	#define __RESET_H__
	3
	4	void reset(void) __attribute__((noreturn));
	5
	6	#endif

     void (*rs485_init)(uint16_t) = JT_RS485_INIT;
     int8_t (*rs485_get_byte)(uint8_t*) = JT_RS485_GET_BYTE;
     void (*rs485_send_byte)(uint8_t) = JT_RS485_SEND_BYTE;
     char (*parse_packet)(uint8_t*) = JT_PARSE_PACKET;
     void (*send_packet)(uint8_t) = JT_SEND_PACKET;
     char (*parse_packet)(uint8_t*, uint8_t) = JT_PARSE_PACKET;
     void (*send_packet)(uint8_t, uint8_t) = JT_SEND_PACKET;
     #endif

     #include <avr/wdt.h>
     /**
      * This function resets the board, resetting the hardware back to almost the
      * same state as a power on reset. Note that you must do the following in
      * this order upon reset or the process will fail:
+     *
      * 1. Reset WDRF in MCUSR to 0
      * 2. call wdt_diable() to disable the watchdog in the right order
      * 3. Set WDTCSR to clear out all traces of the watchdog timer
      **/
     void reset(void) {
         wdt_enabled(WDTO_15MS);
+    }

trunk/common/reset.h (revision 202)
1		#ifndef __RESET_H__
2		#define __RESET_H__
3
4		void reset(void);
5
6		#endif

     #define RELAY       _BV(PORTD4)
     // AC Voltage Sense
     #define VAC_PORT    PORTD
     #define VAC_PORT    PIND
     #define VAC_SENSE   _BV(PIND3)
     // Buttons

     #define TT_GET_KEY  'k'     // Get a key from the keyboard
     #define TT_ACK      'a'     // Ack
     #define TT_NACK     'n'     // Nack
     #define TT_TON      'o'     // Turn the tool on
     #define TT_ON       'o'     // Turn the tool on
     #define TT_TO       'f'     // State timeout
     #define TT_TIMEOUT  't'     // Packet timeout
     #define TT_RESET    'r'     // Tool reset request

Also available in: Unified diff