/ - Diff - Colony - Robotics Club

      * @{
      **/
     int adc_loop_running = 0;
     int adc_loop_status = ADC_LOOP_STOPPED;
     int adc_sig_stop_loop = 0;
     int adc_current_port = 0;
     adc_t an_val[11];
-...
     	set_adc_mux(0x00);
     	adc_current_port = AN1;
     	//Start the conversion if requested
     	//Start the conversion loop if requested
     	if (start_conversion)
     		analog_start_loop();
-...
      * Starts the analog update loop. Will continue to run
      * until analog_stop_loop is called.
+     *
      * @see analog_stop_loop, analog_loop_running
      * @see analog_stop_loop, analog_loop_status
      **/
     void analog_start_loop(void) {
     	//Start the conversion, enable ADC interrupt
     	ADCSRA |= _BV(ADSC) | _BV(ADIE);
     	adc_loop_running = 0x1;
     	adc_loop_status = ADC_LOOP_RUNNING;
+    }
     /**
-...
      * is interrupted. No further updates will be made until
      * the loop is started again.
+     *
      * @param Whether or not to block until current conversion
      * to complete. Use WAIT_UNTIL_FINISHED or
      * SKIP_WAIT.
+     *
      * @see analog_start_loop, analog_loop_running
      * @see analog_start_loop, analog_loop_status
      **/
     void analog_stop_loop(int skip_wait) {
     	//Stop the conversion
     	adc_loop_running = 0x0;
     	if(skip_wait) {
     		//Stop the interrupt
     		ADCSRA &= _BV(ADIE);
     		return;
+    	}
     	//Wait for the ADC interrupt flag to clear / conversion to complete
     	while(ADCSRA & _BV(ADIF));
     	//Stop the interrupt
     	ADCSRA &= _BV(ADIE);
     void analog_stop_loop() {
     	//Signal to stop after the next conversion
     	adc_sig_stop_loop = 1;
+    }
     /**
      * Returns the status of loop. 1 for running.
      * 0 for not running.
      * Returns the status of loop. 0 for stopped.
      * 1 for running. 2 for paused.
+     *
      * @see analog_start_loop, analog_stop_loop
+     *
      * @bug Doesn't actually tell you whether or
      * not the loop has fully stopped. adc_loop_running
      * is a signalling variable to tell the ISR to stop.
      * need to differentiate the signal from the status.
      **/
     int analog_loop_running(void) {
     	return adc_loop_running;
     int analog_loop_status(void) {
     	return adc_loop_status;
+    }
     /**
-...
     ISR(ADC_vect) {
     	static volatile int adc_prev_loop_running = 0;
     	int adc_h = 0;
     	int adc_l = 0;
-...
     		an_val[adc_current_port - 1].adc8 = adc_h;
+    	}
     	//Save the result only if we just turned off the loop
     	if (!adc_loop_running && !adc_prev_loop_running)
     		return;
     	adc_prev_loop_running = adc_loop_running;
     	//Skip AN7 because it is not a real port
     	if (adc_current_port == AN6) {
     		ADMUX = ADMUX_OPT | EXT_MUX;
-...
+    		}
+    	}
     	//Initiate next conversion only if we are running a loop
     	if (!adc_loop_running) {
     	//Stop loop if signal is set
     	if(adc_sig_stop_loop) {
     		//Disable the interrupt
     		ADCSRA &= _BV(ADIE);
     		adc_sig_stop_loop = 0;
     		adc_loop_status = ADC_LOOP_STOPPED;
     		return;
         } else {
         	ADCSRA |= _BV(ADSC);
+    	}
     	return;
     	//Start next conversion
     	ADCSRA |= _BV(ADSC);
+    }

     /** @brief Analog port for the battery voltage detector **/
     #define BATT_PORT  AN11
     /** @brief Wait for current conversion to complete. Parameter for analog_stop_loop **/
     #define WAIT_UNTIL_FINISHED 0
     /** @brief Don't wait for current conversion to complete. Parameter for analog_stop_loop **/
     #define SKIP_WAIT 1
     /** @brief Analog loop status. ADC conversion running. **/
     #define ADC_LOOP_RUNNING 1
     /** @brief Analog loop status.  No ADC conversion running.**/
     #define ADC_LOOP_STOPPED 0
     #define ADC_START 1
     #define ADC_STOP 0
     #define ADMUX_OPT 0x60
     /** @brief Struct to hold the value of a particular analog port **/
-...
     /** @brief Stops the analog loop. Doesn't do anything if the loop is already stopped. **/
     void analog_stop_loop(void);
     /** @brief Returns the status of the analog loop. **/
     int analog_loop_running(void);
     int analog_loop_status(void);
     /** @brief Returns an 8-bit analog value from the look up table. Use this instead of analog_get8. **/
     unsigned int analog8(int which);
     /** @brief Returns an 10-bit analog value from the look up table. Use this instead of analog_get10. **/

      **/
     void bom_refresh(int bit_field) {
         int i;
     	int loop_running;
     	int loop_was_running = 0;
     	//Check analog loop status
     	loop_running = analog_loop_running();
         if(loop_running)
         if(analog_loop_status() == ADC_LOOP_RUNNING) {
     		loop_was_running = 1;
     		analog_stop_loop();
+    	}
     	//Read BOM values
         for(i = 0; i < NUM_BOM_LEDS; i++) {
             if(bit_field & 0x1) {
                 bom_select(i);
-...
+        }
     	//Restore analog loop status
     	if(loop_running)
     	if(loop_was_running)
     		analog_start_loop();
+    }

Project

General

Profile

Colony

Revision 1387