Colony

/**

 * Copyright (c) 2007 Colony Project

 * 

 * Permission is hereby granted, free of charge, to any person

 * obtaining a copy of this software and associated documentation

 * files (the "Software"), to deal in the Software without

 * restriction, including without limitation the rights to use,

 * copy, modify, merge, publish, distribute, sublicense, and/or sell

 * copies of the Software, and to permit persons to whom the

 * Software is furnished to do so, subject to the following

 * conditions:

 * 

 * The above copyright notice and this permission notice shall be

 * included in all copies or substantial portions of the Software.

 * 

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES

 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT

 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,

 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR

 * OTHER DEALINGS IN THE SOFTWARE.

 **/

/**

 * @file bom.c

 * @brief Implementation for using the BOM

 *

 * Contains functions for using the Bearing and Orientation Module (BOM)

 *

 * @author Colony Project, CMU Robotics Club

 **/

#include <dragonfly_lib.h>

#include "bom.h"

#include "dio.h"

#include "analog.h"

//constants

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);

/*

 Bk R Y (Analog)

---------

 Green

 Blue

 White

---------

 Blue

 White

*/

/*

the analog pin definitions from dio.h DO NOT work here,

so we must use PF0 from avrgcc (as opposed to _PIN_F0).

BUT the dio pin definitions from dio.h must be used (no PE...).

also, _PIN_E2 is initialized to high for some reason,

which turns the BOM on when the robot is turned on.

WORK-AROUND: call digital_output(_PIN_E2,0) at some point.

*/

#define MONKI PF0         //analog (yellow)

//------------------------//

#define MONKL _PIN_E2     //green

#define MONK1 _PIN_E3     //blue

#define MONK0 _PIN_E4     //white

//------------------------//

#define MONK3 _PIN_E6     //blue

#define MONK2 _PIN_E7     //white

#define BOM_VALUE_THRESHOLD 200

#define NUM_BOM_LEDS 16

/**

 * @defgroup bom BOM (Bearing and Orientation Module)

 * @brief Functions for dealing with the BOM.

 *

 * The Bearing and Orientation Module / Barrel of Monkeys / BOM

 * is a custom sensor designed and built by the Colony Project.

 * It consists of a ring of 16 IR emitters and 16 IR detectors.

 * The BOM is most often use to determine the direction of other

 * robots. This module contains functions for controlling the BOM.

 *

 * 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:

        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:

        //add bom 1.5 code here

        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;

    }

}

/**

 * (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

 * the direction of a robot flashing its BOM, of only one

 * robot is currently doing so. analog_init must be called

 * before this function can be used.

 *

 * @return the direction of the maximum BOM reading

 *

 * @see analog_init

 **/

int get_max_bom(void) {

    bom_refresh(BOM_ALL);

    return bom_get_max();

}

/**

 * (DEPRECATED) Turns on all bom leds.

 * 

 * @see bom_off

 **/

void bom_on(void)

{

  bom_leds_on(BOM_ALL);

}

/**

 * (DEPRECATED) Turns off all bom leds.

 * 

 * @see bom_on

 **/

void bom_off(void)

{

    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);

}

/**

 * Copyright (c) 2007 Colony Project

 * 

 * Permission is hereby granted, free of charge, to any person

 * obtaining a copy of this software and associated documentation

 * files (the "Software"), to deal in the Software without

 * restriction, including without limitation the rights to use,

 * copy, modify, merge, publish, distribute, sublicense, and/or sell

 * copies of the Software, and to permit persons to whom the

 * Software is furnished to do so, subject to the following

 * conditions:

 * 

 * The above copyright notice and this permission notice shall be

 * included in all copies or substantial portions of the Software.

 * 

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES

 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT

 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,

 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR

 * OTHER DEALINGS IN THE SOFTWARE.

 **/

/**

 * @file analog.c

 * @brief Analog input and output

 *

 * Contains functions for manipulating the ADC on the Dragonfly board.

 * 

 * @author Colony Project, CMU Robotics Club

 * code mostly taken from fwr analog file (author: Tom Lauwers)

 **/

#include <util/delay.h>

#include <avr/interrupt.h>

#include "analog.h"

#include "serial.h"

// Internal Function Prototypes

void set_adc_mux(int which);

/**

 * @defgroup analog Analog

 * Functions for manipulation the ADC on the dragonfly board.

 * All definitions may be found in analog.h.

 *

 * @{

 **/

int adc_loop_running = 0;

int adc_current_port = 0;

adc_t an_val[11];

/**

 * Initializes the ADC.

 * Call analog_init before reading from the analog ports.

 *

 * @see analog8, analog10, analog_get8, analog_get10

 **/

void analog_init(int start_conversion) {

	for (int i = 0; i < 11; i++) {

		an_val[i].adc10 = 0;

		an_val[i].adc8 = 0;

	}

	//cli();

	// 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 128, to make ADC clock = 8,000,000/64 = 125kHz

	ADCSRA = 0;

	ADCSRA |= _BV(ADEN) | _BV(ADIE) | _BV(ADPS2) | _BV(ADPS1) | _BV(ADPS0);

	// Set external mux lines to outputs

	DDRG |= 0x1C;

	// Set up first port for conversions

	set_adc_mux(0x00);

	adc_current_port = AN1;

	//Start the conversion if requested

	if (start_conversion)

		analog_start_loop();

	else

		analog_stop_loop();

	//sei();

}	

unsigned int analog8(int which) {

	if (which == BOM_PORT) {

		return 0;

	} else {

		return an_val[which - 1].adc8;

	}

}

/**

 * Returns the 10-bit analog conversion of which from

 * the lookup table. If the requested port is the BOM_PORT

 * you will get an automatic 0 since the BOM_PORT is not

 * read in the loop and not stored. If you need that port

 * you should use the functions in bom.c. There is an analog_get10

 * function which for instant lookups but should be avoided.

 *

 * @param which the port that you want to read

 *

 * @bug may cause a seg fault if which is a larger value

 * than exists in an_val table. Not sure if we should fix

 * this or not since it would add overhead.

 *

 * @return 10-bit analog value for the which port requested

 *

 * @see analog8, analog_get8, analog_get10

 **/

unsigned int analog10(int which) {

	if (which == BOM_PORT) {

		return 0;

	} else {

		return an_val[which - 1].adc10;

	}

}

/**

 * Starts the analog update loop. Will continue to run

 * until analog_stop_loop is called.

 *

 * @see analog_stop_loop

 **/

void analog_start_loop(void) {

	//Start the conversion

	ADCSRA |= _BV(ADSC);

	adc_loop_running = 0x1;

}

/**

 * Stops the analog update loop. If there is a current

 * read, it will finish up and be stored before the loop

 * is interrupted. No further updates will be made until

 * the loop is started again.

 *

 * @see analog_start_loop

 **/

void analog_stop_loop(void) {

	//Stop the conversion

	adc_loop_running = 0x0;

}

/**

 * Reads an eight bit number from an analog port.

 * analog_init must be called before using this function.

 * 

 * @param which the analog port to read from. One of

 * the constants AN0 - AN7.

 *

 * @return the eight bit input to the specified port

 *

 * @see analog_init, analog10

 **/

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);

	// Wait for the conversion to finish

	while (ADCSRA & _BV(ADSC));

	return ADCH; //since we left aligned the data, ADCH is the 8 MSB.

}

/**

 * Reads a ten bit number from the specified port.

 * analog_init must be called before using this function.

 * 

 *

 * @param which the analog port to read from. Typically

 * a constant, one of AN0 - AN7.

 *

 * @return the ten bit number input to the specified port

 * 

 * @see analog_init, analog8

 **/

unsigned int analog_get10(int which) {

	int adc_h;

	int adc_l;

	// 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);

	// 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 current position of the wheel, as an integer

 * in the range 0 - 255.

 * analog_init must be called before using this function.

 *

 * @return the orientation of the wheel, as an integer in

 * the range 0 - 255.

 *

 * @see analog_init

 **/

int wheel(void) {

	return analog8(WHEEL_PORT);

}

/**

 * Sets the value of the external analog mux. Values are read

 * 	on AN7 physical port. (AN8 - AN15 are "virtual" ports).

 *

 * @param which which analog mux port (0-7) which corresponds

 * 		  to AN8-AN15.

 *

 * @bug FIX THIS IN THE NEXT BOARD REVISION:

 *		ADDR2 ADDR1 ADDR0

 *		G2.G4.G3 set mux to port 0-7 via vinary selection

 *		math would be much cleaner if it was G4.G3.G2

 *

 * @see analog_init

 **/

void set_adc_mux(int which) {  

  // mask so only proper bits are possible.  

  PORTG = (PORTG & 0xE3) | ((which & 0x03) << 3) | (which & 0x04);

}

/**@}**/ //end defgroup

ISR(ADC_vect) {

	static volatile int adc_prev_loop_running = 0; 

	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;

	}

	//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;

		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);

		}

	}

	//Initiate next conversion only if we are running a loop

	if (!adc_loop_running) {

		return;

    } else {

    	ADCSRA |= _BV(ADSC);

	}

	return;

}

/**

 * Copyright (c) 2007 Colony Project

 * 

 * Permission is hereby granted, free of charge, to any person

 * obtaining a copy of this software and associated documentation

 * files (the "Software"), to deal in the Software without

 * restriction, including without limitation the rights to use,

 * copy, modify, merge, publish, distribute, sublicense, and/or sell

 * copies of the Software, and to permit persons to whom the

 * Software is furnished to do so, subject to the following

 * conditions:

 * 

 * The above copyright notice and this permission notice shall be

 * included in all copies or substantial portions of the Software.

 * 

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES

 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT

 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,

 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR

 * OTHER DEALINGS IN THE SOFTWARE.

 **/

/**

 * @file time.c

 * @brief Timer code

 *

 * Implementation of functions for timers.

 *

 * @author Colony Project, CMU Robotics Club

 **/

/*

  time.c

  anything that requires a delay

  mostly delay_ms

  author: Robotics Club, Colony Project

  Change Log:

  2.5.07 - Kevin

  Aaron fixed the orb/servo code and made them use timer3 but compare registers B and C. He hard set the prescaler

  to 8 so the RTC broke. Changed it so that we use a 8 prescaler which sets the compare match at 1/16th of a second.

  You now count how many 16ths of a second you want until you trigger your actual interrupt. Works. Changed defines

  for time so you can still call rtc_init with a scale but now it is defined in terms of actual time like second, quarter_second

  etc. Read that section in the time.h file for more information. Tested and works, though the clock drifts more than

  it used to

  1.30.07 - Kevin

  Modified the clock to run on timer3 on the Dragonfly. Works with decent accuracy. Using a prescaler of 256

  the timer counts up to a precomputer value which will trigger an interrupt and reset the timer. Multiples of

  256 change it by that multiple. Refer to the time.h file for all possible prescalers.

  The interrupt will call a specified function _rtc_func every pulse.

  All of it has been tested and it works.

*/

#include <avr/interrupt.h>

#include <util/delay.h>

#include <time.h>

#include <serial.h>

static volatile int _rtc_val = 0;

static volatile int _rtc_pulse = 0;

static volatile int _rtc_scale = 32;	//Defaults to 1 Second per pulse

static void (*_rtc_f)(void) = 0;

/**

 * @defgroup time Time

 * @brief Time functions

 * 

 * Functions dealing with time.

 * 

 * @{

 **/

/**

 * Delays for the specified number of milliseconds.

 * The accuracy of this function is unknown.

 *

 * @param ms the number of milliseconds to delay for

 **/

void delay_ms(int ms) {

  for(; ms > 15; ms-=15)

    _delay_ms(15);

  _delay_ms(ms);

}

/* 	Prescales defined in time.h. SECOND will give you 1 second.

	More scales are defined in the time.h file.

	rtc_func is the address to a function that you want called every clock tick. */

/**

 * Initializes the real time clock. Prescales are defined in time.h.

 * For example, SECOND will give 1 second. The specified function is

 * called every clock tick. For the real time clock to activate,

 * interrupts must be enabled. (through sei() )

 *

 * @param prescale_opt the period with which the timer is triggered

 * @param rtc_func the function called when the timer is triggered

 *

 * @see rtc_get, rtc_reset

 *

 **/

void rtc_init(int prescale_opt, void (*rtc_func)(void)) {

  //Clear timer register for Timer 3

  TCNT3 = 0;

  /* 	This sets the Waveform Generation Module to CTC (Clear Timer on Compare) Mode (100)

	See page135 in Atmega128 Docs for more modes and explanations */

  TCCR3B |= _BV(WGM32);

  /* 	This sets the prescaler for the system clock (8MHz) ie: divides the clock by some number.

	Currently set to a prescaler of 8 because that is what the orb and servos use (they are on this timer as well)

	See page137 in Atemga128 Docs for all the available prescalers */

  TCCR3B |= _BV(CS31);

  /* 	Sets the two regsiters that we compare against. So the timer counts up to this number and

	then resets back to 0 and calls the compare match interrupt.

	8x10^6 / 8 = 1/16 Second. All values are based off of this number. Do not change it unless you

	are l337*/

  OCR3A = 0xF424;	

  /* 	Enable Output Compare A Interrupt. When OCR3A is met by the timer TCNT3 this interrupt will be

	triggerd. (See page140 in Atmega128 Docs for more information */

  ETIMSK |= _BV(OCIE3A);

  /*	Store the pointer to the function to be used in the interrupt */

  _rtc_f = rtc_func;

  /*	Store how many 1/16ths of a second you want to let by before triggering an interrupt */

  _rtc_scale = prescale_opt;

}

/**

 * Returns the time elapsed in seconds since the last call to

 * rtc_init or rtc_reset.

 *

 * @return the number of seconds since the last call to rtc_init or rtc_reset

 *

 * @see rtc_init, rtc_reset

 **/

int rtc_get(void) {

  return _rtc_val;

}

/**

 * Resets the real time clock counter to 0.

 *

 * @see rtc_init, rtc_get

 **/

void rtc_reset(void) {

  _rtc_val = 0;

}

/** @} **/ //end defgroup

/*	Called every pulse. Function in _rtc_f is called every _rtc_scale and also the counter is updated.

	Bascially, since the pulse is hard set at 1/16s  you want to count how many 16ths of a second have passed

	and when it reaches the amount of time you want, execute the code. */

SIGNAL(TIMER3_COMPA_vect) {

  if (_rtc_pulse ==  _rtc_scale) {

    //Increment the real time clock counter

    _rtc_val++;

    //Calls the function tied to the real time clock if defined

    if(_rtc_f != 0)

      _rtc_f();

    //Resets the pulse until the next scale is matched

    _rtc_pulse = 0;

  }	

  //Updates the amount of pulses seen since the last scale match

  _rtc_pulse++;

}

/**

 * Copyright (c) 2007 Colony Project

 * 

 * Permission is hereby granted, free of charge, to any person

 * obtaining a copy of this software and associated documentation

 * files (the "Software"), to deal in the Software without

 * restriction, including without limitation the rights to use,

 * copy, modify, merge, publish, distribute, sublicense, and/or sell

 * copies of the Software, and to permit persons to whom the

 * Software is furnished to do so, subject to the following

 * conditions:

 * 

 * The above copyright notice and this permission notice shall be

 * included in all copies or substantial portions of the Software.

 * 

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES

 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT

 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,

 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR

 * OTHER DEALINGS IN THE SOFTWARE.

 **/

/**

 * @file motor.c

 * @brief Motors

 *

 * Implementation of functions for controlling the motors.

 *

 * @author Colony Project, CMU Robotics Club

 * Much of this is taken from FWR's library, author: Tom Lauwers

 **/

#include "motor.h"

/**

 * @defgroup motors Motors

 * @brief Functions for controlling the motors.

 * Functions for controlling the motors. Found in motor.h.

 * @{

 **/

/**

 * Initializes both motors so that they can be used with future

 * calls to motor1_set and motor2_set.

 *

 * @see motors_off, motor1_set, motor2_set

 **/

void motors_init( void ) {

  // Configure counter such that we use phase correct

  // PWM with 8-bit resolution

  PORTA &= 0x0F;

  DDRA |= 0xF0;

  DDRB |= 0x60;

  //timer 1A and 1B

  TCCR1A = _BV(COM1A1) | _BV(COM1B1) | _BV(WGM10);

  TCCR1B = _BV(WGM12) | _BV(CS10);

  //	TCCR1A = 0xA1;

  //	TCCR1B = 0x04;

  OCR1AH=0;

  OCR1AL=0;

  OCR1BH=0;

  OCR1BL=0;

}

/**

 * Sets the speed and direction of motor1.

 * motors_init must be called before this function can be used.

 *

 * @param direction Either FORWARD or BACKWARD to set the direction of rotation.

 * @param speed The speed the motor will run at, in the range 0-255.

 * 

 * @see motor2_set, motors_init

 **/

void motor1_set(int direction, int speed) {

  if(direction == 0) {

    // turn off PWM first if switching directions

    if((PORTA & 0x30) != 0x10) {

      OCR1A = 0;

    }	

    PORTA = (PORTA & 0xCF) | 0x10;

    //		PORTD |= 0x10;

    //		PORTD &= 0xBF;

  } else {

    // turn off PWM first if switching directions

    if((PORTA & 0x30) != 0x20) {

      OCR1A = 0;

    }

    PORTA = (PORTA & 0xCF) | 0x20;

    //		PORTD |= 0x40;

    //		PORTD &= 0xEF;

  }

  // Set the timer to count up to speed, an 8-bit value

  OCR1AL = speed;

}

/**

 * Sets the speed and direction of motor2.

 * motors_init must be called before this function can be used.

 *

 * @param direction Either FORWARD or BACKWARD to set the direction of rotation.

 * @param speed The speed the motor will run at, in the range 0-255.

 *

 * @see motor1_set, motors_init

 **/

void motor2_set(int direction, int speed) {

  if(direction == 0) {

    //		PORTD |= 0x20;

    //		PORTD &= 0x7F;

    // turn off PWM first if switching directions

    if((PORTA & 0xC0) != 0x80) {

      OCR1B = 0;

    }		

    PORTA = (PORTA & 0x3F) | 0x80;

  } else {

    //		PORTD |= 0x80;

    //		PORTD &= 0xDF;

    // turn off PWM first if switching directions

    if((PORTA & 0xC0) != 0x40) {

      OCR1B = 0;

    }		

    PORTA = (PORTA & 0x3F) | 0x40;

  }

  OCR1BL = speed;

}

/**

 * Turns off both motors.

 *

 * @see motors_init

 **/

void motors_off( void ) {

  OCR1AL = 0x0;

  OCR1BL = 0x0;

}

/**@}**///end defgroup

/**

 * Copyright (c) 2007 Colony Project

 * 

 * Permission is hereby granted, free of charge, to any person

 * obtaining a copy of this software and associated documentation

 * files (the "Software"), to deal in the Software without

 * restriction, including without limitation the rights to use,

 * copy, modify, merge, publish, distribute, sublicense, and/or sell

 * copies of the Software, and to permit persons to whom the

 * Software is furnished to do so, subject to the following

 * conditions:

 * 

 * The above copyright notice and this permission notice shall be

 * included in all copies or substantial portions of the Software.

 * 

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES

 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT

 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,

 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR

 * OTHER DEALINGS IN THE SOFTWARE.

 **/

/**

 * @file lcd.c

 * @brief LCD

 *

 * Implementation of functions for using the LCD.

 *

 * @author Colony Project, CMU Robotics Club

 **/

#include <avr/io.h>

#include <lcd.h>

#include <time.h>

//LCD defines

#define RST _BV(4)  // pd4 (GPIO)

#define SCE _BV(0)  // pb0 (~SS)

#define D_C _BV(5)  // pd5 (GPIO?)

#define SDI _BV(2)  // pb2 (MOSI)

#define SCK _BV(1) // pb1 (SCK)

#define LCDPORT PORTB

#define LCDDDR DDRB

#define LCDRESETPORT PORTD

#define LCDRESETDDR DDRD

void lcd_putbyte(unsigned char b);

//**************************************Old shit below!*****************

/*

  FontLookup - a lookup table for all characters

*/

static const unsigned char FontLookup [][5] =

  {

    { 0x00, 0x00, 0x00, 0x00, 0x00 },  // sp

    { 0x00, 0x00, 0x5f, 0x00, 0x00 },   // !

    { 0x00, 0x07, 0x00, 0x07, 0x00 },   // "

    { 0x14, 0x7f, 0x14, 0x7f, 0x14 },   // #

    { 0x24, 0x2a, 0x7f, 0x2a, 0x12 },   // $

    { 0x23, 0x13, 0x08, 0x64, 0x62 },   // %

    { 0x36, 0x49, 0x55, 0x22, 0x50 },   // &

    { 0x00, 0x05, 0x03, 0x00, 0x00 },   // '

    { 0x00, 0x1c, 0x22, 0x41, 0x00 },   // (

    { 0x00, 0x41, 0x22, 0x1c, 0x00 },   // )

    { 0x14, 0x08, 0x3E, 0x08, 0x14 },   // *

    { 0x08, 0x08, 0x3E, 0x08, 0x08 },   // +

    { 0x00, 0x00, 0x50, 0x30, 0x00 },   // ,

    { 0x10, 0x10, 0x10, 0x10, 0x10 },   // -

    { 0x00, 0x60, 0x60, 0x00, 0x00 },   // .

    { 0x20, 0x10, 0x08, 0x04, 0x02 },   // /

    { 0x3E, 0x51, 0x49, 0x45, 0x3E },   // 0

    { 0x00, 0x42, 0x7F, 0x40, 0x00 },   // 1

    { 0x42, 0x61, 0x51, 0x49, 0x46 },   // 2

    { 0x21, 0x41, 0x45, 0x4B, 0x31 },   // 3

    { 0x18, 0x14, 0x12, 0x7F, 0x10 },   // 4

    { 0x27, 0x45, 0x45, 0x45, 0x39 },   // 5

    { 0x3C, 0x4A, 0x49, 0x49, 0x30 },   // 6

    { 0x01, 0x71, 0x09, 0x05, 0x03 },   // 7

    { 0x36, 0x49, 0x49, 0x49, 0x36 },   // 8

    { 0x06, 0x49, 0x49, 0x29, 0x1E },   // 9

    { 0x00, 0x36, 0x36, 0x00, 0x00 },   // :

    { 0x00, 0x56, 0x36, 0x00, 0x00 },   // ;

    { 0x08, 0x14, 0x22, 0x41, 0x00 },   // <

    { 0x14, 0x14, 0x14, 0x14, 0x14 },   // =

    { 0x00, 0x41, 0x22, 0x14, 0x08 },   // >

    { 0x02, 0x01, 0x51, 0x09, 0x06 },   // ?

    { 0x32, 0x49, 0x59, 0x51, 0x3E },   // @

    { 0x7E, 0x11, 0x11, 0x11, 0x7E },   // A

    { 0x7F, 0x49, 0x49, 0x49, 0x36 },   // B

    { 0x3E, 0x41, 0x41, 0x41, 0x22 },   // C

    { 0x7F, 0x41, 0x41, 0x22, 0x1C },   // D

    { 0x7F, 0x49, 0x49, 0x49, 0x41 },   // E

    { 0x7F, 0x09, 0x09, 0x09, 0x01 },   // F

    { 0x3E, 0x41, 0x49, 0x49, 0x7A },   // G

    { 0x7F, 0x08, 0x08, 0x08, 0x7F },   // H

    { 0x00, 0x41, 0x7F, 0x41, 0x00 },   // I

    { 0x20, 0x40, 0x41, 0x3F, 0x01 },   // J

    { 0x7F, 0x08, 0x14, 0x22, 0x41 },   // K

    { 0x7F, 0x40, 0x40, 0x40, 0x40 },   // L

    { 0x7F, 0x02, 0x0C, 0x02, 0x7F },   // M

    { 0x7F, 0x04, 0x08, 0x10, 0x7F },   // N

    { 0x3E, 0x41, 0x41, 0x41, 0x3E },   // O

    { 0x7F, 0x09, 0x09, 0x09, 0x06 },   // P

    { 0x3E, 0x41, 0x51, 0x21, 0x5E },   // Q

    { 0x7F, 0x09, 0x19, 0x29, 0x46 },   // R

    { 0x46, 0x49, 0x49, 0x49, 0x31 },   // S

    { 0x01, 0x01, 0x7F, 0x01, 0x01 },   // T

    { 0x3F, 0x40, 0x40, 0x40, 0x3F },   // U

    { 0x1F, 0x20, 0x40, 0x20, 0x1F },   // V

    { 0x3F, 0x40, 0x38, 0x40, 0x3F },   // W

    { 0x63, 0x14, 0x08, 0x14, 0x63 },   // X

    { 0x07, 0x08, 0x70, 0x08, 0x07 },   // Y

    { 0x61, 0x51, 0x49, 0x45, 0x43 },   // Z

    { 0x00, 0x7F, 0x41, 0x41, 0x00 },   // [

    { 0x02, 0x04, 0x08, 0x10, 0x20 },   // backslash

    { 0x00, 0x41, 0x41, 0x7F, 0x00 },   // ]

    { 0x04, 0x02, 0x01, 0x02, 0x04 },   // ^

    { 0x40, 0x40, 0x40, 0x40, 0x40 },   // _

    { 0x00, 0x01, 0x02, 0x04, 0x00 },   // '

    { 0x20, 0x54, 0x54, 0x54, 0x78 },   // a

    { 0x7F, 0x48, 0x44, 0x44, 0x38 },   // b

    { 0x38, 0x44, 0x44, 0x44, 0x20 },   // c

    { 0x38, 0x44, 0x44, 0x48, 0x7F },   // d

    { 0x38, 0x54, 0x54, 0x54, 0x18 },   // e

    { 0x08, 0x7E, 0x09, 0x01, 0x02 },   // f

    { 0x0C, 0x52, 0x52, 0x52, 0x3E },   // g

    { 0x7F, 0x08, 0x04, 0x04, 0x78 },   // h

    { 0x00, 0x44, 0x7D, 0x40, 0x00 },   // i

    { 0x20, 0x40, 0x44, 0x3D, 0x00 },   // j

    { 0x7F, 0x10, 0x28, 0x44, 0x00 },   // k

    { 0x00, 0x41, 0x7F, 0x40, 0x00 },   // l

    { 0x7C, 0x04, 0x18, 0x04, 0x78 },   // m

    { 0x7C, 0x08, 0x04, 0x04, 0x78 },   // n

    { 0x38, 0x44, 0x44, 0x44, 0x38 },   // o

    { 0x7C, 0x14, 0x14, 0x14, 0x08 },   // p

    { 0x08, 0x14, 0x14, 0x18, 0x7C },   // q

    { 0x7C, 0x08, 0x04, 0x04, 0x08 },   // r

    { 0x48, 0x54, 0x54, 0x54, 0x20 },   // s

    { 0x04, 0x3F, 0x44, 0x40, 0x20 },   // t

    { 0x3C, 0x40, 0x40, 0x20, 0x7C },   // u

    { 0x1C, 0x20, 0x40, 0x20, 0x1C },   // v

    { 0x3C, 0x40, 0x30, 0x40, 0x3C },   // w

    { 0x44, 0x28, 0x10, 0x28, 0x44 },   // x

    { 0x0C, 0x50, 0x50, 0x50, 0x3C },   // y

    { 0x44, 0x64, 0x54, 0x4C, 0x44 },    // z

    { 0x00, 0x08, 0x36, 0x41, 0x41 },   // {

    { 0x00, 0x00, 0x7F, 0x00, 0x00 },   // |

    { 0x41, 0x41, 0x36, 0x08, 0x00 },   // }

    { 0x02, 0x01, 0x01, 0x02, 0x01 },   // ~

    { 0x55, 0x2A, 0x55, 0x2A, 0x55 },   // del

  };

/**

 * @defgroup lcd LCD

 * @brief Functions for the LCD

 * Functions for writing to the LCD.

 * All functions may be found in lcd.h.

 *

 * @{

 **/

/**

 * Initializes the LCD. Must be called before any other

 * LCD functions.

 **/

void lcd_init(void) {

  LCDDDR |= (SCE | SDI | SCK);

  LCDRESETDDR |= (RST|D_C);

  LCDPORT &= ~( SCE | SDI | SCK);

  LCDRESETPORT &=~(D_C);

  SPCR |= 0x50;//0b01010000; // no SPI int, SPI en, Master, sample on rising edge, fosc/2

  SPSR |= 0x01;       // a continuation of the above

  LCDRESETPORT |= RST;

  delay_ms(10);

  LCDRESETPORT &= (~RST);

  delay_ms(100);

  LCDRESETPORT |= RST;

  lcd_putbyte( 0x21 );  // LCD Extended Commands.

  lcd_putbyte( 0xC8 );  // Set LCD Vop (Contrast).

  lcd_putbyte( 0x06 );  // Set Temp coefficent.

  lcd_putbyte( 0x13 );  // LCD bias mode 1:48.

  lcd_putbyte( 0x20 );  // LCD Standard Commands, Horizontal addressing mode.

  lcd_putbyte( 0x0C );  // LCD in normal mode.

  LCDRESETPORT |= D_C;		//put it in init instead of main

  lcd_clear_screen();

}

/**

 * Clears the LCD screen. lcd_init must be called first.

 * 

 * @see lcd_init

 **/

void lcd_clear_screen( void ) {

  int i;

  for (i = 0; i < 504; i++)

    lcd_putbyte(0x0);

  lcd_gotoxy(0,0);

}

/**

 * Prints a character on the LCD screen. lcd_init

 * must be called before this function may be used.

 *

 * @param c the character to print

 *

 * @see lcd_init

 **/

void lcd_putc(char c) {

  int i;

  for (i = 0; i < 5; i++)

    lcd_putbyte(FontLookup[c-32][i]);

  lcd_putbyte(0);

}

/*

  print an entire string to the lcd

*/

void lcd_puts(char *s) {

  char *t = s;

  while (*t != 0) {

    lcd_putc(*t);

    t++;

  }

}

/*

  go to coordinate x, y

  y: vertically - 1 char

  x: horizontally - 1 pixel

  multiply x by 6 if want to move 1 entire character

  origin (0,0) is at top left corner of lcd screen

*/

/**

 * Move the current cursor position to the one specified.

 * lcd_init must be called before this function may be used.

 * 

 * @param x The x coordinate of the new position

 * @param y The y coordinate of the new position

 *

 * @see lcd_init

 **/

void lcd_gotoxy(int x, int y) {

  LCDRESETPORT &= ~(D_C);

  lcd_putbyte(0x40 | (y & 0x07));

  lcd_putbyte(0x80 | (x & 0x7f));

  LCDRESETPORT |= D_C;

}

/*

  prints an int to the lcd

  code adapted from Chris Efstathiou's code (hendrix@otenet.gr)

*/

/**

 * Print an integer to the LCD screen.

 * lcd_init must be called before this function may be used.

 * 

 * @param value the integer to print

 *

 * @see lcd_init

 **/

void lcd_puti(int value ) {

  unsigned char lcd_data[6]={'0','0','0','0','0','0' }, position=sizeof(lcd_data), radix=10; 

  /* convert int to ascii  */ 

  if(value<0) { 

    lcd_putc('-'); 

    value=-value; 

  }    

  do { 

    position--; 

    *(lcd_data+position)=(value%radix)+'0'; 

    value/=radix;  

  } while(value); 

  /* start displaying the number */

  for(;position<=(sizeof(lcd_data)-1);position++)

    lcd_putc(lcd_data[position]);

  return;

}

/** @} **/ //end defgroup

void lcd_putbyte(unsigned char b) {

  SPDR = b;

  while (!(SPSR & 0x80)); /* Wait until SPI transaction is complete */

}

/**

 * Copyright (c) 2007 Colony Project

 * 

 * Permission is hereby granted, free of charge, to any person

 * obtaining a copy of this software and associated documentation

 * files (the "Software"), to deal in the Software without

 * restriction, including without limitation the rights to use,

 * copy, modify, merge, publish, distribute, sublicense, and/or sell

 * copies of the Software, and to permit persons to whom the

 * Software is furnished to do so, subject to the following

 * conditions:

 * 

 * The above copyright notice and this permission notice shall be

 * included in all copies or substantial portions of the Software.

 * 

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES

 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT

 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,

 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR

 * OTHER DEALINGS IN THE SOFTWARE.

 **/

/**

 * @file move.c

 * @brief Functions for moving

 *

 * Implementation of functions for moving the robot.

 *

 * @author Colony Project, CMU Robotics Club

 **/

#include "dragonfly_lib.h"

#include "move.h"

#include "rangefinder.h"

// Internal prototypes

void translateAngulartoLinear (int velocity, int omega, int* vl, int* vr);

// global varaibles for move_avoid

int d1, d2, d3, d4, d5; 

/**

 * @defgroup move Movement

 * @brief Functions fo controlling robot motion

 * Higher level functions to control the movement of robots.

 * 

 * @{

 **/

/**

 * Causes the robot to move with the given translation and rotational velocities.

 * motors_init must be called before this function can be used.

 *

 * @param velocity the translational velocity of the robot, in the range -255 to 255.

 * A positive value indicates forward motion, while a negative value indicates

 * backwards motion.

 * 

 * @param omega the rotational velocity of the robot, in the range -255 to 255.

 * A positive value indicates a counterclockwise velocity, while a negative

 * value indicates a clockwise velocity.

 *

 * @see motors_init, motor1_set, motor2_set

 **/

void move (int velocity, int omega) {

  int vl = 0;

  int vr = 0;

  translateAngulartoLinear(velocity, omega, &vl , &vr );

  //

  if (vl < 0) {

    motor1_set(BACKWARD, -vl);

  } else {

    motor1_set(FORWARD, vl);

  }

  if (vr < 0) {

    motor2_set(BACKWARD, -vr);

  } else {

    motor2_set(FORWARD, vr);

  }

}

/**

 * Moves the robot with the given translational and angular velocities

 * while avoiding obstacles. To be effective, this function must be

 * called repeatedly throughout the motion. It relies on the IR

 * rangefinders to detect obstacles. Before calling this function,

 * motors_init and range_init must be called.

 *

 * @param velocity the translational velocity of the robot, in the

 * range -255 to 255. A positive value indicates forward motion.

 *

 * @param omega the rotational velocity of the robot, in the range

 * -255 to 255. A positive value indicates a counterclockwise velocity.

 *

 * @param strength the strength of the avoid behavior, in the range

 * 0 to 100.

 *

 * @see motors_init, range_init, move

 **/

void move_avoid(int velocity, int omega, int strength) {

  int pControl;

  int vl = 0;

  int vr = 0;

  int temp;

  temp=range_read_distance(IR1);

  d1 = (temp == -1) ? d1 : temp;

  temp=range_read_distance(IR2);

  d2=(temp == -1) ? d2 : temp;

  temp=range_read_distance(IR3);

  d3=(temp == -1) ? d3 : temp;

  temp=range_read_distance(IR4);

  d4=(temp == -1) ? d4 : temp;

  temp=range_read_distance(IR5);

  d5=(temp == -1) ? d5 : temp;

  /* Avoid obstacles ahead

     if(d2>170)

     v*=-1;

     Naturally slow down if there is something in the way.

     if(d2>150 || d1>180 || d3>180){

     v>>=1;

  */

  //pControl= (((d3-d1) + (d4-d5))*strength)/100;

  pControl= (((d5-d4))*strength)/100;

  omega = (omega*(100-strength))/100 + pControl;

  translateAngulartoLinear(velocity, omega, &vl , &vr );

  if (vl < 0) {

    motor1_set(BACKWARD, -vl);

  } else {

    motor1_set(FORWARD, vl);

  }

  if (vr < 0) {

    motor2_set(BACKWARD, -vr);

  } else {

    motor2_set(FORWARD, vr);

  }

}

/**@}**///end the motion group

void translateAngulartoLinear (int velocity, int omega, int* vl, int* vr) {

  //omega: angle measure, positive couter-clockwise from front.

  // -180 <= omega <= 180

  //velocity: -255 <= velocity <= 255

  long int vltemp, vrtemp;

  //make sure values are in bounds

  if (velocity < -255 || velocity >255 || omega < -255 || omega > 255) return;

  //compute

  vrtemp = velocity + omega * 3;

  vltemp = velocity - omega * 3;

  //check to see if max linear velocities have been exceeded.

  if (vrtemp > 255) {

    vltemp = 255 * vltemp / vrtemp;

    vrtemp = 255;

  }

  if (vltemp > 255) {	   

    vrtemp = 255 * vrtemp / vltemp;    

    vltemp = 255;  

  }

  if (vrtemp < -255) {

    vltemp = -255 * vltemp / vrtemp;

    vrtemp = -255;

  }

  if (vltemp < -255) {

    vrtemp = -255 * vrtemp / vltemp;

    vltemp = -255;

  }

  *vr = (int)vrtemp;

  *vl = (int)vltemp;

}

/**

 * Copyright (c) 2007 Colony Project

 * 

 * Permission is hereby granted, free of charge, to any person

 * obtaining a copy of this software and associated documentation

 * files (the "Software"), to deal in the Software without

 * restriction, including without limitation the rights to use,

 * copy, modify, merge, publish, distribute, sublicense, and/or sell

 * copies of the Software, and to permit persons to whom the

 * Software is furnished to do so, subject to the following

 * conditions:

 * 

 * The above copyright notice and this permission notice shall be

 * included in all copies or substantial portions of the Software.

 * 

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES

 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT

 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,

 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR

 * OTHER DEALINGS IN THE SOFTWARE.

 **/

/**

 * @file battery.c

 * @brief Implementation for reading battery level

 *