#include <avr/io.h>

#define TAP_PIN PINB0
#define LED_PIN PINB1

int main(void)
{
	
    while (1) 
    {
    }
}

#include <avr/io.h>

#define TAP_PIN PINB0
#define LED_PIN PINB1

int main(void)
{
    DDRB |= (1<<LED_PIN); // la broche LED comme sortie
    PORTB |= (1<<TAP_PIN); //+5V à l'interrupteur

    while (1)  //Boucle infinie
    {
    }
}

//Pour écrire 1 dans le bit:
PORTA |= (1<<PINA0);

//Pour ecrire 0 dans le bit:
PORTA &= ~(1<<PINA0);

//Pour commuter la valeur du bit:
PORTA ^= (1<<PINA0);

#include <avr/io.h>
#define F_CPU 1000000UL		//indique la fréquence de l'horloge
#include <util/delay.h>		//inclue le header de delay

#include <avr/io.h>
#define F_CPU 1000000UL		//indique la fréquence de l'horloge
#include <util/delay.h>		//inclue la bibliothèque de delay

#define TAP_PIN PINB0
#define LED_PIN PINB1
#define DEBOUNCE_TIME 1000	//définie le temps de debounce en us

uint8_t debounce(void)		//declaration de la fonction de debounce
{
	if (bit_is_clear(PINB,0))	//si bouton appuyé
	{
		_delay_us(DEBOUNCE_TIME); //attendre 1ms
		if (bit_is_clear(PINB,0))    //si le bouton est toujours appuyé
		{
			return(1);	//la fonction retourne 1
		}
		else		//si le bouton n'est plus appuyé à un moment retourne 0
		{
			return(0);
		}
	}
	else
	{
		return(0);
	}
}            //fin de la fonction de debounce

int main(void)
{
	DDRB |= (1<<LED_PIN); //broche de LED comme sortie
	PORTB |= (1<<TAP_PIN); //+5V à l'interrupteur
    while (1) //boucle infinie
    {
    }
}

#include <avr/io.h>
#define F_CPU 1000000UL	//indique la fréquence d'horloge
#include <util/delay.h>	//inclue la bibliothèque de delay
#include <avr/sfr_defs.h> //inclue les special feature registers
#include <avr/interrupt.h> //iinclue les interruptions

#define TAP_PIN PINB0
#define LED_PIN PINB1
//on définie le temps de débounce en µs
#define DEBOUNCE_TIME 500 

volatile uint16_t ms = 0; //declaring 

//declaration de la fonction de debounce
uint8_t debounce(void)
{
	if (bit_is_clear(PINB,0))	//si bouton appuyé
	{
                        //attendre temps de debounce
		_delay_us(DEBOUNCE_TIME); 
                        //si bouton toujours appuyé
		if (bit_is_clear(PINB,0))    
		{
			return(1);    //fonction donne 1
		}
//si bouton relaché a un moment, fonction donne 0
		else
		{
			return(0);
		}
	}
	else
	{
		return(0);
	}
}

int main(void)
{
	DDRB |= (1<<LED_PIN); //broche LED sortie
	PORTB |= (1<<TAP_PIN); //+5V broche interrupteur
	
	/*timer0 setup*/
	OCR0A = 124;		//max du compteur
	TCNT0 = 0;		//Counter start
            //Fast PWM mode OCR1A en TOP
	TCCR0A |= (1<<WGM00) | (1<<WGM01);
            //interruption d'Overflow activée	
	TIMSK0 |= (1<<TOIE0);
             //Fast PWM mode, pas de prescaler
	TCCR0B |=  (1<<WGM02) | (1<<CS01); 
	
	sei(); //active les interruptions
    while (1) 
    {
    }
}

ISR(TIM0_OVF_vect) //interruption d'overflow du compteur
{
	ms++;	//incremente ms toutes les ms
}

int main(void)
{
    uint8_t buttonstate;    //bouton relaché?
    uint8_t nbtap = 0;     //nombre de tap en une séquence
    uint16_t maxtempo = 2000;    //tempo max autorisé en ms
    uint16_t tempo;    //le tempo actuel

if (debounce() == 1 && nbtap == 0 && buttonstate == 0) //premier tap
{
	TCNT0 = 0;	//commence à compter
	ms = 0;
	nbtap++;    //bouton appuyé une fois
	buttonstate = 1; //bouton pas encore relaché
}

if (debounce() == 0 && buttonstate == 1)	//si le bouton est relaché
		{
			buttonstate = 0;
		}

if (ms >= maxtempo)	// si ms dépasse tempo maximum
		{
			nbtap = 0;  //réinitialise nombre de tap
		}

if (debounce() == 1 && nbtap != 0 && buttonstate == 0) //pas le premier tap
{
	tempo = ms;		//nouveau tempo
	nbtap++;
	buttonstate = 1;
	TCNT0 = 0;		//réinitialise le compteur
	ms = 0;
}

volatile uint16_t ms = 0; //declaring ms counting variables
volatile uint16_t ledms = 0;

ISR(TIM0_OVF_vect) //Timer overflow interrupt
{
	ms++;	//increment every ms
	ledms++;
}

if (ledms >= tempo)
{
	ledms = 0;    //reinitialise le compteur LED
	PORTB |= (1<<LED_PIN);    //Allume la LED
	_delay_ms(8);   //attend 8ms
	PORTB &= ~(1<<LED_PIN);    //Eteint la LED
}

#include <avr/io.h>
#define F_CPU 1000000UL		//indique la fréquence d'horloge
#include <util/delay.h>		//inclue la bibliothèque de delay
#include <avr/interrupt.h>	//inclue les interruptions

#define TAP_PIN PINB0
#define LED_PIN PINB1
#define DEBOUNCE_TIME 500	//definie un temps de debounce en us

volatile uint16_t ms = 0; //declare les variable qui compte les ms
volatile uint16_t ledms = 0;

uint8_t debounce(void)		//declare la fonction de debounce
{
	if (bit_is_clear(PINB,0))	//si la broche du boutton est basse
	{
		_delay_us(DEBOUNCE_TIME); //attendre 1ms
		if (bit_is_clear(PINB,0))	//si broche toujours basse (boutton appuyé)
		{
			return(1);	//la fonction retourne 1
		}
		else	//si la broche n'est pas basse a un moment retourne 0
		{
			return(0);
		}
	}
	else
	{
		return(0);
	}
}

int main(void)
{
	DDRB |= (1<<LED_PIN); //LED comme sortie
	PORTB |= (1<<TAP_PIN); //+5v à l'interrupteur
	
	/*timer0 setup*/
	OCR0A = 124;		//valeur max du compteur 
	TCNT0 = 0;		//debut du compteur
	TCCR0A |= (1<<WGM00) | (1<<WGM01);	//Fast PWM mode OCR1A est le TOP
	TIMSK0 |= (1<<TOIE0);	//active l'interrution d'overflow
	TCCR0B |=  (1<<WGM02) | (1<<CS01); //Fast PWM mode, prescaler de 8
	
	uint8_t buttonstate;	//bouton relaché?
	uint8_t nbtap;			// Nombre de taps dans un séquence
	uint16_t maxtempo = 2000;	//tempo max autorisé
	uint16_t tempo;
	
	sei(); //Activate interrupts
	
    while (1) 
    {
		if (debounce() == 1 && nbtap == 0 && buttonstate == 0) //premier tap
		{
			TCNT0 = 0;	//commence à compter
			ms = 0;
			nbtap++;
			buttonstate = 1;
		}
		
		if (debounce() == 0 && buttonstate == 1)	//si bouton relaché
		{
			buttonstate = 0;
		}
		
		if (ms >= maxtempo)		//si tempo max dépassé
		{
			nbtap = 0;			//réinitialise la séquence
		}
		
		if (debounce() == 1 && nbtap != 0 && buttonstate == 0) //pas le premier tap
		{
			tempo = ms;		//nouvelle valeur de tempo
			nbtap++;
			buttonstate = 1;
			TCNT0 = 0;		//compteur à 0 pour la fois d'après
			ms = 0;
		}
		
		if (ledms >= tempo)    //si on est sur le temps
		{
			ledms = 0;    //remet compteur pour LED à zéro
			PORTB |= (1<<LED_PIN);    //allume la led
			_delay_ms(8);    //attend 8ms
			PORTB &= ~(1<<LED_PIN);    //eteint la LED
		}
    }
}

ISR(TIM0_OVF_vect) //interruption d'overflow
{
	ms++;	//incremente les millisecondes
	ledms++;
}