/ - Diff - Colony - Robotics Club

      **/
     void dragonfly_init(int config)
+    {
     	sei();
     		sei();
     	// Set directionality of various IO pins
     	DDRG &= ~(_BV(PING0)|_BV(PING1));
-...
     	_delay_ms(1);
+    }
     /**
      * Malloc for colony. Disables analog loop and then restarts it
      * to avoid problems with malloc.
+     *
      * @param size the number of bytes to allocate
      * @return a pointer to size bytes of allocated memory
      **/
     inline void* colony_malloc(int size)
+    {
     	void* ret = NULL;
     	analog_stop_loop();
     	delay_ms(1000);
     	cli();
     	usb_puts("Calling malloc!\n");
     	ret = malloc(size);
     	usb_puts("Malloc returned!\n");
     	sei();
     	analog_start_loop();
     	return ret;
+    }
     /** @} **/ //end defgroup

     /** @brief Initialize the board **/
     void dragonfly_init(int config);
     /** @brief Special malloc to prevent errors from analog **/
     void* colony_malloc(int size);
     /** @} **/ //end addtogroup

      * @brief Analog input and output
+     *
      * Contains functions for manipulating the ADC on the Dragonfly board.
      * It operates by running throug all available analog ports (set by AN_MAX,
      * see analog.h for details on that constant). It performs a conversion for
      * each port and stores the 8bit and 10bit value. It then increments the
      * port that it is looking at and then procedes to do another read.
+     *
      * analog8 and analog10 are changed to use the lookup table. To use the
      * historic functions, use analog_get8 and analog_get10. If you do use those,
      * it is advised to turn off the loop by calling analog_stop_loop and restarting
      * the loop when done with analog_start_loop. This is especially important if you
      * are planning on doing a series of analog_getX reads.
+     *
      * This function pretty intensive on the interrupts as it will be called quite
      * often. Plan ahead for this.
+     *
      * @author Colony Project, CMU Robotics Club, Kevin Woo
      * Originally based on fwr code by Tom Lauwers
      * @author Colony Project, CMU Robotics Club
      * code mostly taken from fwr analog file (author: Tom Lauwers)
      **/
     #include <util/delay.h>
-...
     // Internal Function Prototypes
     void set_adc_mux(int which);
     /** @brief Struct to hold the value of a particular analog port */
     typedef struct {
     	uint8_t adc8;
     	uint16_t adc10;
     } adc_t;
     /**
      * @defgroup analog Analog
      * Functions for manipulation the ADC on the dragonfly board.
-...
     int adc_loop_running = 0;
     int adc_current_port = 0;
     adc_t an_val[11];
     adc_t an_val[10];
     /**
      * Initializes the ADC.
      * Call analog_init before reading from the analog ports.
+     *
      * @see analog8, analog10, analog_get8, analog_get10, analog_start_loop
      *      analog_stop_loop
      * @see analog8, analog10
      **/
     void analog_init(int start_conversion)
+    {
         //Initialize the array to 0
     	for (int i = 0; i < (AN_MAX + 1); i++) {
     	for (int i = 0; i < 10; i++) {
     		an_val[i].adc10 = 0;
     		an_val[i].adc8 = 0;
+    	}
     	//cli();
     	// ADMUX register
     	// The following bits are set
     	// Bit 7,6 - Set voltage reference to AVcc (0b01)
     	// Bit 5 - ADLAR set to simplify moving from register
     	// Bit 4 - X
-...
     	// ADC Status Register A
     	// The following bits are set
     	// Bit 7 - ADEN is set (enables analog)
     	// Bit 6 - Start conversion bit is set (must be done once for free-running mode)
     	// Bit 5 - Enable Auto Trigger (for free running mode) NOT DOING THIS RIGHT NOW
     	// Bit 4 - ADC interrupt flag, 0
     	// Bit 3 - Enable ADC Interrupt (required to run free-running mode)
     	// Bits 2-0 - Set to create a clock divisor of 128, to make ADC clock = 8,000,000/64 = 125kHz
     	ADCSRA = 0;
-...
     	set_adc_mux(0x00);
     	adc_current_port = AN1;
     	// Start the conversion if requested
     	//Start the conversion if requested
     	if (start_conversion)
     		analog_start_loop();
     	else
     		analog_stop_loop();
     	//sei();
+    }
     /**
      * Reads an analog value from the look-up table. Values are not
      * good unless the analog loop is running.
+     *
      * @param which is the analog port you wish to read.
+     *
      * @return returns an 8 bit value which represents the analog value
+     *
      * @see analog8, analog_start_loop, analog_stop_loop, analog_init
      **/
     unsigned int analog_get8(int which) {
     	if (which == BOM_PORT) {
     		return 0;
-...
+    	}
+    }
     /**
      * Reads an analog value from the look-up table. Values are not
      * good unless the analog loop is running.
+     *
      * @param which is the analog port you wish to read.
+     *
      * @return returns an 10 bit value which represents the analog value
+     *
      * @see analog8, analog_start_loop, analog_stop_loop, analog_init
      **/
     unsigned int analog_get10(int which) {
     	if (which == BOM_PORT) {
     		return 0;
-...
+    	}
+    }
     /**
      * Starts the analog loop to put values into the lookup table. Need
      * to have the loop running before analog_get8 and analog_get10 are
      * valid.
+     *
      * @see analog_stop_loop, analog_init, analog_get8, analog_get10
      **/
     void analog_start_loop(void) {
     	//Start the conversion
     	ADCSRA |= _BV(ADSC);
     	adc_loop_running = 0x1;
+    }
     /**
      * Starts the analog loop to put values into the lookup table. You
      * should disable to loop to use analog8 and analog10 reliably.
+     *
      * @see analog_stop_loop, analog_init, analog8, analog10
      **/
     //will stop after current conversion finishes
     void analog_stop_loop(void) {
     	//Stop the conversion
     	adc_loop_running = 0x0;
-...
      * analog_init must be called before using this function.
+     *
      * @param which the analog port to read from. One of
      * the constants AN0 - AN15.
      * the constants AN0 - AN7.
+     *
      * @return the eight bit input to the specified port
+     *
-...
+     *
+     *
      * @param which the analog port to read from. Typically
      * a constant, one of AN0 - AN15.
      * a constant, one of AN0 - AN7.
+     *
      * @return the ten bit number input to the specified port
+     *
-...
      **/
     int wheel(void)
+    {
     	return analog8(WHEEL_PORT);
     	return analog_get8(WHEEL_PORT);
+    }
-...
     ISR(ADC_vect) {
     	static volatile int adc_prev_loop_running = 0;
         // Need these local variables to read ADCH and ADCL in the correct order
     	int adc_h = 0;
     	int adc_l = 0;
     	//usb_putc('p');
     	//usb_puti(adc_current_port);
     	//usb_putc('r');
     	//usb_puti(adc_loop_running);
     	//usb_puts("\n\r");
     	//Store the value only if this read isn't for the BOM
     	if (ADMUX != BOM_PORT) {
     	    // Read ADCL before ADCH otherwise the registers change in the middle
     		adc_l = ADCL;
     		adc_h = ADCH;
     		an_val[adc_current_port - 1].adc10 = (adc_h << 2) | (adc_l >> 6);
     		an_val[adc_current_port - 1].adc8 = adc_h;
     		//usb_puti(an_val[adc_current_port - 1].adc10);
     		//usb_puts("\n\r");
     		//usb_puti(an_val[adc_current_port - 1].adc8);
     		//usb_puti(ADCH);
     		//usb_puts("\n\r");
+    	}
     	//Save the result only if we just turned off the loop
-...
     		return;
     	ADCSRA |= _BV(ADSC);
     	//if (ADCSRA & _BV(ADSC))
     	//	usb_putc('s');
     	return;
+    }

      * @brief Contains functions and definitions for using the ADC
+     *
      * Contains definitions and function prototypes for using the
      * ADC to detect analog signals on pins AN0 - AN15.
      * See analog.c for implementation details.
+     *
      * ADC to detect analog signals on pins AN0 - AN7.
      * AN6 and AN7 are used for the wheel and battery.
      * The pins labeled E6 and E7 are external interrupt pins and are not related
      * to analog.
      * @author Colony Project, CMU Robotics Club, based on firefly
      * code by Tom Lauwers
      **/
     */
     #ifndef _ANALOG_H
     #define _ANALOG_H
-...
     /** @brief Analog port for the battery voltage detector **/
     #define BATT_PORT  AN11
     /** @brief Used in analog_init to start the analog loop from the get-go **/
     #define ADC_START 1
     /** @brief Used in analog_init to not start the analog loop from the get-go **/
     #define ADC_STOP 0
     /** @brief Maximum number of analog ports to check. This number is equivalent to
       *     AN1 -> AN11 as AN0 and AN7 are skipped. **/
     #define ANMAX 11
     /** @brief For use with ADMUX register. Means that We will use AVCC (REFS0) and
      *      enable ADLAR. **/
     #define ADMUX_OPT 0x60
     /** @brief Struct to hold the value of a particular analog port */
     typedef struct {
     	uint8_t adc8;
     	uint16_t adc10;
     } adc_t;
     /** @brief Initialize analog ports. Will start running a loop
     	 if start_conversion is ADC_START.**/
     void analog_init(int start_conversion);
-...
     void analog_start_loop(void);
     /** @brief Stops the analog loop. Doesn't do anything if the loop is already stopped. **/
     void analog_stop_loop(void);
     /** @brief Returns an 8-bit analog value from the look up table. Use this instead of analog8. **/
     /** @brief Read an 8-bit number from an analog port. Loop must be stopped for this to work. **/
     unsigned int analog8(int which);
     /** @brief Returns an 10-bit analog value from the look up table. Use this instead of analog10. **/
     /** @brief Read a 10-bit number from an analog port. Loop must be stopped for this to work. **/
     unsigned int analog10(int which);
     /** @brief Read the position of the wheel. **/
     int wheel(void);
     /** @brief Read an 8-bit number from an analog port. Loop must be stopped for this to work. **/
     /** @brief Returns an 8-bit analog value from the look up table. Use this instead of analog8. **/
     unsigned int analog_get8(int which);
     /** @brief Read a 10-bit number from an analog port. Loop must be stopped for this to work. **/
     /** @brief Returns an 10-bit analog value from the look up table. Use this instead of analog10. **/
     unsigned int analog_get10(int which);

+     *
      * @see analog_init
      **/
     int get_max_bom(void)
+    {
     int get_max_bom(void) {
     	int max_bom_temp = 0;
     	int a, i, j, h = 255;
     	int a, i, j, h;
         h = 255;
     	//Turn off the loop so that we can actually use analog8 correctly
     	analog_stop_loop();
     	//Iterate through through each LED
     	for (j = 0; j < 16; j++)
+    	{
     		i = lookup[j];
     		if (i&8)
     			output_high(MONK3);
     		else
     			output_low(MONK3);
     		if (i&4)
     			output_high(MONK2);
     		else
     			output_low(MONK2);
     		if (i&2)
     			output_high(MONK1);
     		else
     			output_low(MONK1);
     		if (i&1)
     			output_high(MONK0);
     		else
     			output_low(MONK0);
     		a = analog_get8(MONKI);
     		if (a < h)
+    		{
     			h = a;
     			max_bom_temp = j;
+    		}
         for (j = 0; j < 16; j++)
+        {
           i = lookup[j];
+    	}
           if (i&8)
             output_high(MONK3);
           else
             output_low(MONK3);
           if (i&4)
             output_high(MONK2);
           else
             output_low(MONK2);
           if (i&2)
             output_high(MONK1);
           else
             output_low(MONK1);
           if (i&1)
             output_high(MONK0);
           else
             output_low(MONK0);
           a = analog8(MONKI);
           if (a < h)
+          {
             h = a;
             max_bom_temp = j;
+          }
+        }
     	//Restart loop now that we are done using analog8
     	analog_start_loop();

branches/analog/trunk/code/projects/libdragonfly/rangefinder.c
134	134	**/
135	135	int range_read_distance (int range_id)
136	136	{
137		return linearize_distance(analog8(range_id));
	137	return linearize_distance(analog_get8(range_id));
138	138	}
139	139
140	140	/ @} / //end defgroup

Project

General

Profile

Colony

Revision 328