/***********************************************************************
*
*	Slave-Flash with Attiny24
*
* 	Description:
*	A photo-diode registers a flash and counts an internal counter
*	if the counter reaches the limit an second flash is triggered.
*
*	Ports:
*	PB3 Reset, active low, 10k to VCC, pushbutton to GND
*	PB2 	Interrupt int0, active high, 2.2n capacitor to photo-diode-resistor voltage divider
* 	PB1	Unused
*	PB0	Unused
*	PA7	Unused
*	PA6	Unused
*	PA5	fire
*	PA4 	statusled
*	PA3	16bit-selectorD
*	PA2	16bit-selectorC
*	PA1 	16bit-selectorB
*	PA0	16bit-selectorA
*
*	Current usage: 2mA in Idle-Mode, 10mA with LED
*
*	Date: 19.6.2011 andyk75 for instructables
***********************************************************************/

#ifndef F_CPU
// #warning "F_CPU was not defined, is now set to 1MHz"
#define F_CPU 1000000UL    // Systemclock in Hz - Definition as unsigned long 
#endif

#include <inttypes.h>
#include <avr/io.h>
#include <util/delay.h>
#include <avr/sleep.h>
#include <avr/interrupt.h> 
#include "slaveflash.h"		// project specific definitions


void init(void)
{
	// Adjust the ports and the direction registers
	statusledport &= ~(1<<statusled);			
	statusledDDR |= (1<<statusled);			

	fireledport &= ~(1<<fireled);			// set the fire-port low
	fireledDDR |= (1<<fireled);			// set the fireport as an output
	
	//enable pullups for the four inputs of the hex-switch, that saves us external resistors ;-)
	selectorport |= (1<<selectorA) | (1<<selectorB) | (1<<selectorC) | (1<<selectorD);
	
	// Flashdetect-Interrupt 
	MCUCR |= (1<<ISC01);					// A rising Edge at Int0 generates Interrupt
	GIMSK |= (1<<INT0);					// aktivate interupt for int0

	// Set the sleepmode to idle: all interrupts can wake up the device.
	ACSR |= (1<<ACD);					// Analog comparator disable
	ADCSRA = 0;						// ADC disable
	PRR = (1<<PRTIM0) | (1<<PRUSI) | (1<<PRADC);		// shut down timer1, USI, ADC for power reduce
	set_sleep_mode(SLEEP_MODE_IDLE);			// any interrupt is able to reactivate the device.

	// Timer to reset the flashcounter
	TCCR1B = (1<<CS12) | (1<<CS10);				// Prescaler 64
	TIMSK1 = (1<<TOIE1);					// Overflow interrupt enable

	sei();							// global interrupts enable 
	flashcount = 0;						// clear all counted flashes
}

// Timer 0 Overflow
ISR(TIM1_OVF_vect)			
{
	cli();							// disable further interrupts while working on this
	flashcount = 0;						// Reset the counted flashes
	statusledport &= ~(1<<statusled);			// clear the statusled
	TCNT1 = 62606;						// preload the timer counter for about 3s.
	sei();							// reenable interrupts
	sleep_mode(); 						// go to sleep until next interrupt.
}


// Interrupt Service routine for the int0-Pin (PB2 = interrpt)
ISR(INT0_vect)				
{
	cli();
	statusledport ^= (1<<statusled);			// Toggle statusled
	flashcount++;						// count the flash
	if (flashcount == flashesneeded) fire();		// check if the necessary count of flashes was counted
	TCNT1 = 62606;						// preload the timer counter for about 3s.
	sei();							// Reenable interrups
	sleep_mode(); 						// go to sleep until next interrupt.
}

int main(void)
{
	init();							// Set all Registers and initialise
	
	_delay_ms(100);						// wait for a short while

	flashesneeded = getneededflashes();			// Get the needed flashes = read out the hex-switch
	signal(flashesneeded);					// give a feedback
	sleep_mode(); 						// go to sleep until next interrupt.

	for(;;);						// Nothing more to do. Everything else is done in the interrupt routines.

return 0;
}


void signal(uint8_t counter)					// The feedback for the user. Just 'flashing' the led.
{
uint8_t i;
for(i = 0; i<counter; i++)
	{
		statusledport |= (1<<statusled);
		_delay_ms(50);
		statusledport &= ~(1<<statusled);
		_delay_ms(150);
	}		
}


void fire(void) 							// Release the slave-flash
{
	// Release the slave-flash
	fireledport |= (1<<fireled);
	_delay_ms(250);
	fireledport &= ~(1<<fireled);
	flashcount = 0;
}


uint8_t getneededflashes(void)				// read the input of the hex-switch
{
	uint8_t flashes = 0;

	/* 	This routing might seem very short and it really is. 
		The trick is that we have chosen PA0-PA3 for to connect the hex-switch
		and in the right way. All other combination would have made much more
		code necessary. So think before building a device! 
		
		This is how it works:
		selectorpin reads out the complete PINA.
		the %16 chooses only the four lowest bits (PA0-PA3)
		and because we use active low (internal pullups!) We have to subtract the result from 15.
		That's it. Easy huh?
	*/

	flashes = 15- selectorpin%16;				
	
	return flashes;
		 
}