/ - Diff - Colony - Robotics Club

Revision 945

Added by Austin Buchan over 15 years ago

Integrated new BOM1.5 compatible code. Also put eeprom code for reading ID and BOM type from EEPROM. will need to program each robot's eeprom separately later. This has been tested and verified to work on robots with different BOM types.

     #include <dragonfly_lib.h>
     /**
      * init_dragonfly - Initializes functions based on configuration parameters
      * examples:
+     *
      * init_dragonfly (ALL_ON); - Turns on all basic subsystems. More complex ones that require
      * 		their own configuration parameters must still be called on their own.
+     *
      * init_dragonfly (ANALOG | SERIAL | BUZZER);
      * Initialize ADC, USB, XBee, and Buzzer
+     *
      * init_dragonfly (MOTORS | ORB);
      * Initialize the motors and ORB.
      **/
     /* init_dragonfly - Initializes functions based on configuration parameters
        examples:
        init_dragonfly (0, 0, 0); - just initialize the digital IO (buttons, potentiometer)
        init_dragonfly (ANALOG | SERIAL | BUZZER, C0_C1_ANALOG, BAUD115200);
        Initialize ADC and set C0 and C1 as analog inputs.  Initialize serial and set baud rate
        to 115200 bps.  Initialize the buzzer.
        init_dragonfly (MOTORS | ORB, 0, 0);
        Initialize motor driving and the color fading abilities of the ORB. */
     /**
      * @defgroup dragonfly Dragonfly
      * @brief General Dragonfly Functions
-...
      **/
     /**
      * Initializes the components specified by config. Will turn on interrupts
      * 	automatically.
+     *
      * 	@param config The subsystems that you wish to turn on. Check dragonfly_lib.h for
      * 			valid values.
      * Initializes the components specified by config.
+     *
      * @see analog_init, usb_init, xbee_init, buzzer_init,
      * bom_init, orb_init, motors_init, lcd_init
      **/
     void dragonfly_init(int config) {
       sei();
     void flash_red(void);
       //Enables the hardware buttons on the board as input pins
     	//	with internal pullups enabled.
     	//Pin G0 is button 1
     	//Pin G1 is button 2
     	DDRG &= ~(_BV(PING0)|_BV(PING1));
       PORTG |= _BV(PING0)|_BV(PING1);
       if(config & ANALOG) {
         analog_init(ADC_START);
         range_init();
+      }
       if(config & COMM) {
         //Both default to 115200. Check serial.h for more information.
         usb_init();
         xbee_init();
+      }
       if(config & BUZZER) {
         buzzer_init();
+      }
       if(config & ORB) {
         orb_init();
+      }
       if(config & MOTORS)
         motors_init();
     void dragonfly_init(int config)
+    {
         sei();
         // Set directionality of various IO pins
         DDRG &= ~(_BV(PING0)|_BV(PING1));
         PORTG |= _BV(PING0)|_BV(PING1);
         if(config & ANALOG)
             analog_init(ADC_START);
         if(config & COMM)
+        {
             //Defaults to 115200. Check serial.h for more information.
             usb_init();
             xbee_init();
+        }
         if(config & BUZZER)
+        {
             sei();
             buzzer_init();
+        }
         if(config & ORB)
+        {
             sei();
             orb_init();
+        }
         if(config & MOTORS)
             motors_init();
       if(config & LCD)
         lcd_init();
       // delay a bit for stability
       _delay_ms(1);
         if(config & LCD)
             lcd_init();
         if(config & RANGE)
             range_init();
         if(config & BOM)
+        {
             unsigned char bom_read = get_bom_type();
             if(bom_read == 0xFF)
                 //warn that bom initialization failed
                 flash_red();
             else
                 bom_init(bom_read);
+        }
         // delay a bit for stability
         _delay_ms(1);
+    }
     //flash lights red three times and restore ports
     void flash_red(void)
+    {
         cli();
         char dd = DDRC;
         char po = PORTC;
         char i;
         DDRC = 0x77;
         for(i = 0; i<3; i++)
+        {
             PORTC = 0x77;
             delay_ms(300);
             PORTC = 0x66;
             delay_ms(300);
+        }
         DDRC = dd;
         PORTC = po;
         sei();
+    }
     /** @} **/ //end defgroup

     #define ORB    0x04
     /** @brief Initialize the motors **/
     #define MOTORS 0x08
     /** @brief Initialize I2C **/
     #define I2C    0x20
     /** @brief Initialize the buzzer **/
     #define BUZZER 0x10
     #define BUZZER 0x40
     /** @brief Initialize the LCD screen **/
     #define LCD    0x20
     /** @brief Initialize everything **/
     #define ALL_ON 0xFF
     #define LCD    0x80
     /** @brief Initialize the rangefinders **/
     #define RANGE  0x0100
     /** @brief Initialize the BOM **/
     #define BOM  0x0200
     /** @brief Initialize everything  **/
     #define ALL_ON 0x03FF
     /** @brief Initialize the board **/
     void dragonfly_init(int config);
-...
     #include <bom.h>
     #include <move.h>
     #include <reset.h>
     #include <math.h>
     #include <eeprom.h>
     #endif

     unsigned char get_robotid(void) {
         unsigned char ret;
         unsigned char c0, c1, c2;
         eeprom_get_byte(EEPROM_ROBOT_ID_ADDR, &ret);
         eeprom_get_byte(EEPROM_ROBOT_ID_ADDR, &c0);
         eeprom_get_byte(EEPROM_ROBOT_ID_ADDR+1, &c1);
         eeprom_get_byte(EEPROM_ROBOT_ID_ADDR+2, &c2);
         if(c0 == 'I' && c1 == 'D')
             return c2;
         else
             return 0xFF;
+    }
     unsigned char get_bom_type(void) {
         unsigned char c0, c1, c2, c3;
         return ret;
+    }
         eeprom_get_byte(EEPROM_BOM_TYPE_ADDR, &c0);
         eeprom_get_byte(EEPROM_BOM_TYPE_ADDR+1, &c1);
         eeprom_get_byte(EEPROM_BOM_TYPE_ADDR+2, &c2);
         eeprom_get_byte(EEPROM_BOM_TYPE_ADDR+3, &c3);
         if(c0 == 'B' && c1 == 'O' && c2 == 'M')
             return c3;
         else
             return 0xFF;
+    }

      #ifndef _EEPROM_H_
      #define _EEPROM_H_
      #define EEPROM_ROBOT_ID_ADDR 0x0b
      #include <bom.h>
      #define EEPROM_ROBOT_ID_ADDR 0x10
      #define EEPROM_BOM_TYPE_ADDR 0x14
      /** @brief store a byte to eeproem
       *  @return 0 if success, nonzero on failure
       */
-...
      /** @brief get stored robot ID
+      *
       *  returnes the value of eerpom at EEPROM_ROBOT_ID_ADDR
       *  checks that EEPROM has been programed with an ID and returns it
+      *
       *  @return the robot id, if it is stored. If it returns 0xff it is probably invalid
       *  @return the robot id, if it is stored. If it returns 0xFF it is probably invalid
       */
       unsigned char get_robotid(void);
      unsigned char get_robotid(void);
        /** @brief get stored robot ID
+      *
       * checks that EEPROM has been programed with an BOM type and returns it
+      *
       *  @return the robot bom type as defined in bom.h, if it is stored. If it returns 0xFF it is probably invalid
       */
      unsigned char get_bom_type(void);
      #endif

     #include <dragonfly_lib.h>
     #include "bom.h"
     #include "dio.h"
     #include "serial.h"
     #include "analog.h"
     //constants
     //On the original BOM1.0, the emmitter angular order does not match the analog mux order
     //so you need to iterate through the mux index in the following order if you want to get
     //the detector readings in order:
     static const char lookup[16] = {7,6,5,0xe,1,4,3,2,0xf,0,0xd,8,0xc,0xb,9,0xa};
     // internal function prototypes
-...
     #define MONK3 _PIN_E6     //blue
     #define MONK2 _PIN_E7     //white
     #define BOM_VALUE_THRESHOLD 200
     #define BOM_VALUE_THRESHOLD 200
     #define NUM_BOM_LEDS 16
     /*
       *The following pin definitions are for the BOM v1.5
       */
     #define BOM_MODE	_PIN_E2	//dio0
     #define BOM_STROBE	_PIN_E3	//dio1
     #define BOM_DATA	_PIN_A0 //servo0
     #define BOM_CLOCK	_PIN_A1	//servo1
     #define BOM_S0		_PIN_E5	//dio3
     #define BOM_S1		_PIN_E4	//dio2
     #define BOM_S2		_PIN_E6	//dio4
     #define BOM_S3		_PIN_E7	//dio5
     #define BOM_OUT		PF0		//analog(yellow)
     /**
      * @defgroup bom BOM (Bearing and Orientation Module)
      * @brief Functions for dealing with the BOM.
-...
      * Include bom.h to access these functions.
+     *
      * @{
      **/
     static unsigned int bom_val[NUM_BOM_LEDS];
     static char bom_type = BOM;
     /**
      * Initializes the BOM.
      * Call bom_init before reading bom values or turning bom leds.
+     *
      * @bugs INCOMPLETE - need to fill in init routine for BOM15
+     *
      * @see bom_refresh, bom_leds_on, bom_leds_off
      **/
     void bom_init(char type) {
         bom_type = type;
         switch(bom_type) {
         case BOM:
             break;
         case BOM15:
             break;
         case RBOM:
             break;
         //default:
+        }
+    }
     /**
      * Iterates through each bit in the bit_field. For each set bit, sets the corresponding bom select bits
      *    and updates the corresponding bom value with an analog_get8 reading.  analog_init and bom_init
      *    must be called for this to work.
+     *
+     *
      * @param bit_field specifies which elements in bom_val[] should be updated. Use BOM_ALL to refresh all values.
      *    Ex. if 0x0003 is passed, bom_val[0] and bom_val[1] will be updated.
+     *
      * @see bom_get
      **/
     void bom_refresh(int bit_field) {
         int i;
         analog_stop_loop();
         for(i = 0; i < NUM_BOM_LEDS; i++) {
             if(bit_field & 0x1) {
                 bom_select(lookup[i]);
                 bom_val[i] = analog_get8(MONKI);
+            }
             bit_field = bit_field >> 1;
+        }
         analog_start_loop();
+    }
     /**
      * Gets the bom reading from bom_val[which].  Call bom_refresh beforehand to read new bom values.
+     *
      * @param which which bom value to return
+     *
      * @return the bom value
+     *
      * @see bom_refresh
      **/
     int bom_get(int which) {
         return bom_val[which];
+    }
     /**
      * Compares all the values in bom_val[] and returns the index to the lowest (max) value element.
      * Returns the direction of the maximum BOM reading,as an integer in the range 0-15. 0 indicates
      * to the robot's right, while the rest of the sensors are numbered counterclockwise.
+     *
      * @return index to the lowest (max) bom value element.  -1 if no value is lower than
      *    BOM_VALUE_THRESHOLD
      **/
     int bom_get_max(void) {
         int i, lowest_val, lowest_i;
         lowest_i = -1;
      **/
     static unsigned int bom_val[NUM_BOM_LEDS];
     static volatile char bom_type = BOM;
     static int select_pins[4];
     static int analog_pin;
     /**
      * Initializes the BOM.
      * Call bom_init before reading bom values or turning bom leds.
+     *
      * @bugs INCOMPLETE - No utilization of BOM1.5 RSSI capability. Probably leave this out
      * until Cornell and Pras return
+     *
      * @see bom_refresh, bom_leds_on, bom_leds_off
      **/
     void bom_init(char type) {
         bom_type = type;
         switch(bom_type) {
         case BOM10:
     		select_pins[0] = MONK0;
     		select_pins[1] = MONK1;
     		select_pins[2] = MONK2;
     		select_pins[3] = MONK3;
     		analog_pin = MONKI;
             break;
         case BOM15:
             //Sets BOM1.5 to normal [BOM] mode
             digital_output(BOM_MODE, 0);
     		select_pins[0] = BOM_S0;
     		select_pins[1] = BOM_S1;
     		select_pins[2] = BOM_S2;
     		select_pins[3] = BOM_S3;
     		bom_set_leds(BOM_ALL);
     		analog_pin = BOM_OUT;
             break;
         case RBOM:
             break;
         //default:
+        }
+    }
     /**
      * Iterates through each bit in the bit_field. For each set bit, sets the corresponding bom select bits
      *    and updates the corresponding bom value with an analog_get8 reading.  analog_init and bom_init
      *    must be called for this to work.
+     *
+     *
      * @param bit_field specifies which elements in bom_val[] should be updated. Use BOM_ALL to refresh all values.
      *    Ex. if 0x0003 is passed, bom_val[0] and bom_val[1] will be updated.
+     *
      * @see bom_get
      **/
     void bom_refresh(int bit_field) {
         int i;
         analog_stop_loop();
         for(i = 0; i < NUM_BOM_LEDS; i++) {
             if(bit_field & 0x1) {
                 bom_select(i);
                 bom_val[i] = analog_get8(analog_pin);
+            }
             bit_field = bit_field >> 1;
+        }
         analog_start_loop();
+    }
     /**
      * Gets the bom reading from bom_val[which].  Call bom_refresh beforehand to read new bom values.
+     *
      * @param which which bom value to return
+     *
      * @return the bom value
+     *
      * see bom_refresh
      **/
     int bom_get(int which) {
         return bom_val[which];
+    }
     /**
      * Compares all the values in bom_val[] and returns the index to the lowest (max) value element.
+     *
      * @return index to the lowest (max) bom value element.  -1 if no value is lower than
      *    BOM_VALUE_THRESHOLD
      **/
     int bom_get_max(void) {
         int i, lowest_val, lowest_i;
         lowest_i = -1;
         lowest_val = 255;
         for(i = 0; i < NUM_BOM_LEDS; i++) {
             if(bom_val[i] < lowest_val) {
                 lowest_val = bom_val[i];
                 lowest_i = i;
+            }
+        }
         if(lowest_val < BOM_VALUE_THRESHOLD)
             return lowest_i;
         else
             return -1;
+    }
     /**
      * Iterates through each bit in the bit_field. For each set bit, turns on the corresponding bom led.
      *    bom_init must be called for this to work. Only works with BOM_ALL if using the original bom.
+     *
      * @param bit_field specifies which leds should be turned on.  Use BOM_ALL to turn on all bom leds.
      *    Ex. if 0x0005 is passed, leds 0 and 2 will be turned on.
      **/
     void bom_leds_on(int bit_field) {
         switch(bom_type) {
         case BOM:
             if(bit_field == BOM_ALL) {
                 digital_output(MONKL, 1);
+            }
             break;
         case BOM15:
             //add bom 1.5 code here
             break;
         case RBOM:
             //add rbom code here
             break;
             if(bom_val[i] < lowest_val) {
                 lowest_val = bom_val[i];
                 lowest_i = i;
+            }
+        }
+    }
     /**
      * Iterates through each bit in the bit_field. For each set bit, turns off the corresponding bom led.
      *    bom_init must be called for this to work. Only works with BOM_ALL if using the original bom.
+     *
      * @param bit_field specifies which leds should be turned off.  Use BOM_ALL to turn off all bom leds.
      *    Ex. if 0x000B is passed, leds 0 and 3 will be turned off.
      **/
     void bom_leds_off(int bit_field) {
         switch(bom_type) {
         case BOM:
             if(bit_field == BOM_ALL) {
                 digital_output(MONKL, 0);
+            }
             break;
         case BOM15:
             //add bom 1.5 code here
             break;
         case RBOM:
             //add rbom code here
             break;
         if(lowest_val < BOM_VALUE_THRESHOLD)
             return lowest_i;
         else
             return -1;
+    }
     /**
      * Iterates through each bit in the bit_field. If the bit is set, the corresponding emitter will
      *    be enabled to turn on when bom_on() is called.
      *    bom_init must be called for this to work.
+     *
      * @param bit_field specifies which leds should be turned on.  Use BOM_ALL to turn on all bom leds.
      *    Ex. if 0x0005 is passed, leds 0 and 2 will be turned on.
      **/
     void bom_set_leds(int bit_field) {
         int i;
     	unsigned int mask = 1<<(NUM_BOM_LEDS-1);
     	switch(bom_type) {
         case BOM:
             if(bit_field == BOM_ALL)
                 digital_output(MONKL, 1);
             break;
         case BOM15:
     	    for(i=NUM_BOM_LEDS; i>0; i--)
+    	    {
     		    //set the current bit, sending MSB first
     		    digital_output(BOM_DATA, bit_field&mask);
     		    //then pulse the clock
     		    digital_output(BOM_CLOCK, 1);
     		    digital_output(BOM_CLOCK, 0);
     			mask = mask>>1;
+    	    }
             break;
         case RBOM:
             //add rbom code here
             break;
+        }
+    }
+    }
     /**
      * (DEPRECATED) Wrapper function for new BOM code.  Refreshes buffer and returns the max bom value.
      * (DEPRECATED) Returns the direction of the maximum BOM reading,
      * as an integer in the range 0-15. 0 indicates to the
      * robot's right, while the rest of the sensors are
      * numbered counterclockwise. This is useful for determining
      * the direction of a robot flashing its BOM, of only one
      * robot is currently doing so. analog_init must be called
      * before this function can be used.
+     *
      * @return the direction of the maximum BOM reading
+     *
      * @see bom_refresh, bom_get_max
      * @see analog_init
      **/
     int get_max_bom(void) {
         bom_refresh(BOM_ALL);
-...
+    }
     /**
      * (DEPRECATED) Turns on all bom leds.
      * Flashes the BOM.  If using a BOM1.5, only the emitters that have been enabled using
      * bom_set_leds will turn on.
+     *
      * @see bom_off
      * @see bom_off, bom_set_leds
      **/
     void bom_on(void)
+    {
       bom_leds_on(BOM_ALL);
       switch(bom_type) {
       case BOM10:
     	digital_output(MONKL, 1);
     	break;
       case BOM15:
     	digital_output(BOM_STROBE, 1);
     	break;
       case RBOM:
     	break;
+      }
+    }
     /**
      * (DEPRECATED) Turns off all bom leds.
      * Turns off all bom leds.
+     *
      * @see bom_on
      **/
     void bom_off(void)
+    {
         bom_leds_off(BOM_ALL);
       switch(bom_type) {
       case BOM:
     	digital_output(MONKL, 0);
     	break;
       case BOM15:
     	digital_output(BOM_STROBE, 0);
     	break;
       case RBOM:
     	break;
+      }
+    }
     /** @} **/ //end group
     -static void bom_select(char which) {
           if (which&8)
             digital_output(MONK3, 1);
           else
             digital_output(MONK3, 0);
           if (which&4)
             digital_output(MONK2, 1);
           else
             digital_output(MONK2, 0);
     //select a detector to read
     static void bom_select(char which) {
     	if(bom_type == BOM)
     	  which = lookup[(int)which];
         if (which&8)
           digital_output(select_pins[3], 1);
         else
           digital_output(select_pins[3], 0);
           if (which&2)
             digital_output(MONK1, 1);
           else
             digital_output(MONK1, 0);
         if (which&4)
           digital_output(select_pins[2], 1);
         else
           digital_output(select_pins[2], 0);
           if (which&1)
             digital_output(MONK0, 1);
           else
             digital_output(MONK0, 0);
+    }
         if (which&2)
           digital_output(select_pins[1], 1);
         else
           digital_output(select_pins[1], 0);
         if (which&1)
           digital_output(select_pins[0], 1);
         else
           digital_output(select_pins[0], 0);
+    }

     /** @brief Include all elements in the 16-bit bitfield **/
     #define BOM_ALL 0xFFFF
     /** @brief Original BOM - No Range, No Individual LED control **/
     #define BOM     0
     #define BOM10     0
     /** @brief BOM 1.5 - No Range, Individual LED control **/
     #define BOM15   1
     /** @brief RBOM - Range, Individual LED control **/
     #define RBOM    2
     /** @brief Initialize the bom according to bom type **/
     void bom_init(char type);
     /** @brief Refresh bom_val[] with new values from analog8.  analog_init and bom_init must be called for this to work. **/
     void bom_refresh(int bit_field);
     /** @brief Gets the bom reading from bom_val[which].  Call bom_refresh beforehand to read new bom values. **/
     int bom_get(int which);
     /** @brief Compares all the values in bom_val[] and returns the index to the highest value element. **/
     int bom_get_max(void);
     /** @brief Turns on the selected bom leds. Only works with BOM_ALL if using the original bom. **/
     void bom_leds_on(int bit_field);
     /** @brief Turns off the selected bom leds. Only works with BOM_ALL if using the original bom. **/
     void bom_leds_off(int bit_field);
     /** @brief (DEPRECATED) Wrapper function. See bom_refresh and bom_get_max **/
     /** @brief Enables the selected bom leds on a BOM1.5 **/
     void bom_set_leds(int bit_field);
     /** @brief (DEPRECATED) Gets and compares all bom values.  Returns the index to the highest value element. **/
     int get_max_bom(void);
     /** @brief (DEPRECATED) Wrapper function. See bom_leds_on. **/
     /** @brief Turns on all BOM leds, or turns on enabled leds on a BOM1.5. **/
     void bom_on(void);
     /** @brief (DEPRECATED) Wrapper function. See bom_leds_off. **/
     /** @brief Turns off all bom leds. **/
     void bom_off(void);
     /** @} **/

Also available in: Unified diff

Project

General

Profile

Colony

Revision 945