//==================
#ifndef PROC_DEVICE_H
#define PROC_DEVICE_H

#include "proc_device.h"
#include "main_def_func.h"
//==================

//==================
#define LED_1_PORT PORTD
#define LED_1_DDR  DDRD
#define LED_1_PIN  PIND
#define LED_1      PD2

#define LED_2_PORT PORTD
#define LED_2_DDR  DDRD
#define LED_2_PIN  PIND
#define LED_2      PD3
//==================

//==================
#ifdef __PROJECT_MODE_WORK__
#define LED_1_DELAY_BLINK 500
#endif

#ifdef __PROJECT_MODE_DEBUG__
#define LED_1_DELAY_BLINK 1
#endif
//==================

//==================
void proc_device (void);
//==================

//==================
void led_1_on (void);
void led_1_off (void);
void led_1_switch (void);

void set_proc_led_1_blink_on (void);
void set_proc_led_1_blink_off (void);
void proc_led_1_blink (void);

void led_2_on (void);
void led_2_off (void);
void led_2_switch (void);
//==================

#endif

//==================
#include "proc_device.h"
//==================

//==================
void proc_device (void)
{
   static u08 _proc_device;

   switch (_proc_device)
   {
      case 0:
         set_bit (LED_1_DDR, LED_1); // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
         set_bit (LED_2_DDR, LED_2); // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
         _proc_device = 1;
         break;

      case 1:
         if (Get_Event (EV_ID_KEY_PRESSED))
         {
            switch (GetKeyCode ())
            {
               case KEY_PLUS_COD:
                  set_proc_led_1_blink_on ();
                  led_2_on ();
                  _proc_device = 2;
                  break;

               case KEY_MINUS_COD:
                  break;
            }
         }

//         _proc_device = 2;
         break;

      case 2:
         if (Get_Event (EV_ID_KEY_PRESSED))
         {
            switch (GetKeyCode ())
            {
               case KEY_PLUS_COD:
                  set_proc_led_1_blink_off ();
                  led_2_off ();
                  _proc_device = 1;
                  break;

               case KEY_MINUS_COD:
                  break;
            }
         }

//         _proc_device = 2;
         break;

      default:
         break;
   }

   proc_led_1_blink ();
}
//==================

//==================
void led_1_on (void)
{
   set_bit (LED_1_PORT, LED_1);
}

void led_1_off (void)
{
   clr_bit (LED_1_PORT, LED_1);
}

void led_1_switch (void)
{
   switch_bit (LED_1_PORT, LED_1);
}
//==================

//==================
static u08 _proc_led_1_blink;

void set_proc_led_1_blink_on (void)
{
   _proc_led_1_blink = 1;
}

void set_proc_led_1_blink_off (void)
{
   _proc_led_1_blink = 0;
   led_1_off ();
}

void proc_led_1_blink (void)
{
   static soft_timer ST_PROC_LED_1_BLINK;

   switch (_proc_led_1_blink)
   {
      case 0:
         break;

      case 1:
         set_bit (LED_1_DDR, LED_1); // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
         led_1_on ();
         set_soft_timer (ST_PROC_LED_1_BLINK, 0, LED_1_DELAY_BLINK);

         _proc_led_1_blink = 2;
         break;

      case 2:
         if (handle_soft_timer (ST_PROC_LED_1_BLINK))
         {
            led_1_switch ();
         }
         break;

      default:
         break;
   }
}
//==================

//==================
void led_2_on (void)
{
   set_bit (LED_2_PORT, LED_2);
}

void led_2_off (void)
{
   clr_bit (LED_2_PORT, LED_2);
}

void led_2_switch (void)
{
   switch_bit (LED_2_PORT, LED_2);
}
//==================

#include <mega8.h>
#include <delay.h>

#define T0VAL = 195 // переполнение на 195 тиках ~ 200мс

char flag;

void main(void) {
  DDRD = 0x00;
  PORTD = 0xFF;
  DDRB = 0xFF;
  PORTB = 0x00;
  DDRC.0 = 0xFF;
  PORTC.0 = 0x00;
  DDRC.1 = 0xFF;
  PORTC.1 = 0x00;
  DDRC.2 = 0x00;
  DDRC.3 = 0x00;
  DDRC.4 = 0x00;
  DDRC.5 = 0x00;
  PORTC.2 = 0xFF;
  PORTC.3 = 0xFF;
  PORTC.4 = 0xFF;
  PORTC.5 = 0xFF;
  PORTB.0 = 1;
  PORTB.4 = 1;
 
  while (1) {
    // кнопка-триггер нажимается, пока просто запоминаем включение у нас (флаг = 1) или выключение (флаг = 3)
    if (!PINC.2 && flag == 0)
      flag = 1;
    else if (!PINC.2 && flag == 2)
      flag = 3;

    // кнопку-триггер отжали, теперь можно переключать состояние
   if (PINC.2 && flag == 1) {
     TCCR0 = (1 << CS02) | (1 << CS00); // Timer0 запуск, предделитель = /1024
     PORTC.0 = 1; // Включаем d9
      flag = 2;
   }
    else if (PINC.2 && flag == 3) {
     PORTC.0 = 0; // Включаем d9
     PORTC.1 = 0; // и d10 тоже (а вдруг он был включен)
      flag = 0; // возвращаемся к "состоянию 0"
     TCCR0 = 0; // Stop Timer0
   }
   
   if (flag >= 2 && TCNT0 >= T0VAL) { // если у включеное состояние "триггера" и таймер0 досчитал до 195 (200мс), то мигаем d10
     PORTC.1 ^= PORTC.1; // инвертируем состояние PC1
     TCNT0 = 0; // Сбросить счетчик таймера
   }

    //// 1-ая группа кнопок
    if (!PIND.0) {
      PORTB.0 = 1;
      PORTB.1 = 0;
      PORTB.2 = 0;
      PORTB.3 = 0;
    }
    if (!PIND.1) {
      PORTB.1 = 1;
      PORTB.0 = 0;
      PORTB.2 = 0;
      PORTB.3 = 0;
    }
    if (!PIND.2) {
      PORTB.2 = 1;
      PORTB.0 = 0;
      PORTB.1 = 0;
      PORTB.3 = 0;
    }
    if (!PINC.5) {
      PORTB.5 = 1;
      PORTB.0 = 0;
      PORTB.1 = 0;
      PORTB.3 = 0;
    }
    if (!PIND.3) {
      PORTB.3 = 1;
      PORTB.0 = 0;
      PORTB.1 = 0;
      PORTB.2 = 0;
    }
    /////////   2-ая   группа кнопок
    if (!PIND.4) {
      PORTB.4 = 1;
      PORTB.5 = 0;
      PORTB.6 = 0;
      PORTB.7 = 0;
    }
    if (!PIND.5) {
      PORTB.5 = 1;
      PORTB.6 = 0;
      PORTB.7 = 0;
      PORTB.4 = 0;
    }
    if (!PIND.6) {
      PORTB.6 = 1;
      PORTB.4 = 0;
      PORTB.5 = 0;
      PORTB.7 = 0;
    }
    if (!PIND.7) {
      PORTB.7 = 1;
      PORTB.4 = 0;
      PORTB.5 = 0;
      PORTB.6 = 0;
    }
  }
}

eState trToggleBypass() {
...
}

eState trAcRestoration() {
    if (state.v1_state != VST_CLOSED)
        return trToggleBypass();
    else
        return ST_NORMAL;
}

// Transition table type
typedef eState (*trans_t[ST_LAST][EV_LAST])(void);

// Transition table
trans_t trans = {
    [ST_NORMAL][EV_BTN_SHORT] = trToggleBypass,
    [ST_BYPASS][EV_AC_RESTORATION] = trAcRestoration,
    [ST_WATER_CLOSED][EV_BTN_SHORT] = trToggleBypass,
    [ST_ANY][EV_VALVE_TIMEOUT] = trError
};

enum class State : uint8_t { _, A, AC, ACD, ACDA, AB, ABA, ABAD, ABADC };
enum class Event : uint8_t { PressA, PressB, PressC, PressD };

constexpr Transition<State, Event> transitions[] =
{
    { State::_,     Event::PressA, State::A },
    { State::A,     Event::PressC, State::AC },
    { State::AC,    Event::PressD, State::ACD },
    { State::ACD,   Event::PressA, State::ACDA, [] { greenLed.toggle(); } },
   
    { State::A,     Event::PressB, State::AB },
    { State::AB,    Event::PressA, State::ABA },
    { State::ABA,   Event::PressD, State::ABAD },
    { State::ABAD,  Event::PressC, State::ABADC, [] { redLed.toggle(); } }
};

StateMachine<transitions> sm;
sm.process(Event::PressB);
sm.process(Event::PressD);
sm.process(Event::PressA);   // A
sm.process(Event::PressC);   // AC
sm.process(Event::PressD);   // ACD
sm.process(Event::PressA);   // ACDA -> greenLed.toggle()