Example #1
0
File: input.c Project: eknl/gt3b
static void input_loop(void) {

    // read initial ADC values
    BSET(ADC_CR1, 0);			// start conversion
    while (!BCHK(ADC_CSR, 7))  pause();	// wait for end of conversion
    read_ADC();

    // put initial values to all buffers
    ADC_BUFINIT(0);
    ADC_BUFINIT(1);
    ADC_BUFINIT(2);
    adc_battery = adc_battery_last;
    adc_battery_filt = (u32)adc_battery * ADC_BAT_FILT;

    // task CALC must be awaked to compute values before PPM will take on
    awake(CALC);
    input_initialized = 1;

    while (1) {
	// read ADC only when EOC flag (only for first it will not be ready)
	if (BCHK(ADC_CSR, 7))
	    read_ADC();
	read_keys();
	stop();
    }
}
Example #2
0
/* check 12V supply voltage and warn user if it is too low */
	void check_supply_voltage(void)
{
	/*
	 *	Voltage threshold: Device is powered by a lead battery.
	 *	Warn user if voltage drops below 11.5V
	 *	Increase warning intensity if voltage drops below 11V
	 *
	 *	The input voltage divider is formed by a 100k and a 22k resistor. 
	 *	
	 *	| V_in	| V_div	| ADC	|
	 *	| 13.8V	| 2.49V | 249	|	
	 *	| 11.5V | 2.07V | 207	|
	 *	| 11.0V | 1.98V | 198	|
	 * 
	 */
	
	uint8_t ADC_result = read_ADC();
	int8_t corr = 7;	//correction for non-ideal resistors in the divider
	
	if(ADC_result > (207+corr))
	{
		switch_LED(0,'R');						//Everything is fine, no need to warn
	}
	else if(ADC_result > (198+corr))
	{
		flash_LED(2,100,'R');	//Supply voltage is low, check battery charger
	}else
	{
		flash_LED(2,30,'R');	//Supply voltage is dangerously low, user must act to prevent battery damage
	}
	
}
Example #3
0
int main(void)
{
	int read;
	float input_voltage, temperature;
	
	UART_INIT();					// UART 통신 초기화
	ADC_INIT(1);					// AD 변환기 초기화
	
	while(1)
	{
		// 온도 센서의 출력 전압을 ADC를 거쳐 읽는다.
		read = read_ADC();
		
		// 0에서 1023 사이의 값을 0V에서 5V 사이 값으로 변환한다.
		input_voltage = read * 5.0 / 1023.0;
		
		// 10mV에 1℃이므로 100을 곱해서 현재 온도를 얻는다.
		temperature = input_voltage * 100.0;
		
		UART_print16bitNumber((int)temperature);	// 정수값으로 출력
		UART_transmit('\n');				// 줄바꿈

		_delay_ms(1000);				// 1초에 한 번 출력
	}
}
Example #4
0
void Task_ReadJoystick()
{
    for(;;)
    {
        // The button reads ~0 when pushed, and anything from 10 to 1024 when released
        buttonState = (read_ADC(JOYSTICK_PIN_BUTN) < 10) ? '1' : '0' ;

        // Read the joystick analog value and save the corresponding direction to joystickDirection, n, e, s, w, and 0 for stop
        int joy_horz = read_ADC(JOYSTICK_PIN_HORZ);
        int joy_vert = read_ADC(JOYSTICK_PIN_VERT);

        /* map joystick values to:
        *   0 (west or north), 1 (middle), or 2 (east or south)
        */
        int dir_horz = map(joy_horz, JOYSTICK_MIN, JOYSTICK_MAX, 0, 2);
        int dir_vert = map(joy_vert, JOYSTICK_MIN, JOYSTICK_MAX, 0, 2);

        // horizontal directions take precedence over vertical
        if(dir_horz == 0)
        {
            joystickDirection = WEST;
        }
        else if(dir_horz == 1)
        {
            if(dir_vert == 0)
            {
                joystickDirection = NORTH;
            }
            else if(dir_vert == 1)
            {
                joystickDirection = NONE;
            }
            else if(dir_vert == 2)
            {
                joystickDirection = SOUTH;
            }
        }
        else if(dir_horz == 2)
        {
            joystickDirection = EAST;
        }

        Task_Sleep(5);
    }
}
Example #5
0
int main(void)
{
	ADC_init();
	powermgmt(); 
	uint8_t i;
	DDRB |= (1 << PB5)|(1 << PB4);       							//Set DDR of PORTB of LED 1 & LED 2-High(output)		
	while(1)										 
	{ 
		sleep_cpu();
 		for(i=0; i<=1; i++)
		{	
 			if(i==0)
 			{
 				ADC_converted = read_ADC(0);                 //Read one ADC channel 
 				sleep_disable();
 				if(ADC_converted < 50)
 				{
 					PORTB |= (1<<PB5);    //If ADC value is Below "10"(i.e darkness) turn led on
 				}
 				else
 				{
 					PORTB &= ~(1<<PB5);    //Else turn led off
 				}
 			}
 			else if(i==1)
 			{
 				ADC_converted = read_ADC(1);                 //Read one ADC channel
 				sleep_disable();
 				if(ADC_converted > 120)
 				{
 					PORTB |= (1<<PB4);    //If ADC value is Above 121(i.e temperature higher than room temperature) turn led on
 				}
 				else if(ADC_converted < 120)
 				{
 					PORTB &= ~(1<<PB4);    //Else turn led off
 				}
 			}
 			_delay_ms(400);					 //0.4 second switching between LDR and NTC
 		}
	}
	return 0;
}
Example #6
0
int main(void)
{
	range_select();

	init_timer0();
	init_ADC();	
	init_7Seg();
	init_led();
	
	while(1)
	{
		int r = 0;
		if(read_ADC()) r = calc_resist(read_ADC());
		
		test_limits(r);
		
		printbuf(r);
        _delay_ms(150);

	}
}
Example #7
0
int main(void)
{
	int i, j;
	uint16_t value;
	uint8_t adc_value;  //variable store value from conversion
	struct sched_t sched[NUM_LEDS];
	init_microcontroller();
	for (;;)
	{
		adc_value = read_ADC();
		//if (adc_value > 155)
		if (adc_value > ADC_ZERO + (EPSILON / 2))
		{
			// light blue radially from center
			scheduler_fill(sched, 0, 1, 0);
			scheduler_schedule_color(&sched[0], 0, 0, 1);
			value = ADC_ZERO + EPSILON;
			for (i=1; i<NUM_LEDS && value < 256; i++)
			{
				if (adc_value > value)
					scheduler_schedule_color(&sched[i], 0, 0, 1);
				else
					break;
				value += 10;
			}			
		}			
		else if (adc_value < ADC_ZERO - (EPSILON / 2))
		{
			// light red radially from center
			scheduler_fill(sched, 0, 1, 0);
			scheduler_schedule_color(&sched[0], 1, 0, 0);
			value = ADC_ZERO - EPSILON;
			for (i=1; i<NUM_LEDS && value >= 0; i++)
			{
				if (adc_value < value)
					scheduler_schedule_color(&sched[i], 1, 0, 0);
				else
					break;
				value -= 10;
			}			
		}								
		else
		{
			// at rest. light all green
			scheduler_fill(sched, 0, 1, 0);
		}			
		
		for (i=0; i<10; i++)
			scheduler_run(sched);
	}
	
	return 0;
}
Example #8
0
int main(void)
{
	int read;
	ADC_INIT(0); // AD 변환기 초기화
	INIT_TIMER1();
	while(1)
	{
		read = read_ADC(); // 가변저항 값 읽기
		OCR1A = PULSE_MIN + (int)(3.48 * read);
		_delay_ms(ROTATION_DELAY);
	}
}
Example #9
0
int main(void)
{
	int read, actualVCC;
	ADC_INIT(0x0E); // 15번 채널 선택
	UART_INIT(); // UART 통신 초기화
	while(1)
	{
		read = read_ADC(); // 15번 채널 값 읽기
		actualVCC = 1125300L / read; // mV 단위로 변환
		UART_print16bitNumber(actualVCC); // AVCC 값 출력
		UART_printString("\n"); // 줄 바꿈
		_delay_ms(1000); // 1초에 한 번 읽음
	}
}
Example #10
0
void main(void) {
    unsigned int adc_average;
    unsigned char adc_result, i;

    init_hardware();

    __delay_ms(500);

    while (1) {

        //Read the ADC and oversamples to improve accuracy
        adc_average = 0;
        for (i = 0; i < ADC_OVERSAMPLES; i++)
            adc_average += read_ADC(B_SENSE_INPUT);

        //Averages the read ADC samples
        adc_result = adc_average / ADC_OVERSAMPLES;

        //Processes the ADC value and switches outputs accordingly
        switch (state) {
            case STATE_ON:
                if (adc_result < CUTOUT_LEVEL) {
                    PORTC &= ~LEDG_PIN;
                    PORTC |= LEDR_PIN;
                    PORTC &= ~LVCO_PIN;
                    state = STATE_OFF;
                } else if (adc_result < LOW_BATT_LEVEL) {
                    PORTC |= (LEDR_PIN | LEDG_PIN | LVCO_PIN);
                } else {
                    PORTC |= ( LEDG_PIN | LVCO_PIN );
                    PORTC &= ~LEDR_PIN;
                }
                break;

            case STATE_OFF:
                if (LOW_BATT_LEVEL < adc_result) {
                    PORTC &= ~LEDR_PIN;
                    PORTC |= LEDG_PIN;
                    PORTC |= LVCO_PIN;
                    state = STATE_ON;
                }
                break;
        }

        //Waits a set time before reading the ADC again
        __delay_ms(POLL_INTERVAL_MS);

    }
}
Example #11
0
int main(void)
{
		 
	powermgmt();
	ADC_init();
	 
	DDRB |= (1 << PB5)|(1 << PB4);       							//Set DDR of PORTB of LED 1 & LED 2-High(output)
	sei();				// Enable Global Interrupts
	ADCSRA |= 1<<ADSC;		// Start Conversion		
	while(1)										 
	{ 
 	ADC_converted = read_ADC(i);                 //Read one ADC channel 	
	}
	return 0;
}
Example #12
0
int main(int argc, char **argv)
{
	initialize();
	clear_array();

	PORTE = 0;
	
	ADC_enable();
	ADC_set_channel(ADC_MUX_ADC5);
	ADC_set_prescaler(ADC_PRESCALER_128);
	ADC_start();
	

	while(1){
		set_array_red(read_ADC(ADC_MUX_ADC5));
	}
}	
// Analog input: 	Returns ADC value (12-bit resolution)
// Digital in/out: 	Returns I/O status to match the bit ordering
uint8_t get_user_io_val(uint16_t io_sel, uint16_t * val)
{
	struct __user_io_info *user_io_info = (struct __user_io_info *)&(get_DevConfig_pointer()->user_io_info);
	
	uint8_t ret = 0; // I/O Read failed
	uint8_t idx = 0;
	uint8_t status = 0;
	
	*val = 0;
	
	if((user_io_info->user_io_enable & io_sel) ==io_sel) // Enable
	{
		idx = get_user_io_bitorder(io_sel);
		
		if((user_io_info->user_io_type & io_sel) == io_sel) // IO_ANALOG == 1
		{
			// Analog Input: value
			*val = read_ADC(USER_IO_ADC_CH[idx]);
			//printf("===============> Analog input: %d <============\r\n", *val);
		}
		else // IO_DIGITAL == 0
		{
			// Digital Input / Output
			if((user_io_info->user_io_direction & io_sel) == io_sel) // IO_OUTPUT == 1
			{
				// Digital Output: status
				status = (uint16_t)GPIO_ReadOutputDataBit(USER_IO_PORT[idx], USER_IO_PIN[idx]);
				//printf("===============> Digital Output: %d <==============\r\n", status);
			}
			else // IO_INPUT == 0
			{
				// Digital Input: status
				status = (uint16_t)GPIO_ReadInputDataBit(USER_IO_PORT[idx], USER_IO_PIN[idx]);
				//printf("===============> Digital input: %d <==============\r\n", status);
			}
			
			//*val |= (status << i);
			*val = status;
		}
		
		ret = 1; // I/O Read success
	}
	
	return ret;
}
Example #14
0
int main(void)
{
	int value;
	uint8_t on_off;
	
	ADC_INIT(0);
	PORT_INIT();
	
	while(1)
	{
		value = read_ADC() >> 7;
		
		on_off = 0;
		for(int i = 0; i <= value; i++){
			on_off |= (0x01 << i);
		}
		PORTD = on_off;
	}
}
Example #15
0
void TIM2_IRQHandler (void)
{
    TIM2->SR &= ~(0x01);   
    bufferE[i%4096]= read_ADC();
    switch(etat)
    {
    case 0 : DAC->DHR12R1= bufferE[i%4096];
              LED_B_ON(1);
              LED_B_OFF(2);
              LED_B_OFF(10);
              LED_B_OFF(11);
      break;
    case 1 : DAC->DHR12R1= bufferE[i%4096] + bufferE[(i-1200)%4096] ;  // Double
              LED_B_ON(2);
              LED_B_OFF(1);
              LED_B_OFF(10);
              LED_B_OFF(11);
      break;
    case 2 : DAC->DHR12R1= bufferE[i%4096]+0.7*bufferS[(i-2400)%4096];   // Echo
             bufferS[i%4096]=DAC->DOR1;   
             LED_B_ON(10);
             LED_B_OFF(2);
              LED_B_OFF(1);
              LED_B_OFF(11);
      break;
    case 3 : 
              float tmp=0;
              for(int j=0;j<5;j++)
              {
                tmp+= (float)bufferE[(i)%4096]*coeffsFIR[(j)%4096];   // FIR 10khz
              }
             DAC->DHR12R1=tmp;
             LED_B_ON(11);
             LED_B_OFF(2);
             LED_B_OFF(10);
             LED_B_OFF(1);
             TIM2->SR &= ~(0x01); 
             break;
    }
    i++;
    }
Example #16
0
int main(void)
{
	/* Variables */
	uint16_t ad_value = 0;
    char ad_value_text[8];
	
	init_LCD();
	init_ADC();
	
	DDRD = 0xFF;
	PORTD = 0;
	
    while(1)
    {
		ad_value = read_ADC();
		itoa(ad_value,ad_value_text,10);
		LCDGotoXY(0,1);
		LCDstring((uint8_t*) ad_value_text, (uint8_t) strlen(ad_value_text));
		
    }
}
int main(void)
{
	init_ADC();  // Schalte ADC ein

	// korrekte Parameterwerte
	eADCRUNMODE runmode = SINGLESHOT; // Eine Messung
	start_ADC(runmode); // Messung starten

	eADCRES res = BIT8; // Auflösung des Digitalwertes
	unsigned short result;
	result = read_ADC(res); // 512 bei 50 % bei 10 Bit
							// 128 bei 50 % bei 8 Bit

	stop_ADC();

	unsigned long a = 835;
	unsigned long * p = &a;

	unsigned char b;
	b = ulong2bcd_unpk(p); // b=5 - richtig & a=83 - richtig

	// Sonderfall Parameter = 0
	unsigned long a2 = 0;
	unsigned long * p2 = &a2;
	unsigned char b2;
	b2 = ulong2bcd_unpk(p2);  // b2=0 - richtig & a2=0 - richtig

	unsigned char c;
	c = ulong2bcd_pk(89); // Wird 1000 1001 - richtig

	// inkorrekter Parameterwert
	unsigned char c2;
	c2 = ulong2bcd_pk(5); // Wird 0 - richtig

	unsigned char c3;
	c3 = ulong2bcd_pk(100); // Wird 0 - richtig

	while (1) {
	}
}
void GetAudioBandLevel(void)
{
	uint8_t audio_band = 0;
	DDRD	|=	(1 << STROBE)|(1 << EQ_RESET);				//PORTD bit strobe and reset pins output
	PORTD	&=	~((1 << STROBE)|(1 << EQ_RESET));			//sets strobe and reset low
	PORTD	|=	(1 << EQ_RESET);							//reset goes high
	_delay_us(100);											//delay 100usec for setup time req
	PORTD	|=	(1 << STROBE);								//strobe goes high
	_delay_us(50);											//strobe delays
	PORTD	&=	~(1 << STROBE);								//strobe goes low
	_delay_us(50);											//strobe delays
	PORTD	&=	~(1 << EQ_RESET);							//reset reset
	PORTD	|=	(1 << STROBE);								//strobe goes high
	_delay_us(50);
	
	for(audio_band = 0; audio_band < 7; audio_band++)
	{		
		PORTD	&=	~(1 << STROBE);				//resets (set strobe pin low (active))
		_delay_us(30);							//setup time for capture
		AudioLevel[audio_band] = read_ADC();	//reads 8 bit resolution audio level from audio bandpass filter
		PORTD	|=	(1 << STROBE);					//sets (set strobe pin high again)
		_delay_us(50);							//not sure if needed - check datasheet
	}	
}
Example #19
0
int main(void){
	//startLCD_Show_Credits();
    	//lcd_check_busy_flag();
    	//lcd_send_command( LCD_CLEAR );
    	//You can multiplex these pins by enabling and disabling the LCD display.
    	//lcd_puts( "Lx = 15uH " );
    	//lcd_check_busy_flag();
    	//lcd_send_command( LCD_SET_CURSOR_POS | LCD_SECOND_LINE );
    	//lcd_puts( "Cx = 150uF" );
	//lcd_check_busy_flag();
	//_delay_ms(2000);
	//lcd_send_command( LCD_CLEAR );
	//lcd_puts("Hello Jenn!");
	uart_init();
	stdout = &uart_tx;
	stdin = &uart_rx;
	init_ADC();

	//Set Pin Directions
	//Lights Pin as output
	LIGHTS_SIGNAL_DIR |= (1 << LIGHTS_SIGNAL);
	
	//Start Button Pin as input
	START_BUTTON_DIR &= ~(1 << START_BUTTON);
	
	//Stop Button Pin as Input
	STOP_BUTTON_DIR &= ~(1 << STOP_BUTTON);

	//Buzzer Pin as Output
	BUZZER_DIR |= (1 << BUZZER);

	//Trip Switch Pin as Input
	TRIP_SWITCH_DIR &= ~(1 << TRIP_SWITCH_PIN);

	//LCD Led Pin as output
	LCD_LED_DIR |= (1 << LCD_LED_PIN);
	LCD_LED_PORT |= (1 << LCD_LED_PIN); //Turn it on

	static long reading;
	static bool btnStop = false; 
	static bool tripSwitch = false;
	startLCD_Show_Credits();
	displayBlink(3);
	while (1){
		printf("Raw Reading: %d\t",read_ADC(0,&reading));
		long mapped_reading = mapRange(0,1023,0,1800,reading);
		printf("Mapped Reading: %d\t",mapped_reading);
		display_Selection(mapped_reading);
		if(START_BUTTON_PIN & (1 << START_BUTTON) && mapped_reading > 0){
			lcd_check_busy_flag();
			lcd_send_command(LCD_CLEAR);
			lcd_puts("    STARTING    ");
			displayBlink(2);
			long count = 0;
			_delay_ms(1000);
			//Turn on lights
			LIGHTS_SIGNAL_PORT |= (1 << LIGHTS_SIGNAL);
			bool lightsOn = true;
			for(count = mapped_reading;count >= 0;count--){
				//Check for stop button
				if(STOP_BUTTON_PIN & (1 << STOP_BUTTON)){
					lcd_check_busy_flag();
					lcd_send_command(LCD_CLEAR);
					lcd_puts("    STOPPING    ");
					btnStop = true;
					break;
				}
				//Pause if trip switch is high
				if(!(TRIP_SWITCH_PIN & (1 << TRIP_SWITCH))){
					if(!lightsOn){
						LIGHTS_SIGNAL_PORT |= (1 << LIGHTS_SIGNAL);
					}
					//If the the switch is still closed
					printf("UV Lights on for: %d more secs...\n",count);
					lcd_check_busy_flag();
					lcd_send_command(LCD_CLEAR);
					lcd_puts("    Exposing    ");
					lcd_check_busy_flag();
					lcd_send_command(LCD_SET_CURSOR_POS | LCD_SECOND_LINE);
				        char * zero = "0";	
					uint8_t mins = count / 60;
					uint8_t secs = count % 60;
					char minsStr[5];
					char secsStr[5];
					itoa(mins,minsStr,10);
					itoa(secs,secsStr,10);
					lcd_check_busy_flag();
					lcd_puts("      ");
					if(mins <= 9){
						lcd_check_busy_flag();
						lcd_puts(zero);
					}
					lcd_check_busy_flag();
					lcd_puts(minsStr);
					lcd_check_busy_flag();
					lcd_puts(":");
					if(secs <= 9){
						lcd_check_busy_flag();
						lcd_puts(zero);
					}
					lcd_check_busy_flag();
					lcd_puts(secsStr);  	
					_delay_ms(1000);
				}
				else{	
					lightsOn = false;
					LIGHTS_SIGNAL_PORT &= ~(1 << LIGHTS_SIGNAL);
					//Tell user the lid is open
					printf("LID OPEN, CLOSE IT TO CONTINUE\n");
					lcd_check_busy_flag();
					lcd_send_command(LCD_CLEAR);
					lcd_puts("    LID OPEN     ");
					lcd_check_busy_flag();
					lcd_send_command(LCD_SET_CURSOR_POS | LCD_SECOND_LINE);
					lcd_puts(" PLEASE CLOSE IT ");
					//Increment Count to make up for this one
					count++;
				}
				 	
			}
			//Turn off lights
			LIGHTS_SIGNAL_PORT &= ~(1 << LIGHTS_SIGNAL);
			if(btnStop != true){
				lcd_check_busy_flag();
				lcd_send_command(LCD_CLEAR);
				lcd_puts("    FINISHED    ");
				alarmSound(2);
			}
			else{
				buzzerSound(13);
				btnStop = false; //reset the stop flag
			}
			displayBlink(2);
		}	
	}
    	return 0;
}
Example #20
0
int main (void){
	//Start UART
	init_UART();
	stdout = &uart_tx;
	stdin = &uart_rx;
	
	//Start ADC
	init_ADC();

	//Set pins for display as output
	//Digit 1
	DDRD |= (1 << PD5); //A
	DDRD |= (1 << PD6); //B
	DDRD |= (1 << PD7); //C
	DDRB |= (1 << PB0); //D
	
	//Digit 2
	DDRC |= (1 << PC1); //A
	DDRC |= (1 << PC2); //B
	DDRC |= (1 << PC3); //C
	DDRC |= (1 << PC4); //D

	//Lights Pin Output
	DDRC |= (1 << PC5); 
 
	//Start/Stop Button
	DDRB &= ~(1 << PB1); //Start button input	
	DDRB &= ~(1 << PB2); //Stop button input

	//Buzzer Pin
	DDRD |= (1 << PD2); //Output

   	int first_digit = 9;
	int second_digit = 10;    
    	static long reading;
	static bool btnStart;

	//Blink display to let me know everything is good!
	displayBlink(5);
	while(1) {
		printf("Raw Reading: %d\t",read_ADC(0,&reading));
		long mapped_reading = mapRange(0,1023,0,99,reading);
		printf("Mapped Reading: %d\n",mapped_reading);
		display_Selection(mapped_reading);
		if(PINB & (1 << PB1) && mapped_reading > 0 ){ //If the Start button gets pressed then
			displayBlink(2);
			int count = 0;
			_delay_ms(1000);
			PORTC |= (1 << PC5);
			for(count = mapped_reading;count >= 0;count--){
				//Count Backwards from that number	
				//Check for stop button quit if set
				if(PINB & (1 << PB2))
					break;

				uint8_t fdigitm = count / 10;
				uint8_t sdigitm = count % 10;
				firstDisplay(fdigitm);
				secondDisplay(sdigitm);
				printf("UV Lights on for: %d more secs...\n",count);
				_delay_ms(1000);
			}	
			PORTC &= ~(1 << PC5);
			//displayBlink(5);
			alarmSound(2);
			displayBlink(2);
		}
	}
}
Example #21
0
/******************************* Main Program Code *************************/
int main(void)
{
	// configure the microprocessor pins for the data lines
	lcd_D7_ddr |= (1<<lcd_D7_bit);                  // 4 data lines - output
	lcd_D6_ddr |= (1<<lcd_D6_bit);
	lcd_D5_ddr |= (1<<lcd_D5_bit);
	lcd_D4_ddr |= (1<<lcd_D4_bit);

	// configure the microprocessor pins for the control lines
	lcd_E_ddr |= (1<<lcd_E_bit);                    // E line - output
	lcd_RS_ddr |= (1<<lcd_RS_bit);                  // RS line - output
	
	// configure the microprocessor pins for the pushbutton
	pushbutton_ddr &= (1<<pushbutton_bit);
	pushbutton_port |= (1<<pushbutton_bit);
	
	// initialize adc
	ADMUX = ((1<<REFS0)|(1<<MUX2)|(1<<MUX0));				// Aref = Vcc, select ADC5
	ADCSRA = ((1<<ADEN)|(1<<ADPS2)|(1<<ADPS1)|(1<ADPS0));	// Prescaler div factor = 128
	
	// initialize the LCD controller as determined by the defines (LCD instructions)
	lcd_init_4d();                                  // initialize the LCD display for a 4-bit interface
	
	// initialize TWI
	i2c_init();
	
	// initialize thermometer
	therm_init();
	
	// display the first line of information
	lcd_write_string_4d(disp_time);
	
	// set cursor to start of second line
	lcd_write_instruction_4d(lcd_setCursor | lcd_lineTwo);
	_delay_us(40);                                  // 40 uS delay (min)

	// Code for interfacing with the serial connection
	char str[25];
	int yy,mm,dd;
	sei();					// Enable global interrupts
	uart_init();			// Initialize the USART using baud rate 9600
	uart_printstr(sdata);		// Print a string from SRAM
	uart_printstr(fdata);		// Print a string from FLASH

	
	getDate(&yy,&mm,&dd);	// Get date from user
	sprintf(str,"Date: %d/%d/%d\n",yy,mm,dd);
	uart_printstr(str);




	// endless loop
	while(1)
	{
		uart_printstr(sdata);		// Print a string from SRAM
		uart_printstr(fdata);
		// replace with check for button press function
		if(bit_is_clear(pushbutton_pin,pushbutton_bit))
		{
			_delay_ms(100);
			if(bit_is_clear(pushbutton_pin,pushbutton_bit))
			mode_new = (mode + 1) % 3;
		}
		
		if(mode_new != mode)
		{
			// clear lcd
			lcd_write_instruction_4d(lcd_clear);
							
			// display the first line of information
			// set cursor to start of first line
			lcd_write_instruction_4d(lcd_setCursor | lcd_lineOne);
			_delay_us(40);                                  // 40 uS delay (min
			lcd_write_string_4d(disp_time);
			
			// set cursor to start of second line
			lcd_write_instruction_4d(lcd_setCursor | lcd_lineTwo);
			_delay_us(40);                                  // 40 uS delay (min)
	
			if (mode_new == 0)
			{				
				voltage = read_ADC();
				lcd_write_string_4d(disp_volt);
			}
			else if (mode_new == 1)
			{			
				frequency = 10 * freq_cntr_get_frequency();
				lcd_write_string_4d(disp_freq);
			}
			else
			{			
				temp_calcTemp(); // test thermometer
				lcd_write_string_4d(disp_temp);
			}			
		}
		
		mode = mode_new;
	}
	return 0;
}