/ - Diff - Colony - Robotics Club

Revision 275

Converted analog function to use interrupts and continuously poll. Need to test it.

Functions in the library that depend on analog will need to be updated to take
advantage of this when it works.

      * @{
      **/
     int adc_loop_running;
     int adc_current_port;
     /**
      * Initializes the ADC.
-...
      **/
     void analog_init(void)
+    {
     	// ADMUX register
     	// Bit 7,6 - Set voltage reference to AVcc (0b01)
     	// Bit 5 - ADLAR not set to simplify moving from register
     	// Bit 4 - X
     	// Bit 3:0 - Sets the current channel
     	// Initializes to read from AN1 first (AN0 is reservered for the BOM)
     	ADMUX = ~_BV(REFS1) | _BV(REFS0) | ~_BV(ADLAR) | _BV(MUX0);
     	// ADC Status Register A
     	// 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)
     	// 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/128
     	ADCSRA |= 0xEF;
     	// Bits 2-0 - Set to create a clock divisor of 128, to make ADC clock = 8,000,000/64 = 125kHz
     	ADCSRA = _BV(ADEN) | _BV(ADSC) | _BV(ADIE) | _BV(ADPS2) | _BV(ADPS1) | ~_BV(ADPS0);
     	// ADC Status Register B
     	// Bit 7, 5-3 - Must be cleared
     	// Bit 2:0 - Set mode, currently cleared for free running operation
     	// Bit 6 - Analog comparator mode - cleared
     //	ADCSRB = 0x00;
     	// ADMUX register
     	// Bit 7,6 - Set voltage reference to AVcc (0b01)
     	// Bit 5 - Set ADLAR bit for left adjust to do simple 8-bit reads
     	// Bit 4 - X
     	// Bit 3:0 - Sets the current channel, set to ADC7 (the external mux)
     	ADMUX = 0x67;
     	// Set external mux lines to outputs
     	DDRG |= 0x1C;
     	set_adc_mux(0x07);
     	set_adc_mux(0x07);
     	adc_loop_running = 1;
     	adc_current_port = AN1;
+    }
     unsigned int analog_get8(int which) {
     	return an_val[which - 1].adc8;
+    }
     unsigned int analog_get10(int which) {
     	return an_val[which - 1].adc10;
+    }
     /**
-...
      * @see analog_init, analog10
      **/
     unsigned int analog8(int which)
+    {
+    {
     	// Let any previous conversion finish
     	while (ADCSRA & _BV(ADSC));
     	if(which < EXT_MUX)
     		ADMUX = 0x60 + which;
     		ADMUX = 0x40 + which;
     	else if(which == EXT_MUX)
     		return 0;
     	else
+    	{
     		ADMUX = 0x60 + EXT_MUX;
     		ADMUX = 0x40 + EXT_MUX;
     		set_adc_mux(which - 8);
     		_delay_ms(1);
+    	}
     	_delay_ms(1); // need at least 130 us between conversions
     	return ADCH;
     	// Start the conversion
     	ADCSRA |= _BV(ADSC);
     	// Wait for the conversion to finish
     	while (ADCSRA & _BV(ADSC)) ;
     	return ADCL; //since we left aligned the data, ADCH is the 8 MSB.
+    }
     /**
-...
      **/
     unsigned int analog10(int which)
+    {
     	unsigned int adc_h = 0;
     	unsigned int adc_l = 0;
     	// Let any previous conversion finish
     	while (ADCSRA & _BV(ADSC));
     	if(which < EXT_MUX)
     		ADMUX = 0x60 + which;
     		ADMUX = 0x40 + which;
     	else if(which == EXT_MUX)
     		return 0;
     	else
+    	{
     		ADMUX = 0x60 + EXT_MUX;
     		ADMUX = 0x40 + EXT_MUX;
     		set_adc_mux(which - 8);
     		_delay_ms(1);
+    	}
     	// Start the conversion
     	ADCSRA |= _BV(ADSC);
     	_delay_ms(1);
     	adc_l = ADCL; /* highest 2 bits of ADCL -> least 2 bits of analog val */
     	adc_h = ADCH; /* ADCH -> 8 highest bits of analog val */
     	return (adc_h << 2) | (adc_l >> 6);
     	// Wait for the conversion to finish
     	while (ADCSRA & _BV(ADSC)) ;
     	return ((ADCH << 8) | ADCL);
+    }
     /**
-...
      **/
     int wheel(void)
+    {
     	return analog8(WHEEL_PORT);
     	return analog_get8(WHEEL_PORT);
+    }
     /**@}**/ //end defgroup
     SIGNAL (SIG_ADC)
+    {
     	// This is just here to catch ADC interrupts because ADC is free running.
     	// No code needs to be in here.
+    }
     void set_adc_mux(int which)
+    {
       // FIX THIS IN NEXT REVISION
-...
       // mask so only proper bits are possible.
       PORTG = (PORTG & 0xE3) | ((which & 0x03) << 3) | (which & 0x04);
+    }
     ISR(ANALOG_COMP_vect) {
     	//Only perform this if we are running the loop
     	if (!adc_loop_running)
     		return;
     	an_val[adc_current_port - 1].adc10 = (ADCH << 8) | ADCL;
     	//Increment current sensor, wrap around if needed
     	if (adc_current_port == AN10) {
     		adc_current_port = AN1;
     		ADMUX = 0x40 + adc_current_port;
     	} else {
     		adc_current_port++;
     		if(adc_current_port < EXT_MUX) {
     			ADMUX = 0x40 + adc_current_port;
     		} else {
     			ADMUX = 0x40 + EXT_MUX;
     			set_adc_mux(adc_current_port - 8);
+    		}
+    	}
     	ADCSRA |= _BV(ADSC);
+    }

     #ifndef _ANALOG_H
     #define _ANALOG_H
     #include <inttypes.h>
     /**
      * @addtogroup analog
      * @{
-...
     /** @brief Analog port for the battery voltage detector **/
     #define BATT_PORT  AN11
     typedef union adc_t{
     	uint8_t adc8;
     	uint16_t adc10;
     } adc_t;
     extern adc_t an_val[9];
     /** @brief Initialize analog ports. **/
     void analog_init(void);
     /** @brief Read an 8-bit number from an analog port. **/
-...
     unsigned int analog10(int which);
     /** @brief Read the position of the wheel. **/
     int wheel(void);
     unsigned int analog_get8(int which);
     unsigned int analog_get10(int which);
     /**@}**/ //end group
     #endif

Also available in: Unified diff

Project

General

Profile

Colony

Revision 275