/ - Diff - Colony - Robotics Club

Revision 580

Added by Victor Marmol over 15 years ago

Updated bom.c and bom.h to implement James' changes for BOM1.5

     #include "analog.h"
     //constants
     const int lookup[16] = {7,6,5,0xe,1,4,3,2,0xf,0,0xd,8,0xc,0xb,9,0xa};
     static const char lookup[16] = {7,6,5,0xe,1,4,3,2,0xf,0,0xd,8,0xc,0xb,9,0xa};
     // internal function prototypes
     static void bom_select(char which);
     // internal function prototypes
     void output_high(int which);
     void output_low(int which);
-...
     #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
-...
      * The BOM is most often use to determine the direction of other
      * robots. This module contains functions for controlling the BOM.
+     *
      * There are currently two versions of the BOM in operation: v1.0
      * and v1.5.  v1.5 includes new functionality such as addressable
      * emitters, and RSSI range measurement.  If a BOM1.5 is connected
      * to a robot, make sure to add a BOM1_5 flag to dragonfly_init().
+     *
      * 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:
             is_bom_15 = 1;
             //Sets BOM1.5 to normal [BOM] mode
             output_low(BOM_MODE);
             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.
+     *
      * @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:
             int mask = 0x8000;
     	    for(; mask>0; mask=mask>>1)
+    	    {
     		    //set the current bit
     		    digital_output(BOM_DATA, 1);
     		    //then pulse the clock
     		    delay_ms(1);
     		    output_high(BOM_CLOCK);
     		    delay_ms(1);
     		    output_low(BOM_CLOCK);
+    	    }
             break;
         case RBOM:
             //add rbom code here
             break;
+        }
+    }
     /**
      * 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;
+        }
+    }
     /**
      * Initializes a BOM1.5 to have all emitters on, and in normal mode.
      * With this initialization the BOM1.5 is functionally equivalent to
      * BOM1.0
      **/
     void bom_15_init(void) {
     	is_bom_15 = 1;
     	bom_set_emitters(0xFFFF);
+    }
     /**
      * Sets a BOM1.5 to RSSI mode.
      **/
     void bom_RSSI_mode(void) {
     	output_high(BOM_MODE);
+    }
     /**
      * Sets a BOM1.5 to normal mode.
      **/
     void bom_normal_mode(void) {
     	output_low(BOM_MODE);
+    }
     /**
      * Sets which emitters come on when a BOM1.5 is turned on.
      * The LSB of the pattern corresponds to emitter 0, and the
      * MSB corresponds to emitter 15
      **/
     void bom_set_emitters(int pattern) {
     	int mask = 0x8000;
     	for(; mask>0; mask=mask>>1)
+    	{
     		//set the current bit
     		digital_output(BOM_DATA, 1);
     		//then pulse the clock
     		delay_ms(1);
     		output_high(BOM_CLOCK);
     		delay_ms(1);
     		output_low(BOM_CLOCK);
+    	}
+    }
     /**
      * Returns the direction of the maximum BOM reading,
      * (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
-...
      * @see analog_init
      **/
     int get_max_bom(void) {
     	int max_bom_temp = 0;
     	int a, i, j, h;
         h = 255;
         for (j = 0; j < 16; j++)
+        {
           i = lookup[j];
           if (i&8)
             output_high(is_bom_15?BOM_S3:MONK3);
           else
             output_low(is_bom_15?BOM_S3:MONK3);
           if (i&4)
             output_high(is_bom_15?BOM_S2:MONK2);
           else
             output_low(is_bom_15?BOM_S2:MONK2);
           if (i&2)
             output_high(is_bom_15?BOM_S1:MONK1);
           else
             output_low(is_bom_15?BOM_S1:MONK1);
           if (i&1)
             output_high(is_bom_15?BOM_S0:MONK0);
           else
             output_low(is_bom_15?BOM_S0:MONK0);
           a = analog8(is_bom_15?BOM_OUT:MONKI);
           if (a < h)
+          {
             h = a;
             max_bom_temp = j;
+          }
+        }
     	//threshold on the bom analog value.
     	//defined in bom.h
     	// if the analog value read is above the threshold, we cannot see a robot
     	// (remember, low means higher intensity).
     	if(h < BOM_VALUE_THRESHOLD) {
     		return max_bom_temp;
+    	}
     	else
     		return -1;
         bom_refresh(BOM_ALL);
         return bom_get_max();
+    }
     /**
      * Flashes the BOM. analog_init must be called before this
      * function can be used.
      * (DEPRECATED) Turns on all bom leds.
+     *
      * @see bom_off, analog_init
      * @see bom_off
      **/
     void bom_on(void)
+    {
       output_high(is_bom_15?BOM_STROBE:MONKL);
       bom_leds_on(BOM_ALL);
+    }
     /**
      * Stops flashing the BOM. analog_init must be called
      * before this function can be used.
      * (DEPRECATED) Turns off all bom leds.
+     *
      * @see bom_on, analog_init
      * @see bom_on
      **/
     void bom_off(void)
+    {
       output_low(is_bom_15?BOM_STROBE:MONKL);
         bom_leds_off(BOM_ALL);
+    }
     /** @} **/ //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);
           if (which&2)
             digital_output(MONK1, 1);
           else
             digital_output(MONK1, 0);
           if (which&1)
             digital_output(MONK0, 1);
           else
             digital_output(MONK0, 0);
+    }
     void output_high(int which) {
     	digital_output(which, 1);
+    }
     void output_low(int which) {
     	digital_output(which, 0);
+    }
+    }

      * @addtogroup bom
      * @{
      **/
     /** @brief Initializes a BOM v1.5 **/
     void bom_15_init(void);
     /** @brief Sets the mode of a BOM v1.5**/
     void bom_RSSI_mode(void);
     /** @brief Sets the mode of a BOM v1.5**/
     void bom_normal_mode(void);
     /** @brief Sets the emmitter pattern a BOM v1.5**/
     void bom_set_emitters(int pattern);
     /** @brief Returns the location of the maximum BOM reading. **/
     int get_max_bom( void );
     /** @brief Turns the BOM on. **/
     /** @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
     /** @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) Gets and compares all bom values.  Returns the index to the highest value element. **/
     int get_max_bom(void);
     /** @brief (DEPRECATED) Turns on all bom leds. **/
     void bom_on(void);
     /** @brief Turns the BOM off. **/
     /** @brief (DEPRECATED) Turns off all bom leds. **/
     void bom_off(void);
     /** @} **/

Also available in: Unified diff

Project

General

Profile

Colony

Revision 580