#include 
#include 

#define BUTTON_PIN PB0

typedef enum {
    BTN_IDLE,
    BTN_PRESSED,
    BTN_RELEASED
} button_state_t;

// Finite State Machine untuk debouncing
button_state_t button_fsm(uint8_t current_state) {
    static button_state_t state = BTN_IDLE;
    static uint16_t debounce_counter = 0;
    
    switch(state) {
        case BTN_IDLE:
            if (current_state == 0) {  // Button pressed
                debounce_counter++;
                if (debounce_counter > 100) {  // 10ms debounce
                    state = BTN_PRESSED;
                    debounce_counter = 0;
                }
            } else {
                debounce_counter = 0;
            }
            break;
            
        case BTN_PRESSED:
            if (current_state == 1) {  // Button released
                debounce_counter++;
                if (debounce_counter > 100) {
                    state = BTN_RELEASED;
                    debounce_counter = 0;
                }
            } else {
                debounce_counter = 0;
            }
            break;
            
        case BTN_RELEASED:
            state = BTN_IDLE;
            break;
    }
    
    return state;
}

int main(void) {
    DDRB &= ~(1 << BUTTON_PIN);  // Input
    PORTB |= (1 << BUTTON_PIN);  // Pull-up
    
    while(1) {
        uint8_t button_raw = (PINB & (1 << BUTTON_PIN)) == 0;
        button_state_t state = button_fsm(button_raw);
        
        if (state == BTN_PRESSED) {
            // Button pressed action
            // ...
        } else if (state == BTN_RELEASED) {
            // Button released action
            // ...
        }
        
        _delay_ms(1);  // 1ms sampling rate
    }
}

#include 
#include 
#include 

#define DIGIT_COUNT 4

// Segment pins (Common for all digits)
#define SEG_PORT PORTD
#define SEG_DDR  DDRD

// Digit select pins (Common Cathode)
#define DIG_PORT PORTB
#define DIG_DDR  DDRB

uint8_t digits[DIGIT_COUNT] = {0, 0, 0, 0};
uint8_t current_digit = 0;

const uint8_t seg_table[] = {
    0x3F, 0x06, 0x5B, 0x4F, 0x66, 0x6D, 0x7D, 0x07, 0x7F, 0x6F
};

// Timer interrupt for multiplexing
ISR(TIMER0_COMPA_vect) {
    // Turn off all digits
    DIG_PORT |= 0x0F;
    
    // Set segments for current digit
    SEG_PORT = seg_table[digits[current_digit]];
    
    // Enable current digit
    DIG_PORT &= ~(1 << current_digit);
    
    // Move to next digit
    current_digit = (current_digit + 1) % DIGIT_COUNT;
}

void display_init() {
    // Set segment pins as output
    SEG_DDR = 0xFF;
    
    // Set digit select pins as output
    DIG_DDR |= 0x0F;
    
    // Timer0 setup for 1kHz interrupt (1ms per digit)
    TCCR0A = (1 << WGM01);  // CTC mode
    TCCR0B = (1 << CS01) | (1 << CS00);  // Prescaler 64
    OCR0A = 249;  // 1kHz
    TIMSK0 = (1 << OCIE0A);
    
    sei();  // Enable global interrupts
}

void display_number(uint16_t number) {
    digits[0] = number % 10;
    digits[1] = (number / 10) % 10;
    digits[2] = (number / 100) % 10;
    digits[3] = (number / 1000) % 10;
}

int main(void) {
    display_init();
    uint16_t counter = 0;
    
    while(1) {
        display_number(counter);
        counter++;
        _delay_ms(100);
    }
}