const byte Sn0 = 7; // линия D7
const byte Sn1 = 8; // линия D8
const byte Sn2 = 9; // линия D9
const byte LED0 = 4; // линия D4
const byte LED1 = 5; // линия D5
const byte LED2 = 6; // линия D6
volatile byte tmp0 = 0; // временный буфер 0
volatile byte tmp1 = 0; // временный буфер 1
volatile byte Flag = 0; // контрольный флаг
void wait0();
void wait1();


void setup() {
  // put your setup code here, to run once:
 digitalWrite(LED0, HIGH); digitalWrite(LED1, HIGH); digitalWrite(LED2, HIGH);
 pinMode(Sn0, INPUT_PULLUP); pinMode(Sn1, INPUT_PULLUP);
 pinMode(Sn2, INPUT_PULLUP); pinMode(LED0, OUTPUT);
 pinMode(LED1, OUTPUT); pinMode(LED2, OUTPUT);
 
}

void loop() {
  // put your main code here, to run repeatedly:
// ожидание нажатия
  while (!Flag)
  {
   wait0();
   if (tmp0==tmp1){Flag=1;}
    else {Flag=0; tmp1=tmp0;}
   delay(35);
  }
  switch (tmp1){
    case 6:
     wait0();
     if (tmp1==tmp0)
      { // выполнять, если нажатие подтверждено
       digitalWrite(LED0, LOW); digitalWrite(LED1, HIGH);
       digitalWrite(LED2, HIGH); Flag=0;
      }
     break;
    case 5:
     wait0();
     if (tmp1==tmp0)
      { // выполнять, если нажатие подтверждено
       digitalWrite(LED0, HIGH); digitalWrite(LED1, LOW);
       digitalWrite(LED2, HIGH); Flag=0;
      }
     break;
    case 3:
     wait0();
     if (tmp1==tmp0)
      { // выполнять, если нажатие подтверждено
       digitalWrite(LED0, HIGH); digitalWrite(LED1, HIGH);
       digitalWrite(LED2, LOW); Flag=0;
      }
     break;
    default:
      // if nothing else matches, do the default
      // default is optional
    break;
  }
/*
 * ожидание отпускания всех кнопок после того, как был завершен
 * хотя бы один из обработчиков
 * если при входе в селектор имело место отсутствие нажатий
 * или неразрешенная комбинация контроль отпускания игнорируется
 */
 while(!Flag)
 {
  wait1();
  if (tmp0==0)
  { //ожидание подтверждения отпускания
    delay(35); wait1();
    if (tmp0==0){Flag=1; tmp1=0;}
  }
 }
 Flag=0;
}

//----------

void wait0()
{
 tmp0=((digitalRead(Sn0) << 0) | (digitalRead(Sn1) << 1) | (digitalRead(Sn2) << 2)) & 0x07;
}
void wait1()
{
 tmp0 = ~(((digitalRead(Sn0) << 0) | (digitalRead(Sn1) << 1) | (digitalRead(Sn2) << 2)) | 0xF8);
}

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

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

   switch (_proc_device)
   {
      case 0: // Init IO
         io_init ();
         _proc_device = 1;
         break;

      case 1:
         if (Get_Event (EV_ID_INPUTS_CHANGE))
         {
            switch (get_inputs ())
            {
               case (IN_1_BIT):
                  if (get_proc_led_1_state () == 0)
                  {
                     set_proc_led_2_off ();
                     set_proc_led_3_off ();

                     set_proc_led_1_run ();
                  }
                  else
                     set_proc_led_1_off ();
                  break;

               case (IN_2_BIT):
                  if (get_proc_led_2_state () == 0)
                  {
                     set_proc_led_1_off ();
                     set_proc_led_3_off ();

                     set_proc_led_2_run ();
                  }
                  else
                     set_proc_led_2_off ();
                  break;

               case (IN_3_BIT):
                  if (get_proc_led_3_state () == 0)
                  {
                     set_proc_led_1_off ();
                     set_proc_led_2_off ();

                     set_proc_led_3_run ();
                  }
                  else
                     set_proc_led_3_off ();
                  break;
            }
         }
         break;

      default:
         set_proc_led_1_off ();
         set_proc_led_2_off ();
         set_proc_led_3_off ();
         break;
   }

   proc_led_1 ();
   proc_led_2 ();
   proc_led_3 ();
}
//==================

//==================
void io_init (void)
{
   set_bit (OUT_1_DDR, OUT_1); // Пин OUT_1 - выход
   set_bit (OUT_2_DDR, OUT_2); // Пин OUT_2 - выход
   set_bit (OUT_3_DDR, OUT_3); // Пин OUT_3 - выход
}
//==================

//==================
void out_1_on (void)
{
   __out_1_on ();
}

void out_2_on (void)
{
   __out_2_on ();
}

void out_3_on (void)
{
   __out_3_on ();
}
//----------
void out_1_off (void)
{
   __out_1_off ();
}

void out_2_off (void)
{
   __out_2_off ();
}

void out_3_off (void)
{
   __out_3_off ();
}
//----------
void out_1_switch (void)
{
   __out_1_switch ();
}

void out_2_switch (void)
{
   __out_2_switch ();
}

void out_3_switch (void)
{
   __out_3_switch ();
}
//----------
void all_outs_off (void)
{
   out_1_off ();
   out_2_off ();
   out_3_off ();
}
//==================

//==================
static soft_timer ST_PROC_LED_1;
static soft_timer ST_PROC_LED_2;
static soft_timer ST_PROC_LED_3;

static u08 _proc_led_1;

void set_proc_led_1_run (void)
{
   led_1_off ();
   _proc_led_1 = 1;
}

void set_proc_led_1_off (void)
{
   led_1_off ();
   _proc_led_1 = 0;
}

u08 get_proc_led_1_state (void)
{
   return _proc_led_1;
}

void proc_led_1 (void)
{
   switch (_proc_led_1)
   {
      case 0:
         break; // Idle.

      case 1:
         #ifdef __ST_PERIOD__
         set_soft_timer (ST_PROC_LED_1, 0, 100);
         #else
         set_soft_timer (ST_PROC_LED_1, 0); // !!!!!!!!!!!!!!!!!!!!!!!!!!!
         #endif
         _proc_led_1 = 2;
         break;

      case 2:
         if (handle_soft_timer (ST_PROC_LED_1))
         {
            if (!check_led_1_state ())
               led_1_on ();
            else
               led_1_off ();

            #ifdef __ST_NO_PERIOD__
               set_soft_timer (ST_PROC_LED_1, 100); // !!!!!!!!!!!!!!!!!!!!!!!!!!!
            #endif
         }
         break;
   }
}
//==================

/* Макросы чтения входов от кнопок */
#define READ_IN1()      (GPIOB->IDR & (1<<2) )
#define READ_IN2()      (GPIOB->IDR & (1<<13))
#define READ_IN3()      (GPIOA->IDR & (1<<7) )

/* Макросы переключения светодиодов на противоп.сост. */
#define LED1_SWICHT()   GPIOA->ODR ^= 1<<5
#define LED2_SWICHT()   GPIOA->ODR ^= 1<<3
#define LED3_SWICHT()   GPIOB->ODR ^= 1<<1

/* Макросы выключения светодиодов */
#define LED1_OFF()      GPIOA->BSRRH = 1<<5
#define LED2_OFF()      GPIOA->BSRRH = 1<<3
#define LED3_OFF()      GPIOB->BSRRH = 1<<1

/* Периоды счета таймеров */
#define PERIOD_1   30000
#define PERIOD_2   60000
#define PERIOD_3   90000
#define PERIOD_BTN   10000

/** ----------
 */
int main(void)
{
   /* счетчики для таймеров мигания и опроса кнопок */
   uint32_t cnt1 = PERIOD_1, cnt2 = PERIOD_2, cnt3 = PERIOD_3;
   uint32_t cntbtn = PERIOD_BTN;

   /* переменные для разрешения мигания светодиодов */
   uint8_t en1 = 0, en2 = 0, en3 = 0;

   int8_t mode = 0;   // переменная режима работы
   uint8_t read_btn;   //переменная чтения входов
   uint8_t fsm_s = 0;   // переменная текущего номера состояния КА

   /* таблица переходов КА */
   const uint8_t fsm_ts[][8] = {
   /* s  | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 */
   /* s0*/{0,  1,  2,  0,  3,  0,  0,  0},

   /* s1*/{4,  1,  1,  1,  1,  1,  1,  1},
   /* s2*/{5,  2,  2,  2,  2,  2,  2,  2},
   /* s3*/{6,  3,  3,  3,  3,  3,  3,  3},

   /* s4*/{4,  7,  2,  4,  3,  4,  4,  4},
   /* s5*/{5,  1,  7,  5,  3,  5,  5,  5},
   /* s6*/{6,  1,  2,  6,  7,  6,  6,  6},

   /* s7*/{0,  7,  7,  7,  7,  7,  7,  7} };


   /* таблица выходного алфавита КА */
   const int8_t fsm_out[] =
   /* s0 | s1 | s2 | s3 | s4 | s5 | s6 | s7 */
     {-1,   1,   2,   3,  -1,  -1,  -1,  0};


   /*---- [Main Loop] ----------*/
   while(1)
   {
      /*---- Получение состояний кнопок ----*/
      if(cntbtn == 0)  // если цикл полностью отсчитан
      {
         read_btn = 0; // обнуление переменной

         /* чтение входов и формирование входного символа КА */
         if(READ_IN1() == 0) read_btn |= 1<<0;
         if(READ_IN2() == 0) read_btn |= 1<<1;
         if(READ_IN3() == 0) read_btn |= 1<<2;

         /* алгоритм переходов КА */
         fsm_s = fsm_ts[fsm_s][read_btn];
         mode = fsm_out[fsm_s];

         /*---- Выбор режима работы -----*/
         switch(mode){
         case 0:   // все выключено
            en1 = 0; en2 = 0; en3 = 0;
            break;
         case 1:   // разрешено мигание светика 1
            en1 = 1; en2 = 0; en3 = 0;
            break;
         case 2:   // разрешено мигание светика 2
            en1 = 0; en2 = 1; en3 = 0;
            break;
         case 3:   // разрешено мигание светика 3
            en1 = 0; en2 = 0; en3 = 1;
            break;
         default:
            break;
         }

         cntbtn = PERIOD_BTN; // перезапустить счетчик с нового цикла
      }


      /*---- Мигание светодиода 1 ----*/
      if(cnt1 == 0)   // если цикл полностью отсчитан
      {
         /* проверка, разрешено ли мигать */
         if(en1 == 1)
            LED1_SWICHT(); // переключить светодиод 1 на противоположное состояние
         else
            LED1_OFF();    // принудительно выключить светодиод

         cnt1 = PERIOD_1;   // перезапустить счетчик с нового цикла
      }

      /*---- Мигание светодиода 2 ----*/
      if(cnt2 == 0)   // если цикл полностью отсчитан
      {
         /* проверка, разрешено ли мигать */
         if(en2 == 1)
            LED2_SWICHT(); // переключить светодиод 2 на противоположное состояние
         else
            LED2_OFF();    // принудительно выключить светодиод

         cnt2 = PERIOD_2;   // перезапустить счетчик с нового цикла
      }

      /*---- Мигание светодиода 3 ----*/
      if(cnt3 == 0)   // если цикл полностью отсчитан
      {
         /* проверка, разрешено ли мигать */
         if(en3 == 1)
            LED3_SWICHT(); // переключить светодиод 3 на противоположное состояние
         else
            LED3_OFF();    // принудительно выключить светодиод

         cnt3 = PERIOD_3;   // перезапустить счетчик с нового цикла
      }

      /*---- Декременты счетных переменных ----*/
      cnt1--;
      cnt2--;
      cnt3--;
      cntbtn--;

   }/* while() */
}/*---- main() ----------*/

//MLMESSAGE(   ChangePrice      ,   "==CHANGE PRICE=="   ,   "PREISE VER"AUML"NDERN"   ,   "=CAMBIO PRECIO=="   ,   "==CHANGER PRIX=="   ,   "==ИЗМЕНИТЬ ЦЕНЫ="   )   //0
//MLMESSAGE(   Configuration   ,   "=CONFIGURATION=="   ,   "=KONFIGURATION=="      ,   ""               ,   ""               ,   "==КОНФИГУРАЦИЯ=="   )   //1
//MLMESSAGE(   Service         ,   "====SERVICE====="   ,   "====SERVICE====="      ,   "====SERVICIO===="   ,   "====SERVICE====="   ,   "=====СЕРВИС====="   )   //2
//MLMESSAGE(   ConfigCode      ,   "--Config.-code--"   ,   "--Konfig.-code--"      ,   "--Config.-code--"   ,   "--Config.-code--"   ,   "Код кофигурации"   )   //
MLMESSAGE(   Light         ,   "=====LIGHT======"   ,   ""                  ,   ""               ,   ""               ,   "===СВЕТ========"   )   //3
//MLMESSAGE(   SystemConfig   ,   "--System-config-"   ,   "-System-Konfig.-"      ,   "Config. sistema-"   ,   "config. Systфme-"   ,   "Система"         )   //4
//MLMESSAGE(   LineConfig      ,   "--Line-config---"    ,   "-Zeilen-Konfig.-"      ,   "Configurar lфnea"   ,   "-config. Ligne--"   ,   "Строки"          )   //5
//MLMESSAGE(   SignConfig      ,   "--Sign-config---"   ,   "Anzeigen-Konfig."      ,   "Configurar se al"   ,   "config.Afficheur"   ,   "Табло"            )   //6

//==================
typedef enum _proc_device
{
#define STATE(name, func) name,
#include "_proc_device.h"
#undef STATE

PROC_DEVICE_STATES,
} proc_device_t;


//==================
__flash FUNC proc_device_func [PROC_DEVICE_STATES] =
{
#define STATE(name, func) func,
#include "_proc_device.h"
#undef STATE
};
//----------
static proc_device_t _proc_device;
static u08 _proc_device_slave;
//----------
void proc_device (void)
{
//   proc_meter (); // Важно!!! Инициализация!

   proc_fsm_func (proc_device_func, _proc_device);
}
//==================

//************************************************************************
//************************ Главный автомат *******************************
//************************************************************************

//==================
STATE (PROC_DEVICE_INIT,             proc_device_init)
STATE (PROC_DEVICE_WEIGHT_MODE,      proc_device_weight_mode)
STATE (PROC_DEVICE_DOSER_IDLE_MODE,  proc_device_doser_idle_mode)
STATE (PROC_DEVICE_DOSER_MODE,       proc_device_doser_mode)
STATE (PROC_DEVICE_IDLE,             proc_device_idle)
STATE (PROC_DEVICE_EMERG_MODE,       proc_device_emerg_mode)
//==================