/trunk/code/projects/libdragonfly/analog.c - Diff - Colony - Robotics Club

Revision 1924

Fixed line following readings, addded 1ms delay to fix the mux.

+     *
      **/
     void analog_init(int start_conversion) {
     	start_conversion=0;                   //forces the analog loop off
     	for (int i = 0; i < 11; i++) {
     		an_val[i].adc10 = 0;
     		an_val[i].adc8 = 0;
+    	}
         start_conversion=0;                   //forces the analog loop off
         for (int i = 0; i < 11; i++) {
             an_val[i].adc10 = 0;
             an_val[i].adc8 = 0;
+        }
     	// ADMUX register
     	// Bit 7,6 - Set voltage reference to AVcc (0b01)
     	// Bit 5 - ADLAR 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 = 0;
     	ADMUX |= ADMUX_OPT | _BV(MUX0);
         // ADMUX register
         // Bit 7,6 - Set voltage reference to AVcc (0b01)
         // Bit 5 - ADLAR 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 = 0;
         ADMUX |= ADMUX_OPT | _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) 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 2, to make ADC clock != 8,000,000/64 = 125kHz (it runs at highest frequency)
     	ADCSRA = 0;
     	ADCSRA |= _BV(ADEN) | /*_BV(ADPS2) | _BV(ADPS1) |*/ _BV(ADPS0);
     	// Set external mux lines to outputs
     	DDRG |= 0x1C;
         // 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) 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 2, to make ADC clock != 8,000,000/64 = 125kHz (it runs at highest frequency)
         ADCSRA = 0;
         ADCSRA |= _BV(ADEN) | /*_BV(ADPS2) | _BV(ADPS1) |*/ _BV(ADPS0);
     	// Set line sensor mux lines to output.  Uses LCD/SPI header
     	DDRD |=0xE0;
         // Set external mux lines to outputs
         DDRG |= 0x1C;
     	// Set up first port for conversions
     	set_adc_mux(0x00);
     	adc_current_port = AN1;
         // Set line sensor mux lines to output.  Uses LCD/SPI header
         DDRD |=0xE0;
     	//Start the conversion loop if requested
     	if (start_conversion)
     		analog_start_loop();
     	//Conversion loop disabled by default
         // Set up first port for conversions
         set_adc_mux(0x00);
         adc_current_port = AN1;
         //Start the conversion loop if requested
         if (start_conversion)
             analog_start_loop();
         //Conversion loop disabled by default
+    }
     /**
-...
      * @see analog10, analog_get8, analog_get10
      **/
     unsigned int analog8(int which) {
     /*	if (which == BOM_PORT) {
     		return 0;
     	} else {
     		return an_val[which - 1].adc8;
+    	}
     */
     return analog_get8(which);
         /*	if (which == BOM_PORT) {
             return 0;
             } else {
             return an_val[which - 1].adc8;
+            }
          */
         return analog_get8(which);
+    }
     /**
-...
      * @see analog8, analog_get8, analog_get10
      **/
     unsigned int analog10(int which) {
     /*	if (which == BOM_PORT) {
     		return 0;
     	} else {
     		return an_val[which - 1].adc10;
+    	}
     */
     return analog_get10(which);
         /*	if (which == BOM_PORT) {
             return 0;
             } else {
             return an_val[which - 1].adc10;
+            }
          */
         return analog_get10(which);
+    }
     /**
-...
      * @see analog_stop_loop, analog_loop_status
      **/
     void analog_start_loop(void) {
     	if(adc_loop_status != ADC_LOOP_RUNNING){
     		//Start the conversion, enable ADC interrupt
     		ADCSRA |= _BV(ADIE);
     		ADCSRA |= _BV(ADSC);
     		adc_loop_status = ADC_LOOP_RUNNING;
+    	}
         if(adc_loop_status != ADC_LOOP_RUNNING){
             //Start the conversion, enable ADC interrupt
             ADCSRA |= _BV(ADIE);
             ADCSRA |= _BV(ADSC);
             adc_loop_status = ADC_LOOP_RUNNING;
+        }
+    }
     /**
-...
      * @see analog_start_loop, analog_loop_status
      **/
     void analog_stop_loop() {
     	//Signal to stop after the next conversion
     	adc_sig_stop_loop = 1;
         //Signal to stop after the next conversion
         adc_sig_stop_loop = 1;
+    }
     /**
-...
      * @see analog_start_loop, analog_stop_loop
      **/
     int analog_loop_status(void) {
     	return adc_loop_status;
         return adc_loop_status;
+    }
     /**
-...
      * analog_start_loop
      **/
     unsigned int analog_get8(int which) {
     	// Let any previous conversion finish
     	while (ADCSRA & _BV(ADSC));
     	if(which < EXT_MUX) {
     		ADMUX = ADMUX_OPT + which;
     	} else {
     		ADMUX = ADMUX_OPT + EXT_MUX;
     		set_adc_mux(which - 8);
+    	}
     	// Start the conversion
     	ADCSRA |= _BV(ADSC);
         // Let any previous conversion finish
         while (ADCSRA & _BV(ADSC));
     	// Wait for the conversion to finish
     	while (ADCSRA & _BV(ADSC));
         if(which < EXT_MUX) {
             ADMUX = ADMUX_OPT + which;
         } else {
             ADMUX = ADMUX_OPT + EXT_MUX;
             set_adc_mux(which - 8);
+        }
     	return ADCH; //since we left aligned the data, ADCH is the 8 MSB.
         // Start the conversion
         ADCSRA |= _BV(ADSC);
         // Wait for the conversion to finish
         while (ADCSRA & _BV(ADSC));
         return ADCH; //since we left aligned the data, ADCH is the 8 MSB.
+    }
     /**
-...
      * analog_start_loop
      **/
     unsigned int analog_get10(int which) {
     	int adc_h;
     	int adc_l;
     	// Let any previous conversion finish
     	while (ADCSRA & _BV(ADSC));
         int adc_h;
         int adc_l;
     	if(which < EXT_MUX) {
     		ADMUX = ADMUX_OPT + which;
     	} else {
     		ADMUX = ADMUX_OPT + EXT_MUX;
     		set_adc_mux(which - 8);
+    	}
     	// Start the conversion
     	ADCSRA |= _BV(ADSC);
         // Let any previous conversion finish
         while (ADCSRA & _BV(ADSC));
     	// Wait for the conversion to finish
     	while (ADCSRA & _BV(ADSC));
     	adc_l = ADCL;
     	adc_h = ADCH;
         if(which < EXT_MUX) {
             ADMUX = ADMUX_OPT + which;
         } else {
             ADMUX = ADMUX_OPT + EXT_MUX;
             set_adc_mux(which - 8);
+        }
     	return ((adc_h << 2) | (adc_l >> 6));
         // Start the conversion
         ADCSRA |= _BV(ADSC);
         // Wait for the conversion to finish
         while (ADCSRA & _BV(ADSC));
         adc_l = ADCL;
         adc_h = ADCH;
         return ((adc_h << 2) | (adc_l >> 6));
+    }
     /** Returns the 10 bit value from the line sensors **/
     unsigned int read_line(int which) {
     	int adc_h;
     	int adc_l;
     	// Let any previous conversion finish
     	while (ADCSRA & _BV(ADSC));
         int adc_h;
         int adc_l;
     	ADMUX = ADMUX_OPT + AN1;
         // Let any previous conversion finish
         while (ADCSRA & _BV(ADSC));
     //	which = (which&1)<<2 + (which&2) + (which&4)>>2;
             // mask so only proper bits are possible.
             PORTD = (PORTD & 0x1F) | ((which & 0x07) << 5);
     	// Start the conversion
     	ADCSRA |= _BV(ADSC);
         ADMUX = ADMUX_OPT + AN1;
     	// Wait for the conversion to finish
     	while (ADCSRA & _BV(ADSC));
     	adc_l = ADCL;
     	adc_h = ADCH;
          which = ((which&1)<<2) + ((which&2)) + ((which&4)>>2);
     	return ((adc_h << 2) | (adc_l >> 6));
         // mask so only proper bits are possible.
         PORTD = (PORTD & 0x1F) | ((which & 0x07) << 5);
         delay_ms(1);
         // Start the conversion
         ADCSRA |= _BV(ADSC);
         // Wait for the conversion to finish
         while (ADCSRA & _BV(ADSC));
         adc_l = ADCL;
         adc_h = ADCH;
         return ((adc_h << 2) | (adc_l >> 6));
+    }
-...
      * @see analog_init
      **/
     int wheel(void) {
     	return analog8(WHEEL_PORT);
         return analog8(WHEEL_PORT);
+    }
-...
      * @see analog_init
      **/
     void set_adc_mux(int which) {
       // mask so only proper bits are possible.
       PORTG = (PORTG & 0xE3) | ((which & 0x03) << 3) | (which & 0x04);
         // mask so only proper bits are possible.
         PORTG = (PORTG & 0xE3) | ((which & 0x03) << 3) | (which & 0x04);
+    }
     /**@}**/ //end defgroup
     ISR(ADC_vect) {
     	int adc_h = 0;
     	int adc_l = 0;
     	if(adc_loop_status != ADC_LOOP_RUNNING) return;
         int adc_h = 0;
         int adc_l = 0;
     	//Store the value only if this read isn't for the BOM
     	if (ADMUX != BOM_PORT) {
     		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;
+    	}
     	//Skip AN7 because it is not a real port
     	if (adc_current_port == AN6) {
     		ADMUX = ADMUX_OPT | EXT_MUX;
     		set_adc_mux(AN8 - 8);
     		adc_current_port = AN8;
     	//Wrap around
     	} else if (adc_current_port == AN11) {
     		adc_current_port = AN1;
     		ADMUX = ADMUX_OPT | adc_current_port;
     	//Normal increment
     	} else {
     		adc_current_port++;
     		if(adc_current_port < EXT_MUX) {
     			ADMUX = ADMUX_OPT | adc_current_port;
     		} else {
     			ADMUX = ADMUX_OPT | EXT_MUX;
     			set_adc_mux(adc_current_port - 8);
+    		}
+    	}
         if(adc_loop_status != ADC_LOOP_RUNNING) return;
     	//Stop loop if signal is set
     	if(adc_sig_stop_loop) {
     		adc_sig_stop_loop = 0;
     		adc_loop_status = ADC_LOOP_STOPPED;
     		return;
+    	}
     	//Start next conversion
     	ADCSRA |= _BV(ADSC);
         //Store the value only if this read isn't for the BOM
         if (ADMUX != BOM_PORT) {
             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;
+        }
         //Skip AN7 because it is not a real port
         if (adc_current_port == AN6) {
             ADMUX = ADMUX_OPT | EXT_MUX;
             set_adc_mux(AN8 - 8);
             adc_current_port = AN8;
             //Wrap around
         } else if (adc_current_port == AN11) {
             adc_current_port = AN1;
             ADMUX = ADMUX_OPT | adc_current_port;
             //Normal increment
         } else {
             adc_current_port++;
             if(adc_current_port < EXT_MUX) {
                 ADMUX = ADMUX_OPT | adc_current_port;
             } else {
                 ADMUX = ADMUX_OPT | EXT_MUX;
                 set_adc_mux(adc_current_port - 8);
+            }
+        }
         //Stop loop if signal is set
         if(adc_sig_stop_loop) {
             adc_sig_stop_loop = 0;
             adc_loop_status = ADC_LOOP_STOPPED;
             return;
+        }
         //Start next conversion
         ADCSRA |= _BV(ADSC);
+    }

Also available in: Unified diff

Project

General

Profile

Colony

Revision 1924