#define F_CPU 1000000UL
#include < avr/io.h>
#include < util/delay.h>
#include < avr/interrupt.h>
 
#include "r2.h"
 
int main(void) {
	// Activate all the LEDs, set their pins to output
	bit_set(LED_WHITE_L_DDR, LED_WHITE_L_BIT);
	bit_set(LED_WHITE_R_DDR, LED_WHITE_R_BIT);
	bit_set(LED_RED_L_DDR, LED_RED_L_BIT);
	bit_set(LED_RED_R_DDR, LED_RED_R_BIT);
	bit_set(LED_YELLOW_FL_DDR, LED_YELLOW_FL_BIT);
	bit_set(LED_YELLOW_FR_DDR, LED_YELLOW_FR_BIT);
	bit_set(LED_YELLOW_RL_DDR, LED_YELLOW_RL_BIT);
	bit_set(LED_YELLOW_RR_DDR, LED_YELLOW_RR_BIT);
 
	// Activate the motor's control lines
	bit_set(MOTOR_R_ENABLE_DDR, MOTOR_R_ENABLE_BIT);
	bit_set(MOTOR_R_PHASE_DDR, MOTOR_R_PHASE_BIT);
	bit_set(MOTOR_L_ENABLE_DDR, MOTOR_L_ENABLE_BIT);
	bit_set(MOTOR_L_PHASE_DDR, MOTOR_L_PHASE_BIT);
 
	// turn on the motors
	bit_set(MOTOR_R_ENABLE_PORT, MOTOR_R_ENABLE_BIT);
	bit_set(MOTOR_R_PHASE_PORT, MOTOR_R_PHASE_BIT);
	bit_set(MOTOR_L_ENABLE_PORT, MOTOR_L_ENABLE_BIT);
	bit_set(MOTOR_L_PHASE_PORT, MOTOR_L_PHASE_BIT);
 
	// turn on the white and red LEDs
	bit_set(LED_WHITE_L_PORT, LED_WHITE_L_BIT);
	bit_set(LED_WHITE_R_PORT, LED_WHITE_R_BIT);
	bit_set(LED_RED_L_PORT, LED_RED_L_BIT);
	bit_set(LED_RED_R_PORT, LED_RED_R_BIT);
 
	// enable internal pullup on PD0
	bit_set(PORTD, BIT(0));
	// enable external interrupts
	EIMSK = BIT(INT0) | BIT(INT1);
	// enable global interrupts
	sei();
 
	// loop forever
	while (1)
	{
 
		delayms(500);
	}
	return 0;
}
 
// delay for up to 65k milliseconds
void delayms(uint16_t millis) 
{
	// loop, delaying 1ms each iteration
	while ( millis ) 
	{
		_delay_ms(1);
		millis--;
	}
}
 
// this catches the Interrupt sent from pin INT0
ISR(INT0_vect) 
{
	//Turn everything off
	bit_clear(LED_WHITE_L_PORT, LED_WHITE_L_BIT);
	bit_clear(LED_WHITE_R_PORT, LED_WHITE_R_BIT);
	bit_clear(LED_RED_L_PORT, LED_RED_L_BIT);
	bit_clear(LED_RED_R_PORT, LED_RED_R_BIT);
 
	bit_clear(MOTOR_R_ENABLE_PORT, MOTOR_R_ENABLE_BIT);
	bit_clear(MOTOR_R_PHASE_PORT, MOTOR_R_PHASE_BIT);
	bit_clear(MOTOR_L_ENABLE_PORT, MOTOR_L_ENABLE_BIT);
	bit_clear(MOTOR_L_PHASE_PORT, MOTOR_L_PHASE_BIT);
 
 
	// loop forever, flashing our indicators.
	while(1)
	{
		bit_flip(LED_YELLOW_FL_PORT, LED_YELLOW_FL_BIT);
		bit_flip(LED_YELLOW_FR_PORT, LED_YELLOW_FR_BIT);
		bit_flip(LED_YELLOW_RL_PORT, LED_YELLOW_RL_BIT);
		bit_flip(LED_YELLOW_RR_PORT, LED_YELLOW_RR_BIT);
		delayms(500);
	}
}

#define bit_get(p,m) ((p) & (m))
#define bit_set(p,m) ((p) |= (m))
#define bit_clear(p,m) ((p) &= ~(m))
#define bit_flip(p,m) ((p) ^= (m))
#define bit_write(c,p,m) (c ? bit_set(p,m) : bit_clear(p,m))
#define BIT(x) (0x01 < < (x))
#define LONGBIT(x) ((unsigned long)0x00000001 << (x))

#define F_CPU 1000000UL
#include < avr/io.h>
#include < util/delay.h>
#include < avr/interrupt.h>
 
#include "r2.h"
 
int main(void) {
	// Activate all the LEDs, set their pins to output
	bit_set(LED_WHITE_L_DDR, LED_WHITE_L_BIT);
	bit_set(LED_WHITE_R_DDR, LED_WHITE_R_BIT);
	bit_set(LED_RED_L_DDR, LED_RED_L_BIT);
	bit_set(LED_RED_R_DDR, LED_RED_R_BIT);
	bit_set(LED_YELLOW_FL_DDR, LED_YELLOW_FL_BIT);
	bit_set(LED_YELLOW_FR_DDR, LED_YELLOW_FR_BIT);
	bit_set(LED_YELLOW_RL_DDR, LED_YELLOW_RL_BIT);
	bit_set(LED_YELLOW_RR_DDR, LED_YELLOW_RR_BIT);
 
	// enable internal pullup on PD0
	bit_set(PORTD, BIT(0));
	// enable external interrupts
	EIMSK = BIT(INT0) | BIT(INT1);
	// enable global interrupts
	sei();
 
	// turn on the white and red LEDs
	bit_set(LED_WHITE_L_PORT, LED_WHITE_L_BIT);
	bit_set(LED_WHITE_R_PORT, LED_WHITE_R_BIT);
	bit_set(LED_RED_L_PORT, LED_RED_L_BIT);
	bit_set(LED_RED_R_PORT, LED_RED_R_BIT);
 
	// loop forever
	while (1)
	{
		delayms(500);
	}
	return 0;
}
 
// delay for up to 65k milliseconds
void delayms(uint16_t millis)
{
	// loop, delaying 1ms each iteration
	while ( millis )
	{
		_delay_ms(1);
		millis--;
	}
}
 
// this catches the Interrupt sent from pin INT0
ISR(INT0_vect)
{
	//Turn everything off
	bit_clear(LED_WHITE_L_PORT, LED_WHITE_L_BIT);
	bit_clear(LED_WHITE_R_PORT, LED_WHITE_R_BIT);
	bit_clear(LED_RED_L_PORT, LED_RED_L_BIT);
	bit_clear(LED_RED_R_PORT, LED_RED_R_BIT);
 
	// loop forever, flashing our indicators.
	while(1)
	{
		bit_flip(LED_YELLOW_FL_PORT, LED_YELLOW_FL_BIT);
		bit_flip(LED_YELLOW_FR_PORT, LED_YELLOW_FR_BIT);
		bit_flip(LED_YELLOW_RL_PORT, LED_YELLOW_RL_BIT);
		bit_flip(LED_YELLOW_RR_PORT, LED_YELLOW_RR_BIT);
		delayms(500);
	}
}

// enable external interrupt
EIMSK = BIT(INT0);
//  set the interrupt to trigger on a rising edge
EICRA |= BIT(ISC00) | BIT(ISC01);

#define F_CPU 10000000UL
#include <avr /io.h>
#include <util /delay.h>
 
// delay for up to 65k milliseconds
void delayms(uint16_t millis) 
{
	// loop, delaying 1ms each iteration
	while ( millis ) 
	{
		_delay_ms(1);
		millis--;
	}
}
 
// initialise the adc
void init_adc ( void )
{
	//select external (VCC) voltage as the reference voltage (x0xx xxxx) 
	ADMUX = 0x00;
	//enable ADC (1000 0000)
	ADCSRA |= 0x80;
}
 
// read the specified adc
int adc_read ( uint8_t n )
{
	// set the adc to the chosen channel
	ADMUX = n;
	// start the ADC conversion, set the ADC clock to cpu clock / 16 (0100 0100)
	ADCSRA |= 0x44;
	// wait for the adc conversion to be completed
	while((ADCSRA & 0x40) !=0){};
	// return the adc result
	return ADC;
}
 
int main(void) 
{
	// set PB0 to output
	DDRB |= 1< <PB3;
	// turn on the ADC
	init_adc();
	// set up our variables
	int reading = 0, prev = 0, temp = 0;
	// loop for ever
	while(1) {
		// take a new adc reading
		reading = adc_read(2);
		// average it with the previous reading
		temp = (reading + prev) / 2;		
		// if the voltage is less than 6
		if ( temp > 185 )
		{
			// turn the output pin on
			PORTB &= ~(1< <PB3);
		}
		else
		{
			// turn the output pin off
			PORTB |= 1<<PB3; /* LED off */
		} 
		// save the current reading
		prev = reading;
		// wait for 20ms
		delayms(20);
	}
	return 0;
}