Статья по ссылке напомнила мне один недавний проект. Статья отличная, но в ней не хватает какого-нибудь практического примера. От этого остаются неясными границы применимости в принципе неплохих советов автора. В своем проекте я полностью следовал рекомендациям из упомянутой статьи и вот что вышло.

В задаче требовалось подключить рольставни к ПЛК. Принцип работы рольставней очень прост. Есть трубчатый мотор который наматывает на себя полотно ставней.
Мотор однофазный асинхронный. Направление вращение изменяется переключением фазы между двумя проводниками выходящими из мотора.
Обычно рольставни покупают сразу с модулем управления. Но тут был объект с десятками рольставней. И требовалось создать HMI для управления всеми из разных мест и разных устройств. Устройствами могли быть физические кнопки без фиксации, кнопки с фиксацией, экранные кнопки, всевозможные датчики и проч. Ничто не должно было стать препятствием для подключения чего угодно с целью группового управления рольставнями.

Стандартная схема подключения мотора рольставней.
Стандартная схема подключения мотора рольставней.

Схема подключения ПЛК к мотору рольставней.
Схема подключения ПЛК к мотору рольставней.

В качестве ПЛК была выбрана серия WAGO PFC200, а в качестве среды разработки пакет e!COCKPIT . Среда разработки от WAGO привлекательна тем что в нее легко интегрируются модели MATLAB. В MATLAB я и начал разработку, чтобы не изучать глубоко языки ПЛК и их библиотеки.

Как видно из схем выше управление мотором рольставней осуществляется двумя дискретными сигналами. Выходы сигналы концевиков у рольставней отсутствуют, концевики находятся внутри мотора и точки срабатывания регулируются встроенными в редуктор винтами с выведенными наружу шлицами под отвёртку. Все это на первый взгляд еще более упрощает управление.

И все же модель в MATLAB - Similink - Stateflow получилась вот такая:

Тестовая модель верхнего уровня
Тестовая модель верхнего уровня
Содержимое блока модели Blind_control
Содержимое блока модели Blind_control
Содержимое непосредственно рабочей модели управления рольставнями
Содержимое непосредственно рабочей модели управления рольставнями
Содержимое блока HMI_contro
Содержимое блока HMI_contro
Содержимое блока HMI_buttons
Содержимое блока HMI_buttons

Уточню, здесь представлена модель управления только одним мотором. Потом модель в ПЛК просто тиражируется для остальных моторов.
Модель получилась на удивление сложная. Но почему!?

Во-первых, здесь реализован логика которая могла бы быть реализована в HMI, но перенесена в ПЛК. На экране HMI предполагается иметь три кнопки: вверх, стоп, вниз.
Каждая кнопка должна иметь подсветку активности. При этом команды с HMI должны блокировать и отменять приказы локальных физических кнопок, и эта блокировка во избежание конфликтов должна действовать спустя некоторое время после окончания активности кнопок на HMI.

Во-вторых, предполагается подключение к ПЛК разных типов физических кнопок и работа по разным алгоритмам. Кнопки могут быть с фиксацией нажатия и без фиксации нажатия. Режим и тип кнопок задается сигналом Btn_mode. Он в свою очередь тоже может приходить от внешней кнопки.

В-третьих, управлять с помощью реле не так просто как кажется, если нужно думать о продлении ресурса реле. Нельзя просто сразу переключать направление движения или делать быстрые переключения пока мотор не остановился и пусковой конденсатор не разрядился. Иначе реле быстро обгорят и перестанут контачить или залипнут. Поэтому детально проработан автомат состояний Stateflow с именем Motor.

Реализованы следующие сценарии управления от кнопок:

Сценарий управления с двумя кнопками

  • Пока нажимается кнопка Btn_1 - движется вниз

  • Пока нажимается кнопка Btn_2 - движется вверх

  • Если ничего не нажато - остановка

Сценарий 1 управления одной кнопкой

  • 1.Нажали кнопку и отпустили - движется вверх

  • 2.Нажали кнопку - остановка

  • 3.Нажали кнопку - движется вниз

  • 4.Нажали кнопку - остановка

  • Переход к пункту 1

Сценарий 2 управления одной кнопкой

Если мотор остановлен:

  • Короткое нажатие вызывает подъем вверх,

  • Два коротких нажатия вызывают опускание

Если мотор работает:

  • Короткое нажатие вызывает остановку

После того как модель в Stateflow была протестирована и отлажена был сгенерирован исходник на языке Statement List (STL) для среды разработки e!COCKPIT.
И вот полученный код

Осторожно! Реально длинный код.
CASE ssMethodType OF
    SS_INITIALIZE: 
        DelayInput1_DSTATE := FALSE;
        DelayInput1_DSTATE_i := FALSE;
        DelayInput1_DSTATE_m := FALSE;
        is_active_Button := 0;
        is_Button := c_Blind_contro_IN_NO_ACTIVE;
        is_HMI_control := c_Blind_contro_IN_NO_ACTIVE;
        temporalCounter_i1(timerAction := 1, maxTime := 0);
        is_Local_control := c_Blind_contro_IN_NO_ACTIVE;
        was_Local_control := c_Blind_contro_IN_NO_ACTIVE;
        is_Mode01 := c_Blind_contro_IN_NO_ACTIVE;
        is_Mode1 := c_Blind_contro_IN_NO_ACTIVE;
        is_Released := c_Blind_contro_IN_NO_ACTIVE;
        was_Released := c_Blind_contro_IN_NO_ACTIVE;
        temporalCounter_i1(timerAction := 1, maxTime := 0);
        is_Mode2 := c_Blind_contro_IN_NO_ACTIVE;
        temporalCounter_i1(timerAction := 1, maxTime := 0);
        is_active_HMI_buttons := 0;
        is_HMI_buttons := c_Blind_contro_IN_NO_ACTIVE;
        is_active_Motor := 0;
        is_Motor := c_Blind_contro_IN_NO_ACTIVE;
        is_DOWN := c_Blind_contro_IN_NO_ACTIVE;
        temporalCounter_i2(timerAction := 1, maxTime := 0);
        is_UP := c_Blind_contro_IN_NO_ACTIVE;
        temporalCounter_i2(timerAction := 1, maxTime := 0);
        is_active_c3_Blind_control0 := 0;
        b_st := FALSE;
        HMI_Btn_UP_req := FALSE;
        HMI_Btn_Down_req := FALSE;
        HMI_Btn_Stop_req := FALSE;
        HMI_req := FALSE;
        UP_mode := FALSE;
        DOWN_mode := FALSE;
    SS_STEP: 
        rtb_FixPtRelationalOperator := BOOL_TO_DINT(HMI_Btn_Up) > BOOL_TO_DINT(DelayInput1_DSTATE);
        b_rtb_FixPtRelationalOperat := BOOL_TO_DINT(HMI_Btn_Down) > BOOL_TO_DINT(DelayInput1_DSTATE_i);
        c_rtb_FixPtRelationalOperat := BOOL_TO_DINT(HMI_Btn_Stop) > BOOL_TO_DINT(DelayInput1_DSTATE_m);

        IF is_active_c3_Blind_control0 = 0 THEN 
            is_active_c3_Blind_control0 := 1;
            is_active_Motor := 1;
            Relay_DIR := FALSE;
            is_Motor := Blind_control0_IN_IDLE;
            temporalCounter_i2(timerAction := 1, maxTime := 0);
            Relay_PWR := FALSE;
            is_active_Button := 1;
            is_Button := Blind_control0_IN_Begin;
            is_active_HMI_buttons := 1;
            is_HMI_buttons := Blind_control0_IN_Btns;
        ELSE 

            IF is_active_Motor <> 0 THEN 

                CASE is_Motor OF
                    Blind_control0_IN_DOWN: 

                        CASE is_DOWN OF
                            Blind_control0_IN_MOV_DOWN: 
                                ;
                                ;
                            c_Blind_control0_IN_MOV_DOW: 
                                temporalCounter_i2(timerAction := 2, maxTime := 100);

                                IF temporalCounter_i2.done THEN 
                                    is_DOWN := Blind_control0_IN_MOV_DOWN;
                                    Relay_PWR := TRUE;
                                END_IF;

                        END_CASE;

                    Blind_control0_IN_IDLE: 
                        temporalCounter_i2(timerAction := 2, maxTime := 100);

                        IF temporalCounter_i2.done THEN 

                            IF Relay_DIR THEN 
                                Relay_DIR := FALSE;
                                is_Motor := Blind_control0_IN_IDLE;
                                temporalCounter_i2(timerAction := 1, maxTime := 0);
                                Relay_PWR := FALSE;
                            END_IF;

                        END_IF;

                    Blind_control0_IN_PreIDLE: 
                        temporalCounter_i2(timerAction := 2, maxTime := 100);

                        IF temporalCounter_i2.done THEN 
                            is_Motor := Blind_control0_IN_IDLE;
                            temporalCounter_i2(timerAction := 1, maxTime := 0);
                            Relay_PWR := FALSE;
                        END_IF;

                    Blind_control0_IN_UP_j: 

                        CASE is_UP OF
                            Blind_control0_IN_MOV_UP: 
                                ;
                                ;
                            c_Blind_control0_IN_MOV_UP_: 
                                temporalCounter_i2(timerAction := 2, maxTime := 100);

                                IF temporalCounter_i2.done THEN 
                                    is_UP := Blind_control0_IN_MOV_UP;
                                    Relay_PWR := TRUE;
                                END_IF;

                        END_CASE;

                END_CASE;

            END_IF;


            IF is_active_Button <> 0 THEN 
                temp1 := FALSE;
                temp2 := FALSE;

                CASE is_Button OF
                    Blind_control0_IN_Begin: 

                        CASE Btn_mode OF
                            1: 
                                is_Button := c_Blind_control0_IN_Local_c;
                                is_Local_control := Blind_control0_IN_Mode1;
                                was_Local_control := Blind_control0_IN_Mode1;

                                IF is_active_Motor <> 0 THEN 

                                    CASE is_Motor OF
                                        Blind_control0_IN_DOWN: 

                                            CASE is_DOWN OF
                                                Blind_control0_IN_MOV_DOWN: 
                                                    is_DOWN := c_Blind_contro_IN_NO_ACTIVE;
                                                    DOWN_mode := FALSE;
                                                    is_Motor := Blind_control0_IN_PreIDLE;
                                                    temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                    Relay_PWR := FALSE;
                                                c_Blind_control0_IN_MOV_DOW: 
                                                    temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                    IF temporalCounter_i2.done THEN 
                                                        is_DOWN := Blind_control0_IN_MOV_DOWN;
                                                        Relay_PWR := TRUE;
                                                    ELSE 
                                                        is_DOWN := c_Blind_contro_IN_NO_ACTIVE;
                                                        DOWN_mode := FALSE;
                                                        is_Motor := Blind_control0_IN_PreIDLE;
                                                        temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                        Relay_PWR := FALSE;
                                                    END_IF;

                                            END_CASE;

                                        Blind_control0_IN_IDLE: 
                                            temporalCounter_i2(timerAction := 2, maxTime := 100);

                                            IF temporalCounter_i2.done THEN 

                                                IF Relay_DIR THEN 
                                                    Relay_DIR := FALSE;
                                                    is_Motor := Blind_control0_IN_IDLE;
                                                    temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                    Relay_PWR := FALSE;
                                                END_IF;

                                            END_IF;

                                        Blind_control0_IN_PreIDLE: 
                                            temporalCounter_i2(timerAction := 2, maxTime := 100);

                                            IF temporalCounter_i2.done THEN 
                                                is_Motor := Blind_control0_IN_IDLE;
                                                temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                Relay_PWR := FALSE;
                                            END_IF;

                                        Blind_control0_IN_UP_j: 

                                            CASE is_UP OF
                                                Blind_control0_IN_MOV_UP: 
                                                    is_UP := c_Blind_contro_IN_NO_ACTIVE;
                                                    UP_mode := FALSE;
                                                    is_Motor := Blind_control0_IN_PreIDLE;
                                                    temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                    Relay_PWR := FALSE;
                                                c_Blind_control0_IN_MOV_UP_: 
                                                    temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                    IF temporalCounter_i2.done THEN 
                                                        is_UP := Blind_control0_IN_MOV_UP;
                                                        Relay_PWR := TRUE;
                                                    ELSE 
                                                        is_UP := c_Blind_contro_IN_NO_ACTIVE;
                                                        UP_mode := FALSE;
                                                        is_Motor := Blind_control0_IN_PreIDLE;
                                                        temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                        Relay_PWR := FALSE;
                                                    END_IF;

                                            END_CASE;

                                    END_CASE;

                                END_IF;

                                is_Mode1 := Blind_control0_IN_Begin;
                            2: 
                                is_Button := c_Blind_control0_IN_Local_c;
                                is_Local_control := Blind_control0_IN_Mode2;
                                was_Local_control := Blind_control0_IN_Mode2;

                                IF is_active_Motor <> 0 THEN 

                                    CASE is_Motor OF
                                        Blind_control0_IN_DOWN: 

                                            CASE is_DOWN OF
                                                Blind_control0_IN_MOV_DOWN: 
                                                    is_DOWN := c_Blind_contro_IN_NO_ACTIVE;
                                                    DOWN_mode := FALSE;
                                                    is_Motor := Blind_control0_IN_PreIDLE;
                                                    temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                    Relay_PWR := FALSE;
                                                c_Blind_control0_IN_MOV_DOW: 
                                                    temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                    IF temporalCounter_i2.done THEN 
                                                        is_DOWN := Blind_control0_IN_MOV_DOWN;
                                                        Relay_PWR := TRUE;
                                                    ELSE 
                                                        is_DOWN := c_Blind_contro_IN_NO_ACTIVE;
                                                        DOWN_mode := FALSE;
                                                        is_Motor := Blind_control0_IN_PreIDLE;
                                                        temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                        Relay_PWR := FALSE;
                                                    END_IF;

                                            END_CASE;

                                        Blind_control0_IN_IDLE: 
                                            temporalCounter_i2(timerAction := 2, maxTime := 100);

                                            IF temporalCounter_i2.done THEN 

                                                IF Relay_DIR THEN 
                                                    Relay_DIR := FALSE;
                                                    is_Motor := Blind_control0_IN_IDLE;
                                                    temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                    Relay_PWR := FALSE;
                                                END_IF;

                                            END_IF;

                                        Blind_control0_IN_PreIDLE: 
                                            temporalCounter_i2(timerAction := 2, maxTime := 100);

                                            IF temporalCounter_i2.done THEN 
                                                is_Motor := Blind_control0_IN_IDLE;
                                                temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                Relay_PWR := FALSE;
                                            END_IF;

                                        Blind_control0_IN_UP_j: 

                                            CASE is_UP OF
                                                Blind_control0_IN_MOV_UP: 
                                                    is_UP := c_Blind_contro_IN_NO_ACTIVE;
                                                    UP_mode := FALSE;
                                                    is_Motor := Blind_control0_IN_PreIDLE;
                                                    temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                    Relay_PWR := FALSE;
                                                c_Blind_control0_IN_MOV_UP_: 
                                                    temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                    IF temporalCounter_i2.done THEN 
                                                        is_UP := Blind_control0_IN_MOV_UP;
                                                        Relay_PWR := TRUE;
                                                    ELSE 
                                                        is_UP := c_Blind_contro_IN_NO_ACTIVE;
                                                        UP_mode := FALSE;
                                                        is_Motor := Blind_control0_IN_PreIDLE;
                                                        temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                        Relay_PWR := FALSE;
                                                    END_IF;

                                            END_CASE;

                                    END_CASE;

                                END_IF;

                                is_Mode2 := Blind_control0_IN_Begin;
                                temporalCounter_i1(timerAction := 1, maxTime := 0);
                            0: 
                                is_Button := c_Blind_control0_IN_Local_c;
                                is_Local_control := Blind_control0_IN_Mode01;
                                was_Local_control := Blind_control0_IN_Mode01;

                                IF is_active_Motor <> 0 THEN 

                                    CASE is_Motor OF
                                        Blind_control0_IN_DOWN: 

                                            CASE is_DOWN OF
                                                Blind_control0_IN_MOV_DOWN: 
                                                    is_DOWN := c_Blind_contro_IN_NO_ACTIVE;
                                                    DOWN_mode := FALSE;
                                                    is_Motor := Blind_control0_IN_PreIDLE;
                                                    temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                    Relay_PWR := FALSE;
                                                c_Blind_control0_IN_MOV_DOW: 
                                                    temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                    IF temporalCounter_i2.done THEN 
                                                        is_DOWN := Blind_control0_IN_MOV_DOWN;
                                                        Relay_PWR := TRUE;
                                                    ELSE 
                                                        is_DOWN := c_Blind_contro_IN_NO_ACTIVE;
                                                        DOWN_mode := FALSE;
                                                        is_Motor := Blind_control0_IN_PreIDLE;
                                                        temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                        Relay_PWR := FALSE;
                                                    END_IF;

                                            END_CASE;

                                        Blind_control0_IN_IDLE: 
                                            temporalCounter_i2(timerAction := 2, maxTime := 100);

                                            IF temporalCounter_i2.done THEN 

                                                IF Relay_DIR THEN 
                                                    Relay_DIR := FALSE;
                                                    is_Motor := Blind_control0_IN_IDLE;
                                                    temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                    Relay_PWR := FALSE;
                                                END_IF;

                                            END_IF;

                                        Blind_control0_IN_PreIDLE: 
                                            temporalCounter_i2(timerAction := 2, maxTime := 100);

                                            IF temporalCounter_i2.done THEN 
                                                is_Motor := Blind_control0_IN_IDLE;
                                                temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                Relay_PWR := FALSE;
                                            END_IF;

                                        Blind_control0_IN_UP_j: 

                                            CASE is_UP OF
                                                Blind_control0_IN_MOV_UP: 
                                                    is_UP := c_Blind_contro_IN_NO_ACTIVE;
                                                    UP_mode := FALSE;
                                                    is_Motor := Blind_control0_IN_PreIDLE;
                                                    temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                    Relay_PWR := FALSE;
                                                c_Blind_control0_IN_MOV_UP_: 
                                                    temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                    IF temporalCounter_i2.done THEN 
                                                        is_UP := Blind_control0_IN_MOV_UP;
                                                        Relay_PWR := TRUE;
                                                    ELSE 
                                                        is_UP := c_Blind_contro_IN_NO_ACTIVE;
                                                        UP_mode := FALSE;
                                                        is_Motor := Blind_control0_IN_PreIDLE;
                                                        temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                        Relay_PWR := FALSE;
                                                    END_IF;

                                            END_CASE;

                                    END_CASE;

                                END_IF;

                                is_Mode01 := Blind_control0_IN_Begin;
                        END_CASE;

                    c_Blind_control0_IN_HMI_con: 

                        IF  NOT local_block THEN 

                            CASE is_HMI_control OF
                                c_Blind_control0_IN_Start_U: 
                                    HMI_Btn_UP_req := FALSE;
                                    HMI_Btn_Stop_req := FALSE;
                                    is_HMI_control := c_Blind_contro_IN_NO_ACTIVE;
                                b_Blind_control0_IN_Stop_DO: 
                                    HMI_Btn_Down_req := FALSE;
                                    HMI_Btn_Stop_req := FALSE;
                                    is_HMI_control := c_Blind_contro_IN_NO_ACTIVE;
                                ELSE
                                    is_HMI_control := c_Blind_contro_IN_NO_ACTIVE;
                            END_CASE;

                            HMI_req := FALSE;
                            is_Button := c_Blind_control0_IN_Local_c;

                            CASE was_Local_control OF
                                Blind_control0_IN_Mode01: 
                                    is_Local_control := Blind_control0_IN_Mode01;
                                    was_Local_control := Blind_control0_IN_Mode01;

                                    IF is_active_Motor <> 0 THEN 

                                        CASE is_Motor OF
                                            Blind_control0_IN_DOWN: 

                                                CASE is_DOWN OF
                                                    Blind_control0_IN_MOV_DOWN: 
                                                        is_DOWN := c_Blind_contro_IN_NO_ACTIVE;
                                                        DOWN_mode := FALSE;
                                                        is_Motor := Blind_control0_IN_PreIDLE;
                                                        temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                        Relay_PWR := FALSE;
                                                    c_Blind_control0_IN_MOV_DOW: 
                                                        temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                        IF temporalCounter_i2.done THEN 
                                                            is_DOWN := Blind_control0_IN_MOV_DOWN;
                                                            Relay_PWR := TRUE;
                                                        ELSE 
                                                            is_DOWN := c_Blind_contro_IN_NO_ACTIVE;
                                                            DOWN_mode := FALSE;
                                                            is_Motor := Blind_control0_IN_PreIDLE;
                                                            temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                            Relay_PWR := FALSE;
                                                        END_IF;

                                                END_CASE;

                                            Blind_control0_IN_IDLE: 
                                                temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                IF temporalCounter_i2.done THEN 

                                                    IF Relay_DIR THEN 
                                                        Relay_DIR := FALSE;
                                                        is_Motor := Blind_control0_IN_IDLE;
                                                        temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                        Relay_PWR := FALSE;
                                                    END_IF;

                                                END_IF;

                                            Blind_control0_IN_PreIDLE: 
                                                temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                IF temporalCounter_i2.done THEN 
                                                    is_Motor := Blind_control0_IN_IDLE;
                                                    temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                    Relay_PWR := FALSE;
                                                END_IF;

                                            Blind_control0_IN_UP_j: 

                                                CASE is_UP OF
                                                    Blind_control0_IN_MOV_UP: 
                                                        is_UP := c_Blind_contro_IN_NO_ACTIVE;
                                                        UP_mode := FALSE;
                                                        is_Motor := Blind_control0_IN_PreIDLE;
                                                        temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                        Relay_PWR := FALSE;
                                                    c_Blind_control0_IN_MOV_UP_: 
                                                        temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                        IF temporalCounter_i2.done THEN 
                                                            is_UP := Blind_control0_IN_MOV_UP;
                                                            Relay_PWR := TRUE;
                                                        ELSE 
                                                            is_UP := c_Blind_contro_IN_NO_ACTIVE;
                                                            UP_mode := FALSE;
                                                            is_Motor := Blind_control0_IN_PreIDLE;
                                                            temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                            Relay_PWR := FALSE;
                                                        END_IF;

                                                END_CASE;

                                        END_CASE;

                                    END_IF;

                                    is_Mode01 := Blind_control0_IN_Begin;
                                Blind_control0_IN_Mode1: 
                                    is_Local_control := Blind_control0_IN_Mode1;
                                    was_Local_control := Blind_control0_IN_Mode1;

                                    IF is_active_Motor <> 0 THEN 

                                        CASE is_Motor OF
                                            Blind_control0_IN_DOWN: 

                                                CASE is_DOWN OF
                                                    Blind_control0_IN_MOV_DOWN: 
                                                        is_DOWN := c_Blind_contro_IN_NO_ACTIVE;
                                                        DOWN_mode := FALSE;
                                                        is_Motor := Blind_control0_IN_PreIDLE;
                                                        temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                        Relay_PWR := FALSE;
                                                    c_Blind_control0_IN_MOV_DOW: 
                                                        temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                        IF temporalCounter_i2.done THEN 
                                                            is_DOWN := Blind_control0_IN_MOV_DOWN;
                                                            Relay_PWR := TRUE;
                                                        ELSE 
                                                            is_DOWN := c_Blind_contro_IN_NO_ACTIVE;
                                                            DOWN_mode := FALSE;
                                                            is_Motor := Blind_control0_IN_PreIDLE;
                                                            temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                            Relay_PWR := FALSE;
                                                        END_IF;

                                                END_CASE;

                                            Blind_control0_IN_IDLE: 
                                                temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                IF temporalCounter_i2.done THEN 

                                                    IF Relay_DIR THEN 
                                                        Relay_DIR := FALSE;
                                                        is_Motor := Blind_control0_IN_IDLE;
                                                        temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                        Relay_PWR := FALSE;
                                                    END_IF;

                                                END_IF;

                                            Blind_control0_IN_PreIDLE: 
                                                temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                IF temporalCounter_i2.done THEN 
                                                    is_Motor := Blind_control0_IN_IDLE;
                                                    temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                    Relay_PWR := FALSE;
                                                END_IF;

                                            Blind_control0_IN_UP_j: 

                                                CASE is_UP OF
                                                    Blind_control0_IN_MOV_UP: 
                                                        is_UP := c_Blind_contro_IN_NO_ACTIVE;
                                                        UP_mode := FALSE;
                                                        is_Motor := Blind_control0_IN_PreIDLE;
                                                        temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                        Relay_PWR := FALSE;
                                                    c_Blind_control0_IN_MOV_UP_: 
                                                        temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                        IF temporalCounter_i2.done THEN 
                                                            is_UP := Blind_control0_IN_MOV_UP;
                                                            Relay_PWR := TRUE;
                                                        ELSE 
                                                            is_UP := c_Blind_contro_IN_NO_ACTIVE;
                                                            UP_mode := FALSE;
                                                            is_Motor := Blind_control0_IN_PreIDLE;
                                                            temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                            Relay_PWR := FALSE;
                                                        END_IF;

                                                END_CASE;

                                        END_CASE;

                                    END_IF;

                                    is_Mode1 := Blind_control0_IN_Begin;
                                Blind_control0_IN_Mode2: 
                                    is_Local_control := Blind_control0_IN_Mode2;
                                    was_Local_control := Blind_control0_IN_Mode2;

                                    IF is_active_Motor <> 0 THEN 

                                        CASE is_Motor OF
                                            Blind_control0_IN_DOWN: 

                                                CASE is_DOWN OF
                                                    Blind_control0_IN_MOV_DOWN: 
                                                        is_DOWN := c_Blind_contro_IN_NO_ACTIVE;
                                                        DOWN_mode := FALSE;
                                                        is_Motor := Blind_control0_IN_PreIDLE;
                                                        temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                        Relay_PWR := FALSE;
                                                    c_Blind_control0_IN_MOV_DOW: 
                                                        temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                        IF temporalCounter_i2.done THEN 
                                                            is_DOWN := Blind_control0_IN_MOV_DOWN;
                                                            Relay_PWR := TRUE;
                                                        ELSE 
                                                            is_DOWN := c_Blind_contro_IN_NO_ACTIVE;
                                                            DOWN_mode := FALSE;
                                                            is_Motor := Blind_control0_IN_PreIDLE;
                                                            temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                            Relay_PWR := FALSE;
                                                        END_IF;

                                                END_CASE;

                                            Blind_control0_IN_IDLE: 
                                                temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                IF temporalCounter_i2.done THEN 

                                                    IF Relay_DIR THEN 
                                                        Relay_DIR := FALSE;
                                                        is_Motor := Blind_control0_IN_IDLE;
                                                        temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                        Relay_PWR := FALSE;
                                                    END_IF;

                                                END_IF;

                                            Blind_control0_IN_PreIDLE: 
                                                temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                IF temporalCounter_i2.done THEN 
                                                    is_Motor := Blind_control0_IN_IDLE;
                                                    temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                    Relay_PWR := FALSE;
                                                END_IF;

                                            Blind_control0_IN_UP_j: 

                                                CASE is_UP OF
                                                    Blind_control0_IN_MOV_UP: 
                                                        is_UP := c_Blind_contro_IN_NO_ACTIVE;
                                                        UP_mode := FALSE;
                                                        is_Motor := Blind_control0_IN_PreIDLE;
                                                        temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                        Relay_PWR := FALSE;
                                                    c_Blind_control0_IN_MOV_UP_: 
                                                        temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                        IF temporalCounter_i2.done THEN 
                                                            is_UP := Blind_control0_IN_MOV_UP;
                                                            Relay_PWR := TRUE;
                                                        ELSE 
                                                            is_UP := c_Blind_contro_IN_NO_ACTIVE;
                                                            UP_mode := FALSE;
                                                            is_Motor := Blind_control0_IN_PreIDLE;
                                                            temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                            Relay_PWR := FALSE;
                                                        END_IF;

                                                END_CASE;

                                        END_CASE;

                                    END_IF;

                                    is_Mode2 := Blind_control0_IN_Begin;
                                    temporalCounter_i1(timerAction := 1, maxTime := 0);
                            END_CASE;

                        ELSE 

                            CASE is_HMI_control OF
                                Blind_control0_IN_DoStop: 
                                    temporalCounter_i1(timerAction := 2, maxTime := 200);

                                    IF temporalCounter_i1.done THEN 
                                        is_HMI_control := Blind_control0_IN_IDLE;
                                        temporalCounter_i1(timerAction := 1, maxTime := 0);
                                    END_IF;

                                Blind_control0_IN_IDLE: 
                                    temporalCounter_i1(timerAction := 2, maxTime := 1000);

                                    IF temporalCounter_i1.done THEN 
                                        local_block := FALSE;
                                        is_HMI_control := Blind_control0_IN_IDLE;
                                        temporalCounter_i1(timerAction := 1, maxTime := 0);
                                    ELSIF HMI_Btn_UP_req THEN 
                                        is_HMI_control := c_Blind_control0_IN_Start_U;
                                        temporalCounter_i1(timerAction := 1, maxTime := 0);

                                        IF is_active_Motor <> 0 THEN 

                                            CASE is_Motor OF
                                                Blind_control0_IN_DOWN: 

                                                    CASE is_DOWN OF
                                                        Blind_control0_IN_MOV_DOWN: 
                                                            ;
                                                            ;
                                                        c_Blind_control0_IN_MOV_DOW: 
                                                            temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                            IF temporalCounter_i2.done THEN 
                                                                is_DOWN := Blind_control0_IN_MOV_DOWN;
                                                                Relay_PWR := TRUE;
                                                            END_IF;

                                                    END_CASE;

                                                Blind_control0_IN_IDLE: 
                                                    is_Motor := Blind_control0_IN_UP_j;
                                                    UP_mode := TRUE;
                                                    is_UP := c_Blind_control0_IN_MOV_UP_;
                                                    temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                    Relay_DIR := TRUE;
                                                Blind_control0_IN_PreIDLE: 
                                                    temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                    IF temporalCounter_i2.done THEN 
                                                        is_Motor := Blind_control0_IN_IDLE;
                                                        temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                        Relay_PWR := FALSE;
                                                    END_IF;

                                                Blind_control0_IN_UP_j: 

                                                    CASE is_UP OF
                                                        Blind_control0_IN_MOV_UP: 
                                                            ;
                                                            ;
                                                        c_Blind_control0_IN_MOV_UP_: 
                                                            temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                            IF temporalCounter_i2.done THEN 
                                                                is_UP := Blind_control0_IN_MOV_UP;
                                                                Relay_PWR := TRUE;
                                                            END_IF;

                                                    END_CASE;

                                            END_CASE;

                                        END_IF;

                                    ELSIF HMI_Btn_Down_req THEN 
                                        is_HMI_control := b_Blind_control0_IN_Stop_DO;
                                        temporalCounter_i1(timerAction := 1, maxTime := 0);

                                        IF is_active_Motor <> 0 THEN 

                                            CASE is_Motor OF
                                                Blind_control0_IN_DOWN: 

                                                    CASE is_DOWN OF
                                                        Blind_control0_IN_MOV_DOWN: 
                                                            ;
                                                            ;
                                                        c_Blind_control0_IN_MOV_DOW: 
                                                            temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                            IF temporalCounter_i2.done THEN 
                                                                is_DOWN := Blind_control0_IN_MOV_DOWN;
                                                                Relay_PWR := TRUE;
                                                            END_IF;

                                                    END_CASE;

                                                Blind_control0_IN_IDLE: 
                                                    is_Motor := Blind_control0_IN_DOWN;
                                                    DOWN_mode := TRUE;
                                                    is_DOWN := c_Blind_control0_IN_MOV_DOW;
                                                    temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                    Relay_DIR := FALSE;
                                                Blind_control0_IN_PreIDLE: 
                                                    temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                    IF temporalCounter_i2.done THEN 
                                                        is_Motor := Blind_control0_IN_IDLE;
                                                        temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                        Relay_PWR := FALSE;
                                                    END_IF;

                                                Blind_control0_IN_UP_j: 

                                                    CASE is_UP OF
                                                        Blind_control0_IN_MOV_UP: 
                                                            ;
                                                            ;
                                                        c_Blind_control0_IN_MOV_UP_: 
                                                            temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                            IF temporalCounter_i2.done THEN 
                                                                is_UP := Blind_control0_IN_MOV_UP;
                                                                Relay_PWR := TRUE;
                                                            END_IF;

                                                    END_CASE;

                                            END_CASE;

                                        END_IF;

                                    END_IF;

                                c_Blind_control0_IN_Start_U: 

                                    IF HMI_Btn_Stop_req OR HMI_Btn_Down_req THEN 
                                        temp1 := TRUE;
                                    ELSE 
                                        temporalCounter_i1(timerAction := 2, maxTime := TRUNC(REAL_TO_LREAL(Mot_timeout) * 1000.0));

                                        IF temporalCounter_i1.done THEN 
                                            temp1 := TRUE;
                                        END_IF;

                                    END_IF;

                                b_Blind_control0_IN_Stop_DO: 

                                    IF HMI_Btn_Stop_req OR HMI_Btn_UP_req THEN 
                                        temp2 := TRUE;
                                    ELSE 
                                        temporalCounter_i1(timerAction := 2, maxTime := TRUNC(REAL_TO_LREAL(Mot_timeout) * 1000.0));

                                        IF temporalCounter_i1.done THEN 
                                            temp2 := TRUE;
                                        END_IF;

                                    END_IF;

                            END_CASE;

                        END_IF;

                    c_Blind_control0_IN_Local_c: 
                        tmp :=  NOT Btn_1;

                        IF HMI_req AND tmp THEN 

                            CASE is_Local_control OF
                                Blind_control0_IN_Mode01: 

                                    CASE is_Mode01 OF
                                        c_Blind_control0_IN_Pressed: 

                                            IF is_active_Motor <> 0 THEN 

                                                CASE is_Motor OF
                                                    Blind_control0_IN_DOWN: 

                                                        CASE is_DOWN OF
                                                            Blind_control0_IN_MOV_DOWN: 
                                                                is_DOWN := c_Blind_contro_IN_NO_ACTIVE;
                                                                DOWN_mode := FALSE;
                                                                is_Motor := Blind_control0_IN_PreIDLE;
                                                                temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                Relay_PWR := FALSE;
                                                            c_Blind_control0_IN_MOV_DOW: 
                                                                temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                IF temporalCounter_i2.done THEN 
                                                                    is_DOWN := Blind_control0_IN_MOV_DOWN;
                                                                    Relay_PWR := TRUE;
                                                                ELSE 
                                                                    is_DOWN := c_Blind_contro_IN_NO_ACTIVE;
                                                                    DOWN_mode := FALSE;
                                                                    is_Motor := Blind_control0_IN_PreIDLE;
                                                                    temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                    Relay_PWR := FALSE;
                                                                END_IF;

                                                        END_CASE;

                                                    Blind_control0_IN_IDLE: 
                                                        temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                        IF temporalCounter_i2.done THEN 

                                                            IF Relay_DIR THEN 
                                                                Relay_DIR := FALSE;
                                                                is_Motor := Blind_control0_IN_IDLE;
                                                                temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                Relay_PWR := FALSE;
                                                            END_IF;

                                                        END_IF;

                                                    Blind_control0_IN_PreIDLE: 
                                                        temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                        IF temporalCounter_i2.done THEN 
                                                            is_Motor := Blind_control0_IN_IDLE;
                                                            temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                            Relay_PWR := FALSE;
                                                        END_IF;

                                                    Blind_control0_IN_UP_j: 

                                                        CASE is_UP OF
                                                            Blind_control0_IN_MOV_UP: 
                                                                is_UP := c_Blind_contro_IN_NO_ACTIVE;
                                                                UP_mode := FALSE;
                                                                is_Motor := Blind_control0_IN_PreIDLE;
                                                                temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                Relay_PWR := FALSE;
                                                            c_Blind_control0_IN_MOV_UP_: 
                                                                temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                IF temporalCounter_i2.done THEN 
                                                                    is_UP := Blind_control0_IN_MOV_UP;
                                                                    Relay_PWR := TRUE;
                                                                ELSE 
                                                                    is_UP := c_Blind_contro_IN_NO_ACTIVE;
                                                                    UP_mode := FALSE;
                                                                    is_Motor := Blind_control0_IN_PreIDLE;
                                                                    temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                    Relay_PWR := FALSE;
                                                                END_IF;

                                                        END_CASE;

                                                END_CASE;

                                            END_IF;

                                            is_Mode01 := c_Blind_contro_IN_NO_ACTIVE;
                                        d_Blind_control0_IN_Pressed: 

                                            IF is_active_Motor <> 0 THEN 

                                                CASE is_Motor OF
                                                    Blind_control0_IN_DOWN: 

                                                        CASE is_DOWN OF
                                                            Blind_control0_IN_MOV_DOWN: 
                                                                is_DOWN := c_Blind_contro_IN_NO_ACTIVE;
                                                                DOWN_mode := FALSE;
                                                                is_Motor := Blind_control0_IN_PreIDLE;
                                                                temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                Relay_PWR := FALSE;
                                                            c_Blind_control0_IN_MOV_DOW: 
                                                                temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                IF temporalCounter_i2.done THEN 
                                                                    is_DOWN := Blind_control0_IN_MOV_DOWN;
                                                                    Relay_PWR := TRUE;
                                                                ELSE 
                                                                    is_DOWN := c_Blind_contro_IN_NO_ACTIVE;
                                                                    DOWN_mode := FALSE;
                                                                    is_Motor := Blind_control0_IN_PreIDLE;
                                                                    temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                    Relay_PWR := FALSE;
                                                                END_IF;

                                                        END_CASE;

                                                    Blind_control0_IN_IDLE: 
                                                        temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                        IF temporalCounter_i2.done THEN 

                                                            IF Relay_DIR THEN 
                                                                Relay_DIR := FALSE;
                                                                is_Motor := Blind_control0_IN_IDLE;
                                                                temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                Relay_PWR := FALSE;
                                                            END_IF;

                                                        END_IF;

                                                    Blind_control0_IN_PreIDLE: 
                                                        temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                        IF temporalCounter_i2.done THEN 
                                                            is_Motor := Blind_control0_IN_IDLE;
                                                            temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                            Relay_PWR := FALSE;
                                                        END_IF;

                                                    Blind_control0_IN_UP_j: 

                                                        CASE is_UP OF
                                                            Blind_control0_IN_MOV_UP: 
                                                                is_UP := c_Blind_contro_IN_NO_ACTIVE;
                                                                UP_mode := FALSE;
                                                                is_Motor := Blind_control0_IN_PreIDLE;
                                                                temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                Relay_PWR := FALSE;
                                                            c_Blind_control0_IN_MOV_UP_: 
                                                                temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                IF temporalCounter_i2.done THEN 
                                                                    is_UP := Blind_control0_IN_MOV_UP;
                                                                    Relay_PWR := TRUE;
                                                                ELSE 
                                                                    is_UP := c_Blind_contro_IN_NO_ACTIVE;
                                                                    UP_mode := FALSE;
                                                                    is_Motor := Blind_control0_IN_PreIDLE;
                                                                    temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                    Relay_PWR := FALSE;
                                                                END_IF;

                                                        END_CASE;

                                                END_CASE;

                                            END_IF;

                                            is_Mode01 := c_Blind_contro_IN_NO_ACTIVE;
                                        ELSE
                                            is_Mode01 := c_Blind_contro_IN_NO_ACTIVE;
                                    END_CASE;

                                    is_Local_control := c_Blind_contro_IN_NO_ACTIVE;
                                ELSE
                                    is_Released := c_Blind_contro_IN_NO_ACTIVE;
                                    is_Mode1 := c_Blind_contro_IN_NO_ACTIVE;
                                    is_Mode2 := c_Blind_contro_IN_NO_ACTIVE;
                                    is_Local_control := c_Blind_contro_IN_NO_ACTIVE;
                            END_CASE;

                            is_Button := c_Blind_control0_IN_HMI_con;
                            is_HMI_control := Blind_control0_IN_DoStop;
                            temporalCounter_i1(timerAction := 1, maxTime := 0);

                            IF is_active_Motor <> 0 THEN 

                                CASE is_Motor OF
                                    Blind_control0_IN_DOWN: 

                                        CASE is_DOWN OF
                                            Blind_control0_IN_MOV_DOWN: 
                                                is_DOWN := c_Blind_contro_IN_NO_ACTIVE;
                                                DOWN_mode := FALSE;
                                                is_Motor := Blind_control0_IN_PreIDLE;
                                                temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                Relay_PWR := FALSE;
                                            c_Blind_control0_IN_MOV_DOW: 
                                                temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                IF temporalCounter_i2.done THEN 
                                                    is_DOWN := Blind_control0_IN_MOV_DOWN;
                                                    Relay_PWR := TRUE;
                                                ELSE 
                                                    is_DOWN := c_Blind_contro_IN_NO_ACTIVE;
                                                    DOWN_mode := FALSE;
                                                    is_Motor := Blind_control0_IN_PreIDLE;
                                                    temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                    Relay_PWR := FALSE;
                                                END_IF;

                                        END_CASE;

                                    Blind_control0_IN_IDLE: 
                                        temporalCounter_i2(timerAction := 2, maxTime := 100);

                                        IF temporalCounter_i2.done THEN 

                                            IF Relay_DIR THEN 
                                                Relay_DIR := FALSE;
                                                is_Motor := Blind_control0_IN_IDLE;
                                                temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                Relay_PWR := FALSE;
                                            END_IF;

                                        END_IF;

                                    Blind_control0_IN_PreIDLE: 
                                        temporalCounter_i2(timerAction := 2, maxTime := 100);

                                        IF temporalCounter_i2.done THEN 
                                            is_Motor := Blind_control0_IN_IDLE;
                                            temporalCounter_i2(timerAction := 1, maxTime := 0);
                                            Relay_PWR := FALSE;
                                        END_IF;

                                    Blind_control0_IN_UP_j: 

                                        CASE is_UP OF
                                            Blind_control0_IN_MOV_UP: 
                                                is_UP := c_Blind_contro_IN_NO_ACTIVE;
                                                UP_mode := FALSE;
                                                is_Motor := Blind_control0_IN_PreIDLE;
                                                temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                Relay_PWR := FALSE;
                                            c_Blind_control0_IN_MOV_UP_: 
                                                temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                IF temporalCounter_i2.done THEN 
                                                    is_UP := Blind_control0_IN_MOV_UP;
                                                    Relay_PWR := TRUE;
                                                ELSE 
                                                    is_UP := c_Blind_contro_IN_NO_ACTIVE;
                                                    UP_mode := FALSE;
                                                    is_Motor := Blind_control0_IN_PreIDLE;
                                                    temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                    Relay_PWR := FALSE;
                                                END_IF;

                                        END_CASE;

                                END_CASE;

                            END_IF;

                        ELSE 

                            CASE is_Local_control OF
                                Blind_control0_IN_Mode01: 

                                    IF Btn_mode <> 0 THEN 

                                        CASE is_Mode01 OF
                                            c_Blind_control0_IN_Pressed: 

                                                IF is_active_Motor <> 0 THEN 

                                                    CASE is_Motor OF
                                                        Blind_control0_IN_DOWN: 

                                                            CASE is_DOWN OF
                                                                Blind_control0_IN_MOV_DOWN: 
                                                                    is_DOWN := c_Blind_contro_IN_NO_ACTIVE;
                                                                    DOWN_mode := FALSE;
                                                                    is_Motor := Blind_control0_IN_PreIDLE;
                                                                    temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                    Relay_PWR := FALSE;
                                                                c_Blind_control0_IN_MOV_DOW: 
                                                                    temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                    IF temporalCounter_i2.done THEN 
                                                                        is_DOWN := Blind_control0_IN_MOV_DOWN;
                                                                        Relay_PWR := TRUE;
                                                                    ELSE 
                                                                        is_DOWN := c_Blind_contro_IN_NO_ACTIVE;
                                                                        DOWN_mode := FALSE;
                                                                        is_Motor := Blind_control0_IN_PreIDLE;
                                                                        temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                        Relay_PWR := FALSE;
                                                                    END_IF;

                                                            END_CASE;

                                                        Blind_control0_IN_IDLE: 
                                                            temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                            IF temporalCounter_i2.done THEN 

                                                                IF Relay_DIR THEN 
                                                                    Relay_DIR := FALSE;
                                                                    is_Motor := Blind_control0_IN_IDLE;
                                                                    temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                    Relay_PWR := FALSE;
                                                                END_IF;

                                                            END_IF;

                                                        Blind_control0_IN_PreIDLE: 
                                                            temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                            IF temporalCounter_i2.done THEN 
                                                                is_Motor := Blind_control0_IN_IDLE;
                                                                temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                Relay_PWR := FALSE;
                                                            END_IF;

                                                        Blind_control0_IN_UP_j: 

                                                            CASE is_UP OF
                                                                Blind_control0_IN_MOV_UP: 
                                                                    is_UP := c_Blind_contro_IN_NO_ACTIVE;
                                                                    UP_mode := FALSE;
                                                                    is_Motor := Blind_control0_IN_PreIDLE;
                                                                    temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                    Relay_PWR := FALSE;
                                                                c_Blind_control0_IN_MOV_UP_: 
                                                                    temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                    IF temporalCounter_i2.done THEN 
                                                                        is_UP := Blind_control0_IN_MOV_UP;
                                                                        Relay_PWR := TRUE;
                                                                    ELSE 
                                                                        is_UP := c_Blind_contro_IN_NO_ACTIVE;
                                                                        UP_mode := FALSE;
                                                                        is_Motor := Blind_control0_IN_PreIDLE;
                                                                        temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                        Relay_PWR := FALSE;
                                                                    END_IF;

                                                            END_CASE;

                                                    END_CASE;

                                                END_IF;

                                                is_Mode01 := c_Blind_contro_IN_NO_ACTIVE;
                                            d_Blind_control0_IN_Pressed: 

                                                IF is_active_Motor <> 0 THEN 

                                                    CASE is_Motor OF
                                                        Blind_control0_IN_DOWN: 

                                                            CASE is_DOWN OF
                                                                Blind_control0_IN_MOV_DOWN: 
                                                                    is_DOWN := c_Blind_contro_IN_NO_ACTIVE;
                                                                    DOWN_mode := FALSE;
                                                                    is_Motor := Blind_control0_IN_PreIDLE;
                                                                    temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                    Relay_PWR := FALSE;
                                                                c_Blind_control0_IN_MOV_DOW: 
                                                                    temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                    IF temporalCounter_i2.done THEN 
                                                                        is_DOWN := Blind_control0_IN_MOV_DOWN;
                                                                        Relay_PWR := TRUE;
                                                                    ELSE 
                                                                        is_DOWN := c_Blind_contro_IN_NO_ACTIVE;
                                                                        DOWN_mode := FALSE;
                                                                        is_Motor := Blind_control0_IN_PreIDLE;
                                                                        temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                        Relay_PWR := FALSE;
                                                                    END_IF;

                                                            END_CASE;

                                                        Blind_control0_IN_IDLE: 
                                                            temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                            IF temporalCounter_i2.done THEN 

                                                                IF Relay_DIR THEN 
                                                                    Relay_DIR := FALSE;
                                                                    is_Motor := Blind_control0_IN_IDLE;
                                                                    temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                    Relay_PWR := FALSE;
                                                                END_IF;

                                                            END_IF;

                                                        Blind_control0_IN_PreIDLE: 
                                                            temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                            IF temporalCounter_i2.done THEN 
                                                                is_Motor := Blind_control0_IN_IDLE;
                                                                temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                Relay_PWR := FALSE;
                                                            END_IF;

                                                        Blind_control0_IN_UP_j: 

                                                            CASE is_UP OF
                                                                Blind_control0_IN_MOV_UP: 
                                                                    is_UP := c_Blind_contro_IN_NO_ACTIVE;
                                                                    UP_mode := FALSE;
                                                                    is_Motor := Blind_control0_IN_PreIDLE;
                                                                    temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                    Relay_PWR := FALSE;
                                                                c_Blind_control0_IN_MOV_UP_: 
                                                                    temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                    IF temporalCounter_i2.done THEN 
                                                                        is_UP := Blind_control0_IN_MOV_UP;
                                                                        Relay_PWR := TRUE;
                                                                    ELSE 
                                                                        is_UP := c_Blind_contro_IN_NO_ACTIVE;
                                                                        UP_mode := FALSE;
                                                                        is_Motor := Blind_control0_IN_PreIDLE;
                                                                        temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                        Relay_PWR := FALSE;
                                                                    END_IF;

                                                            END_CASE;

                                                    END_CASE;

                                                END_IF;

                                                is_Mode01 := c_Blind_contro_IN_NO_ACTIVE;
                                            ELSE
                                                is_Mode01 := c_Blind_contro_IN_NO_ACTIVE;
                                        END_CASE;

                                        is_Local_control := c_Blind_contro_IN_NO_ACTIVE;
                                        is_Button := Blind_control0_IN_Begin;
                                    ELSE 

                                        CASE is_Mode01 OF
                                            Blind_control0_IN_Begin: 

                                                IF Btn_1 THEN 
                                                    is_Mode01 := c_Blind_control0_IN_Pressed;

                                                    IF is_active_Motor <> 0 THEN 

                                                        CASE is_Motor OF
                                                            Blind_control0_IN_DOWN: 

                                                                CASE is_DOWN OF
                                                                    Blind_control0_IN_MOV_DOWN: 
                                                                        ;
                                                                        ;
                                                                    c_Blind_control0_IN_MOV_DOW: 
                                                                        temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                        IF temporalCounter_i2.done THEN 
                                                                            is_DOWN := Blind_control0_IN_MOV_DOWN;
                                                                            Relay_PWR := TRUE;
                                                                        END_IF;

                                                                END_CASE;

                                                            Blind_control0_IN_IDLE: 
                                                                is_Motor := Blind_control0_IN_DOWN;
                                                                DOWN_mode := TRUE;
                                                                is_DOWN := c_Blind_control0_IN_MOV_DOW;
                                                                temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                Relay_DIR := FALSE;
                                                            Blind_control0_IN_PreIDLE: 
                                                                temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                IF temporalCounter_i2.done THEN 
                                                                    is_Motor := Blind_control0_IN_IDLE;
                                                                    temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                    Relay_PWR := FALSE;
                                                                END_IF;

                                                            Blind_control0_IN_UP_j: 

                                                                CASE is_UP OF
                                                                    Blind_control0_IN_MOV_UP: 
                                                                        ;
                                                                        ;
                                                                    c_Blind_control0_IN_MOV_UP_: 
                                                                        temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                        IF temporalCounter_i2.done THEN 
                                                                            is_UP := Blind_control0_IN_MOV_UP;
                                                                            Relay_PWR := TRUE;
                                                                        END_IF;

                                                                END_CASE;

                                                        END_CASE;

                                                    END_IF;

                                                ELSIF Btn_2 THEN 
                                                    is_Mode01 := d_Blind_control0_IN_Pressed;

                                                    IF is_active_Motor <> 0 THEN 

                                                        CASE is_Motor OF
                                                            Blind_control0_IN_DOWN: 

                                                                CASE is_DOWN OF
                                                                    Blind_control0_IN_MOV_DOWN: 
                                                                        ;
                                                                        ;
                                                                    c_Blind_control0_IN_MOV_DOW: 
                                                                        temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                        IF temporalCounter_i2.done THEN 
                                                                            is_DOWN := Blind_control0_IN_MOV_DOWN;
                                                                            Relay_PWR := TRUE;
                                                                        END_IF;

                                                                END_CASE;

                                                            Blind_control0_IN_IDLE: 
                                                                is_Motor := Blind_control0_IN_UP_j;
                                                                UP_mode := TRUE;
                                                                is_UP := c_Blind_control0_IN_MOV_UP_;
                                                                temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                Relay_DIR := TRUE;
                                                            Blind_control0_IN_PreIDLE: 
                                                                temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                IF temporalCounter_i2.done THEN 
                                                                    is_Motor := Blind_control0_IN_IDLE;
                                                                    temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                    Relay_PWR := FALSE;
                                                                END_IF;

                                                            Blind_control0_IN_UP_j: 

                                                                CASE is_UP OF
                                                                    Blind_control0_IN_MOV_UP: 
                                                                        ;
                                                                        ;
                                                                    c_Blind_control0_IN_MOV_UP_: 
                                                                        temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                        IF temporalCounter_i2.done THEN 
                                                                            is_UP := Blind_control0_IN_MOV_UP;
                                                                            Relay_PWR := TRUE;
                                                                        END_IF;

                                                                END_CASE;

                                                        END_CASE;

                                                    END_IF;

                                                ELSE 
                                                    is_Mode01 := Blind_control0_IN_Released;
                                                END_IF;

                                            c_Blind_control0_IN_Pressed: 

                                                IF  NOT Btn_1 THEN 

                                                    IF is_active_Motor <> 0 THEN 

                                                        CASE is_Motor OF
                                                            Blind_control0_IN_DOWN: 

                                                                CASE is_DOWN OF
                                                                    Blind_control0_IN_MOV_DOWN: 
                                                                        is_DOWN := c_Blind_contro_IN_NO_ACTIVE;
                                                                        DOWN_mode := FALSE;
                                                                        is_Motor := Blind_control0_IN_PreIDLE;
                                                                        temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                        Relay_PWR := FALSE;
                                                                    c_Blind_control0_IN_MOV_DOW: 
                                                                        temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                        IF temporalCounter_i2.done THEN 
                                                                            is_DOWN := Blind_control0_IN_MOV_DOWN;
                                                                            Relay_PWR := TRUE;
                                                                        ELSE 
                                                                            is_DOWN := c_Blind_contro_IN_NO_ACTIVE;
                                                                            DOWN_mode := FALSE;
                                                                            is_Motor := Blind_control0_IN_PreIDLE;
                                                                            temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                            Relay_PWR := FALSE;
                                                                        END_IF;

                                                                END_CASE;

                                                            Blind_control0_IN_IDLE: 
                                                                temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                IF temporalCounter_i2.done THEN 

                                                                    IF Relay_DIR THEN 
                                                                        Relay_DIR := FALSE;
                                                                        is_Motor := Blind_control0_IN_IDLE;
                                                                        temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                        Relay_PWR := FALSE;
                                                                    END_IF;

                                                                END_IF;

                                                            Blind_control0_IN_PreIDLE: 
                                                                temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                IF temporalCounter_i2.done THEN 
                                                                    is_Motor := Blind_control0_IN_IDLE;
                                                                    temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                    Relay_PWR := FALSE;
                                                                END_IF;

                                                            Blind_control0_IN_UP_j: 

                                                                CASE is_UP OF
                                                                    Blind_control0_IN_MOV_UP: 
                                                                        is_UP := c_Blind_contro_IN_NO_ACTIVE;
                                                                        UP_mode := FALSE;
                                                                        is_Motor := Blind_control0_IN_PreIDLE;
                                                                        temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                        Relay_PWR := FALSE;
                                                                    c_Blind_control0_IN_MOV_UP_: 
                                                                        temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                        IF temporalCounter_i2.done THEN 
                                                                            is_UP := Blind_control0_IN_MOV_UP;
                                                                            Relay_PWR := TRUE;
                                                                        ELSE 
                                                                            is_UP := c_Blind_contro_IN_NO_ACTIVE;
                                                                            UP_mode := FALSE;
                                                                            is_Motor := Blind_control0_IN_PreIDLE;
                                                                            temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                            Relay_PWR := FALSE;
                                                                        END_IF;

                                                                END_CASE;

                                                        END_CASE;

                                                    END_IF;

                                                    is_Mode01 := Blind_control0_IN_Released;
                                                END_IF;

                                            d_Blind_control0_IN_Pressed: 

                                                IF  NOT Btn_2 THEN 

                                                    IF is_active_Motor <> 0 THEN 

                                                        CASE is_Motor OF
                                                            Blind_control0_IN_DOWN: 

                                                                CASE is_DOWN OF
                                                                    Blind_control0_IN_MOV_DOWN: 
                                                                        is_DOWN := c_Blind_contro_IN_NO_ACTIVE;
                                                                        DOWN_mode := FALSE;
                                                                        is_Motor := Blind_control0_IN_PreIDLE;
                                                                        temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                        Relay_PWR := FALSE;
                                                                    c_Blind_control0_IN_MOV_DOW: 
                                                                        temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                        IF temporalCounter_i2.done THEN 
                                                                            is_DOWN := Blind_control0_IN_MOV_DOWN;
                                                                            Relay_PWR := TRUE;
                                                                        ELSE 
                                                                            is_DOWN := c_Blind_contro_IN_NO_ACTIVE;
                                                                            DOWN_mode := FALSE;
                                                                            is_Motor := Blind_control0_IN_PreIDLE;
                                                                            temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                            Relay_PWR := FALSE;
                                                                        END_IF;

                                                                END_CASE;

                                                            Blind_control0_IN_IDLE: 
                                                                temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                IF temporalCounter_i2.done THEN 

                                                                    IF Relay_DIR THEN 
                                                                        Relay_DIR := FALSE;
                                                                        is_Motor := Blind_control0_IN_IDLE;
                                                                        temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                        Relay_PWR := FALSE;
                                                                    END_IF;

                                                                END_IF;

                                                            Blind_control0_IN_PreIDLE: 
                                                                temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                IF temporalCounter_i2.done THEN 
                                                                    is_Motor := Blind_control0_IN_IDLE;
                                                                    temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                    Relay_PWR := FALSE;
                                                                END_IF;

                                                            Blind_control0_IN_UP_j: 

                                                                CASE is_UP OF
                                                                    Blind_control0_IN_MOV_UP: 
                                                                        is_UP := c_Blind_contro_IN_NO_ACTIVE;
                                                                        UP_mode := FALSE;
                                                                        is_Motor := Blind_control0_IN_PreIDLE;
                                                                        temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                        Relay_PWR := FALSE;
                                                                    c_Blind_control0_IN_MOV_UP_: 
                                                                        temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                        IF temporalCounter_i2.done THEN 
                                                                            is_UP := Blind_control0_IN_MOV_UP;
                                                                            Relay_PWR := TRUE;
                                                                        ELSE 
                                                                            is_UP := c_Blind_contro_IN_NO_ACTIVE;
                                                                            UP_mode := FALSE;
                                                                            is_Motor := Blind_control0_IN_PreIDLE;
                                                                            temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                            Relay_PWR := FALSE;
                                                                        END_IF;

                                                                END_CASE;

                                                        END_CASE;

                                                    END_IF;

                                                    is_Mode01 := Blind_control0_IN_Released;
                                                END_IF;

                                            Blind_control0_IN_Released: 

                                                IF Btn_1 THEN 
                                                    is_Mode01 := c_Blind_control0_IN_Pressed;

                                                    IF is_active_Motor <> 0 THEN 

                                                        CASE is_Motor OF
                                                            Blind_control0_IN_DOWN: 

                                                                CASE is_DOWN OF
                                                                    Blind_control0_IN_MOV_DOWN: 
                                                                        ;
                                                                        ;
                                                                    c_Blind_control0_IN_MOV_DOW: 
                                                                        temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                        IF temporalCounter_i2.done THEN 
                                                                            is_DOWN := Blind_control0_IN_MOV_DOWN;
                                                                            Relay_PWR := TRUE;
                                                                        END_IF;

                                                                END_CASE;

                                                            Blind_control0_IN_IDLE: 
                                                                is_Motor := Blind_control0_IN_DOWN;
                                                                DOWN_mode := TRUE;
                                                                is_DOWN := c_Blind_control0_IN_MOV_DOW;
                                                                temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                Relay_DIR := FALSE;
                                                            Blind_control0_IN_PreIDLE: 
                                                                temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                IF temporalCounter_i2.done THEN 
                                                                    is_Motor := Blind_control0_IN_IDLE;
                                                                    temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                    Relay_PWR := FALSE;
                                                                END_IF;

                                                            Blind_control0_IN_UP_j: 

                                                                CASE is_UP OF
                                                                    Blind_control0_IN_MOV_UP: 
                                                                        ;
                                                                        ;
                                                                    c_Blind_control0_IN_MOV_UP_: 
                                                                        temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                        IF temporalCounter_i2.done THEN 
                                                                            is_UP := Blind_control0_IN_MOV_UP;
                                                                            Relay_PWR := TRUE;
                                                                        END_IF;

                                                                END_CASE;

                                                        END_CASE;

                                                    END_IF;

                                                ELSIF Btn_2 THEN 
                                                    is_Mode01 := d_Blind_control0_IN_Pressed;

                                                    IF is_active_Motor <> 0 THEN 

                                                        CASE is_Motor OF
                                                            Blind_control0_IN_DOWN: 

                                                                CASE is_DOWN OF
                                                                    Blind_control0_IN_MOV_DOWN: 
                                                                        ;
                                                                        ;
                                                                    c_Blind_control0_IN_MOV_DOW: 
                                                                        temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                        IF temporalCounter_i2.done THEN 
                                                                            is_DOWN := Blind_control0_IN_MOV_DOWN;
                                                                            Relay_PWR := TRUE;
                                                                        END_IF;

                                                                END_CASE;

                                                            Blind_control0_IN_IDLE: 
                                                                is_Motor := Blind_control0_IN_UP_j;
                                                                UP_mode := TRUE;
                                                                is_UP := c_Blind_control0_IN_MOV_UP_;
                                                                temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                Relay_DIR := TRUE;
                                                            Blind_control0_IN_PreIDLE: 
                                                                temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                IF temporalCounter_i2.done THEN 
                                                                    is_Motor := Blind_control0_IN_IDLE;
                                                                    temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                    Relay_PWR := FALSE;
                                                                END_IF;

                                                            Blind_control0_IN_UP_j: 

                                                                CASE is_UP OF
                                                                    Blind_control0_IN_MOV_UP: 
                                                                        ;
                                                                        ;
                                                                    c_Blind_control0_IN_MOV_UP_: 
                                                                        temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                        IF temporalCounter_i2.done THEN 
                                                                            is_UP := Blind_control0_IN_MOV_UP;
                                                                            Relay_PWR := TRUE;
                                                                        END_IF;

                                                                END_CASE;

                                                        END_CASE;

                                                    END_IF;

                                                END_IF;

                                        END_CASE;

                                    END_IF;

                                Blind_control0_IN_Mode1: 

                                    IF Btn_mode <> 1 THEN 
                                        is_Released := c_Blind_contro_IN_NO_ACTIVE;
                                        is_Mode1 := c_Blind_contro_IN_NO_ACTIVE;
                                        is_Local_control := c_Blind_contro_IN_NO_ACTIVE;
                                        is_Button := Blind_control0_IN_Begin;
                                    ELSE 

                                        CASE is_Mode1 OF
                                            Blind_control0_IN_Begin: 

                                                IF Btn_1 THEN 
                                                    is_Mode1 := Blind_control0_IN_Pressed;
                                                    b_st := TRUE;
                                                ELSE 
                                                    is_Mode1 := c_Blind_control0_IN_Release;

                                                    CASE was_Released OF
                                                        Blind_control0_IN_DOWN: 
                                                            is_Released := Blind_control0_IN_DOWN;
                                                            was_Released := Blind_control0_IN_DOWN;
                                                            temporalCounter_i1(timerAction := 1, maxTime := 0);
                                                        Blind_control0_IN_DOWN_Tout: 
                                                            is_Released := Blind_control0_IN_DOWN_Tout;
                                                            was_Released := Blind_control0_IN_DOWN_Tout;
                                                            b_st := FALSE;

                                                            IF is_active_Motor <> 0 THEN 

                                                                CASE is_Motor OF
                                                                    Blind_control0_IN_DOWN: 

                                                                        CASE is_DOWN OF
                                                                            Blind_control0_IN_MOV_DOWN: 
                                                                                is_DOWN := c_Blind_contro_IN_NO_ACTIVE;
                                                                                DOWN_mode := FALSE;
                                                                                is_Motor := Blind_control0_IN_PreIDLE;
                                                                                temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                                Relay_PWR := FALSE;
                                                                            c_Blind_control0_IN_MOV_DOW: 
                                                                                temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                                IF temporalCounter_i2.done THEN 
                                                                                    is_DOWN := Blind_control0_IN_MOV_DOWN;
                                                                                    Relay_PWR := TRUE;
                                                                                ELSE 
                                                                                    is_DOWN := c_Blind_contro_IN_NO_ACTIVE;
                                                                                    DOWN_mode := FALSE;
                                                                                    is_Motor := Blind_control0_IN_PreIDLE;
                                                                                    temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                                    Relay_PWR := FALSE;
                                                                                END_IF;

                                                                        END_CASE;

                                                                    Blind_control0_IN_IDLE: 
                                                                        temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                        IF temporalCounter_i2.done THEN 

                                                                            IF Relay_DIR THEN 
                                                                                Relay_DIR := FALSE;
                                                                                is_Motor := Blind_control0_IN_IDLE;
                                                                                temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                                Relay_PWR := FALSE;
                                                                            END_IF;

                                                                        END_IF;

                                                                    Blind_control0_IN_PreIDLE: 
                                                                        temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                        IF temporalCounter_i2.done THEN 
                                                                            is_Motor := Blind_control0_IN_IDLE;
                                                                            temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                            Relay_PWR := FALSE;
                                                                        END_IF;

                                                                    Blind_control0_IN_UP_j: 

                                                                        CASE is_UP OF
                                                                            Blind_control0_IN_MOV_UP: 
                                                                                is_UP := c_Blind_contro_IN_NO_ACTIVE;
                                                                                UP_mode := FALSE;
                                                                                is_Motor := Blind_control0_IN_PreIDLE;
                                                                                temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                                Relay_PWR := FALSE;
                                                                            c_Blind_control0_IN_MOV_UP_: 
                                                                                temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                                IF temporalCounter_i2.done THEN 
                                                                                    is_UP := Blind_control0_IN_MOV_UP;
                                                                                    Relay_PWR := TRUE;
                                                                                ELSE 
                                                                                    is_UP := c_Blind_contro_IN_NO_ACTIVE;
                                                                                    UP_mode := FALSE;
                                                                                    is_Motor := Blind_control0_IN_PreIDLE;
                                                                                    temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                                    Relay_PWR := FALSE;
                                                                                END_IF;

                                                                        END_CASE;

                                                                END_CASE;

                                                            END_IF;

                                                        Blind_control0_IN_STOP_DOWN: 
                                                            is_Released := Blind_control0_IN_STOP_DOWN;
                                                            was_Released := Blind_control0_IN_STOP_DOWN;
                                                        Blind_control0_IN_STOP_UP: 
                                                            is_Released := Blind_control0_IN_STOP_UP;
                                                            was_Released := Blind_control0_IN_STOP_UP;
                                                        Blind_control0_IN_UP: 
                                                            is_Released := Blind_control0_IN_UP;
                                                            was_Released := Blind_control0_IN_UP;
                                                            temporalCounter_i1(timerAction := 1, maxTime := 0);
                                                        Blind_control0_IN_UP_Tout: 
                                                            is_Released := Blind_control0_IN_UP_Tout;
                                                            was_Released := Blind_control0_IN_UP_Tout;
                                                            b_st := FALSE;

                                                            IF is_active_Motor <> 0 THEN 

                                                                CASE is_Motor OF
                                                                    Blind_control0_IN_DOWN: 

                                                                        CASE is_DOWN OF
                                                                            Blind_control0_IN_MOV_DOWN: 
                                                                                is_DOWN := c_Blind_contro_IN_NO_ACTIVE;
                                                                                DOWN_mode := FALSE;
                                                                                is_Motor := Blind_control0_IN_PreIDLE;
                                                                                temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                                Relay_PWR := FALSE;
                                                                            c_Blind_control0_IN_MOV_DOW: 
                                                                                temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                                IF temporalCounter_i2.done THEN 
                                                                                    is_DOWN := Blind_control0_IN_MOV_DOWN;
                                                                                    Relay_PWR := TRUE;
                                                                                ELSE 
                                                                                    is_DOWN := c_Blind_contro_IN_NO_ACTIVE;
                                                                                    DOWN_mode := FALSE;
                                                                                    is_Motor := Blind_control0_IN_PreIDLE;
                                                                                    temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                                    Relay_PWR := FALSE;
                                                                                END_IF;

                                                                        END_CASE;

                                                                    Blind_control0_IN_IDLE: 
                                                                        temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                        IF temporalCounter_i2.done THEN 

                                                                            IF Relay_DIR THEN 
                                                                                Relay_DIR := FALSE;
                                                                                is_Motor := Blind_control0_IN_IDLE;
                                                                                temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                                Relay_PWR := FALSE;
                                                                            END_IF;

                                                                        END_IF;

                                                                    Blind_control0_IN_PreIDLE: 
                                                                        temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                        IF temporalCounter_i2.done THEN 
                                                                            is_Motor := Blind_control0_IN_IDLE;
                                                                            temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                            Relay_PWR := FALSE;
                                                                        END_IF;

                                                                    Blind_control0_IN_UP_j: 

                                                                        CASE is_UP OF
                                                                            Blind_control0_IN_MOV_UP: 
                                                                                is_UP := c_Blind_contro_IN_NO_ACTIVE;
                                                                                UP_mode := FALSE;
                                                                                is_Motor := Blind_control0_IN_PreIDLE;
                                                                                temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                                Relay_PWR := FALSE;
                                                                            c_Blind_control0_IN_MOV_UP_: 
                                                                                temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                                IF temporalCounter_i2.done THEN 
                                                                                    is_UP := Blind_control0_IN_MOV_UP;
                                                                                    Relay_PWR := TRUE;
                                                                                ELSE 
                                                                                    is_UP := c_Blind_contro_IN_NO_ACTIVE;
                                                                                    UP_mode := FALSE;
                                                                                    is_Motor := Blind_control0_IN_PreIDLE;
                                                                                    temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                                    Relay_PWR := FALSE;
                                                                                END_IF;

                                                                        END_CASE;

                                                                END_CASE;

                                                            END_IF;

                                                        ELSE
                                                            is_Released := Blind_control0_IN_STOP_UP;
                                                            was_Released := Blind_control0_IN_STOP_UP;
                                                    END_CASE;

                                                END_IF;

                                            Blind_control0_IN_Pressed: 

                                                IF  NOT Btn_1 THEN 
                                                    is_Mode1 := c_Blind_control0_IN_Release;

                                                    CASE was_Released OF
                                                        Blind_control0_IN_DOWN: 
                                                            is_Released := Blind_control0_IN_DOWN;
                                                            was_Released := Blind_control0_IN_DOWN;
                                                            temporalCounter_i1(timerAction := 1, maxTime := 0);
                                                        Blind_control0_IN_DOWN_Tout: 
                                                            is_Released := Blind_control0_IN_DOWN_Tout;
                                                            was_Released := Blind_control0_IN_DOWN_Tout;
                                                            b_st := FALSE;

                                                            IF is_active_Motor <> 0 THEN 

                                                                CASE is_Motor OF
                                                                    Blind_control0_IN_DOWN: 

                                                                        CASE is_DOWN OF
                                                                            Blind_control0_IN_MOV_DOWN: 
                                                                                is_DOWN := c_Blind_contro_IN_NO_ACTIVE;
                                                                                DOWN_mode := FALSE;
                                                                                is_Motor := Blind_control0_IN_PreIDLE;
                                                                                temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                                Relay_PWR := FALSE;
                                                                            c_Blind_control0_IN_MOV_DOW: 
                                                                                temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                                IF temporalCounter_i2.done THEN 
                                                                                    is_DOWN := Blind_control0_IN_MOV_DOWN;
                                                                                    Relay_PWR := TRUE;
                                                                                ELSE 
                                                                                    is_DOWN := c_Blind_contro_IN_NO_ACTIVE;
                                                                                    DOWN_mode := FALSE;
                                                                                    is_Motor := Blind_control0_IN_PreIDLE;
                                                                                    temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                                    Relay_PWR := FALSE;
                                                                                END_IF;

                                                                        END_CASE;

                                                                    Blind_control0_IN_IDLE: 
                                                                        temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                        IF temporalCounter_i2.done THEN 

                                                                            IF Relay_DIR THEN 
                                                                                Relay_DIR := FALSE;
                                                                                is_Motor := Blind_control0_IN_IDLE;
                                                                                temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                                Relay_PWR := FALSE;
                                                                            END_IF;

                                                                        END_IF;

                                                                    Blind_control0_IN_PreIDLE: 
                                                                        temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                        IF temporalCounter_i2.done THEN 
                                                                            is_Motor := Blind_control0_IN_IDLE;
                                                                            temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                            Relay_PWR := FALSE;
                                                                        END_IF;

                                                                    Blind_control0_IN_UP_j: 

                                                                        CASE is_UP OF
                                                                            Blind_control0_IN_MOV_UP: 
                                                                                is_UP := c_Blind_contro_IN_NO_ACTIVE;
                                                                                UP_mode := FALSE;
                                                                                is_Motor := Blind_control0_IN_PreIDLE;
                                                                                temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                                Relay_PWR := FALSE;
                                                                            c_Blind_control0_IN_MOV_UP_: 
                                                                                temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                                IF temporalCounter_i2.done THEN 
                                                                                    is_UP := Blind_control0_IN_MOV_UP;
                                                                                    Relay_PWR := TRUE;
                                                                                ELSE 
                                                                                    is_UP := c_Blind_contro_IN_NO_ACTIVE;
                                                                                    UP_mode := FALSE;
                                                                                    is_Motor := Blind_control0_IN_PreIDLE;
                                                                                    temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                                    Relay_PWR := FALSE;
                                                                                END_IF;

                                                                        END_CASE;

                                                                END_CASE;

                                                            END_IF;

                                                        Blind_control0_IN_STOP_DOWN: 
                                                            is_Released := Blind_control0_IN_STOP_DOWN;
                                                            was_Released := Blind_control0_IN_STOP_DOWN;
                                                        Blind_control0_IN_STOP_UP: 
                                                            is_Released := Blind_control0_IN_STOP_UP;
                                                            was_Released := Blind_control0_IN_STOP_UP;
                                                        Blind_control0_IN_UP: 
                                                            is_Released := Blind_control0_IN_UP;
                                                            was_Released := Blind_control0_IN_UP;
                                                            temporalCounter_i1(timerAction := 1, maxTime := 0);
                                                        Blind_control0_IN_UP_Tout: 
                                                            is_Released := Blind_control0_IN_UP_Tout;
                                                            was_Released := Blind_control0_IN_UP_Tout;
                                                            b_st := FALSE;

                                                            IF is_active_Motor <> 0 THEN 

                                                                CASE is_Motor OF
                                                                    Blind_control0_IN_DOWN: 

                                                                        CASE is_DOWN OF
                                                                            Blind_control0_IN_MOV_DOWN: 
                                                                                is_DOWN := c_Blind_contro_IN_NO_ACTIVE;
                                                                                DOWN_mode := FALSE;
                                                                                is_Motor := Blind_control0_IN_PreIDLE;
                                                                                temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                                Relay_PWR := FALSE;
                                                                            c_Blind_control0_IN_MOV_DOW: 
                                                                                temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                                IF temporalCounter_i2.done THEN 
                                                                                    is_DOWN := Blind_control0_IN_MOV_DOWN;
                                                                                    Relay_PWR := TRUE;
                                                                                ELSE 
                                                                                    is_DOWN := c_Blind_contro_IN_NO_ACTIVE;
                                                                                    DOWN_mode := FALSE;
                                                                                    is_Motor := Blind_control0_IN_PreIDLE;
                                                                                    temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                                    Relay_PWR := FALSE;
                                                                                END_IF;

                                                                        END_CASE;

                                                                    Blind_control0_IN_IDLE: 
                                                                        temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                        IF temporalCounter_i2.done THEN 

                                                                            IF Relay_DIR THEN 
                                                                                Relay_DIR := FALSE;
                                                                                is_Motor := Blind_control0_IN_IDLE;
                                                                                temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                                Relay_PWR := FALSE;
                                                                            END_IF;

                                                                        END_IF;

                                                                    Blind_control0_IN_PreIDLE: 
                                                                        temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                        IF temporalCounter_i2.done THEN 
                                                                            is_Motor := Blind_control0_IN_IDLE;
                                                                            temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                            Relay_PWR := FALSE;
                                                                        END_IF;

                                                                    Blind_control0_IN_UP_j: 

                                                                        CASE is_UP OF
                                                                            Blind_control0_IN_MOV_UP: 
                                                                                is_UP := c_Blind_contro_IN_NO_ACTIVE;
                                                                                UP_mode := FALSE;
                                                                                is_Motor := Blind_control0_IN_PreIDLE;
                                                                                temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                                Relay_PWR := FALSE;
                                                                            c_Blind_control0_IN_MOV_UP_: 
                                                                                temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                                IF temporalCounter_i2.done THEN 
                                                                                    is_UP := Blind_control0_IN_MOV_UP;
                                                                                    Relay_PWR := TRUE;
                                                                                ELSE 
                                                                                    is_UP := c_Blind_contro_IN_NO_ACTIVE;
                                                                                    UP_mode := FALSE;
                                                                                    is_Motor := Blind_control0_IN_PreIDLE;
                                                                                    temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                                    Relay_PWR := FALSE;
                                                                                END_IF;

                                                                        END_CASE;

                                                                END_CASE;

                                                            END_IF;

                                                        ELSE
                                                            is_Released := Blind_control0_IN_STOP_UP;
                                                            was_Released := Blind_control0_IN_STOP_UP;
                                                    END_CASE;

                                                END_IF;

                                            c_Blind_control0_IN_Release: 

                                                IF Btn_1 THEN 
                                                    is_Released := c_Blind_contro_IN_NO_ACTIVE;
                                                    is_Mode1 := Blind_control0_IN_Pressed;
                                                    b_st := TRUE;
                                                ELSE 

                                                    CASE is_Released OF
                                                        Blind_control0_IN_DOWN: 
                                                            temporalCounter_i1(timerAction := 2, maxTime := TRUNC(REAL_TO_LREAL(Mot_timeout) * 1000.0));

                                                            IF temporalCounter_i1.done THEN 
                                                                is_Released := Blind_control0_IN_DOWN_Tout;
                                                                was_Released := Blind_control0_IN_DOWN_Tout;
                                                                b_st := FALSE;

                                                                IF is_active_Motor <> 0 THEN 

                                                                    CASE is_Motor OF
                                                                        Blind_control0_IN_DOWN: 

                                                                            CASE is_DOWN OF
                                                                                Blind_control0_IN_MOV_DOWN: 
                                                                                    is_DOWN := c_Blind_contro_IN_NO_ACTIVE;
                                                                                    DOWN_mode := FALSE;
                                                                                    is_Motor := Blind_control0_IN_PreIDLE;
                                                                                    temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                                    Relay_PWR := FALSE;
                                                                                c_Blind_control0_IN_MOV_DOW: 
                                                                                    temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                                    IF temporalCounter_i2.done THEN 
                                                                                        is_DOWN := Blind_control0_IN_MOV_DOWN;
                                                                                        Relay_PWR := TRUE;
                                                                                    ELSE 
                                                                                        is_DOWN := c_Blind_contro_IN_NO_ACTIVE;
                                                                                        DOWN_mode := FALSE;
                                                                                        is_Motor := Blind_control0_IN_PreIDLE;
                                                                                        temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                                        Relay_PWR := FALSE;
                                                                                    END_IF;

                                                                            END_CASE;

                                                                        Blind_control0_IN_IDLE: 
                                                                            temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                            IF temporalCounter_i2.done THEN 

                                                                                IF Relay_DIR THEN 
                                                                                    Relay_DIR := FALSE;
                                                                                    is_Motor := Blind_control0_IN_IDLE;
                                                                                    temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                                    Relay_PWR := FALSE;
                                                                                END_IF;

                                                                            END_IF;

                                                                        Blind_control0_IN_PreIDLE: 
                                                                            temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                            IF temporalCounter_i2.done THEN 
                                                                                is_Motor := Blind_control0_IN_IDLE;
                                                                                temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                                Relay_PWR := FALSE;
                                                                            END_IF;

                                                                        Blind_control0_IN_UP_j: 

                                                                            CASE is_UP OF
                                                                                Blind_control0_IN_MOV_UP: 
                                                                                    is_UP := c_Blind_contro_IN_NO_ACTIVE;
                                                                                    UP_mode := FALSE;
                                                                                    is_Motor := Blind_control0_IN_PreIDLE;
                                                                                    temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                                    Relay_PWR := FALSE;
                                                                                c_Blind_control0_IN_MOV_UP_: 
                                                                                    temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                                    IF temporalCounter_i2.done THEN 
                                                                                        is_UP := Blind_control0_IN_MOV_UP;
                                                                                        Relay_PWR := TRUE;
                                                                                    ELSE 
                                                                                        is_UP := c_Blind_contro_IN_NO_ACTIVE;
                                                                                        UP_mode := FALSE;
                                                                                        is_Motor := Blind_control0_IN_PreIDLE;
                                                                                        temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                                        Relay_PWR := FALSE;
                                                                                    END_IF;

                                                                            END_CASE;

                                                                    END_CASE;

                                                                END_IF;

                                                            ELSIF b_st THEN 
                                                                b_st := FALSE;

                                                                IF is_active_Motor <> 0 THEN 

                                                                    CASE is_Motor OF
                                                                        Blind_control0_IN_DOWN: 

                                                                            CASE is_DOWN OF
                                                                                Blind_control0_IN_MOV_DOWN: 
                                                                                    is_DOWN := c_Blind_contro_IN_NO_ACTIVE;
                                                                                    DOWN_mode := FALSE;
                                                                                    is_Motor := Blind_control0_IN_PreIDLE;
                                                                                    temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                                    Relay_PWR := FALSE;
                                                                                c_Blind_control0_IN_MOV_DOW: 
                                                                                    temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                                    IF temporalCounter_i2.done THEN 
                                                                                        is_DOWN := Blind_control0_IN_MOV_DOWN;
                                                                                        Relay_PWR := TRUE;
                                                                                    ELSE 
                                                                                        is_DOWN := c_Blind_contro_IN_NO_ACTIVE;
                                                                                        DOWN_mode := FALSE;
                                                                                        is_Motor := Blind_control0_IN_PreIDLE;
                                                                                        temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                                        Relay_PWR := FALSE;
                                                                                    END_IF;

                                                                            END_CASE;

                                                                        Blind_control0_IN_IDLE: 
                                                                            temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                            IF temporalCounter_i2.done THEN 

                                                                                IF Relay_DIR THEN 
                                                                                    Relay_DIR := FALSE;
                                                                                    is_Motor := Blind_control0_IN_IDLE;
                                                                                    temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                                    Relay_PWR := FALSE;
                                                                                END_IF;

                                                                            END_IF;

                                                                        Blind_control0_IN_PreIDLE: 
                                                                            temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                            IF temporalCounter_i2.done THEN 
                                                                                is_Motor := Blind_control0_IN_IDLE;
                                                                                temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                                Relay_PWR := FALSE;
                                                                            END_IF;

                                                                        Blind_control0_IN_UP_j: 

                                                                            CASE is_UP OF
                                                                                Blind_control0_IN_MOV_UP: 
                                                                                    is_UP := c_Blind_contro_IN_NO_ACTIVE;
                                                                                    UP_mode := FALSE;
                                                                                    is_Motor := Blind_control0_IN_PreIDLE;
                                                                                    temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                                    Relay_PWR := FALSE;
                                                                                c_Blind_control0_IN_MOV_UP_: 
                                                                                    temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                                    IF temporalCounter_i2.done THEN 
                                                                                        is_UP := Blind_control0_IN_MOV_UP;
                                                                                        Relay_PWR := TRUE;
                                                                                    ELSE 
                                                                                        is_UP := c_Blind_contro_IN_NO_ACTIVE;
                                                                                        UP_mode := FALSE;
                                                                                        is_Motor := Blind_control0_IN_PreIDLE;
                                                                                        temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                                        Relay_PWR := FALSE;
                                                                                    END_IF;

                                                                            END_CASE;

                                                                    END_CASE;

                                                                END_IF;

                                                                is_Released := Blind_control0_IN_STOP_UP;
                                                                was_Released := Blind_control0_IN_STOP_UP;
                                                            END_IF;

                                                        Blind_control0_IN_DOWN_Tout: 
                                                            is_Released := Blind_control0_IN_STOP_DOWN;
                                                            was_Released := Blind_control0_IN_STOP_DOWN;
                                                        Blind_control0_IN_STOP_DOWN: 

                                                            IF b_st THEN 
                                                                b_st := FALSE;

                                                                IF is_active_Motor <> 0 THEN 

                                                                    CASE is_Motor OF
                                                                        Blind_control0_IN_DOWN: 

                                                                            CASE is_DOWN OF
                                                                                Blind_control0_IN_MOV_DOWN: 
                                                                                    ;
                                                                                    ;
                                                                                c_Blind_control0_IN_MOV_DOW: 
                                                                                    temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                                    IF temporalCounter_i2.done THEN 
                                                                                        is_DOWN := Blind_control0_IN_MOV_DOWN;
                                                                                        Relay_PWR := TRUE;
                                                                                    END_IF;

                                                                            END_CASE;

                                                                        Blind_control0_IN_IDLE: 
                                                                            is_Motor := Blind_control0_IN_DOWN;
                                                                            DOWN_mode := TRUE;
                                                                            is_DOWN := c_Blind_control0_IN_MOV_DOW;
                                                                            temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                            Relay_DIR := FALSE;
                                                                        Blind_control0_IN_PreIDLE: 
                                                                            temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                            IF temporalCounter_i2.done THEN 
                                                                                is_Motor := Blind_control0_IN_IDLE;
                                                                                temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                                Relay_PWR := FALSE;
                                                                            END_IF;

                                                                        Blind_control0_IN_UP_j: 

                                                                            CASE is_UP OF
                                                                                Blind_control0_IN_MOV_UP: 
                                                                                    ;
                                                                                    ;
                                                                                c_Blind_control0_IN_MOV_UP_: 
                                                                                    temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                                    IF temporalCounter_i2.done THEN 
                                                                                        is_UP := Blind_control0_IN_MOV_UP;
                                                                                        Relay_PWR := TRUE;
                                                                                    END_IF;

                                                                            END_CASE;

                                                                    END_CASE;

                                                                END_IF;

                                                                is_Released := Blind_control0_IN_DOWN;
                                                                was_Released := Blind_control0_IN_DOWN;
                                                                temporalCounter_i1(timerAction := 1, maxTime := 0);
                                                            END_IF;

                                                        Blind_control0_IN_STOP_UP: 

                                                            IF b_st THEN 
                                                                b_st := FALSE;

                                                                IF is_active_Motor <> 0 THEN 

                                                                    CASE is_Motor OF
                                                                        Blind_control0_IN_DOWN: 

                                                                            CASE is_DOWN OF
                                                                                Blind_control0_IN_MOV_DOWN: 
                                                                                    ;
                                                                                    ;
                                                                                c_Blind_control0_IN_MOV_DOW: 
                                                                                    temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                                    IF temporalCounter_i2.done THEN 
                                                                                        is_DOWN := Blind_control0_IN_MOV_DOWN;
                                                                                        Relay_PWR := TRUE;
                                                                                    END_IF;

                                                                            END_CASE;

                                                                        Blind_control0_IN_IDLE: 
                                                                            is_Motor := Blind_control0_IN_UP_j;
                                                                            UP_mode := TRUE;
                                                                            is_UP := c_Blind_control0_IN_MOV_UP_;
                                                                            temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                            Relay_DIR := TRUE;
                                                                        Blind_control0_IN_PreIDLE: 
                                                                            temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                            IF temporalCounter_i2.done THEN 
                                                                                is_Motor := Blind_control0_IN_IDLE;
                                                                                temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                                Relay_PWR := FALSE;
                                                                            END_IF;

                                                                        Blind_control0_IN_UP_j: 

                                                                            CASE is_UP OF
                                                                                Blind_control0_IN_MOV_UP: 
                                                                                    ;
                                                                                    ;
                                                                                c_Blind_control0_IN_MOV_UP_: 
                                                                                    temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                                    IF temporalCounter_i2.done THEN 
                                                                                        is_UP := Blind_control0_IN_MOV_UP;
                                                                                        Relay_PWR := TRUE;
                                                                                    END_IF;

                                                                            END_CASE;

                                                                    END_CASE;

                                                                END_IF;

                                                                is_Released := Blind_control0_IN_UP;
                                                                was_Released := Blind_control0_IN_UP;
                                                                temporalCounter_i1(timerAction := 1, maxTime := 0);
                                                            END_IF;

                                                        Blind_control0_IN_UP: 

                                                            IF b_st THEN 
                                                                b_st := FALSE;

                                                                IF is_active_Motor <> 0 THEN 

                                                                    CASE is_Motor OF
                                                                        Blind_control0_IN_DOWN: 

                                                                            CASE is_DOWN OF
                                                                                Blind_control0_IN_MOV_DOWN: 
                                                                                    is_DOWN := c_Blind_contro_IN_NO_ACTIVE;
                                                                                    DOWN_mode := FALSE;
                                                                                    is_Motor := Blind_control0_IN_PreIDLE;
                                                                                    temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                                    Relay_PWR := FALSE;
                                                                                c_Blind_control0_IN_MOV_DOW: 
                                                                                    temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                                    IF temporalCounter_i2.done THEN 
                                                                                        is_DOWN := Blind_control0_IN_MOV_DOWN;
                                                                                        Relay_PWR := TRUE;
                                                                                    ELSE 
                                                                                        is_DOWN := c_Blind_contro_IN_NO_ACTIVE;
                                                                                        DOWN_mode := FALSE;
                                                                                        is_Motor := Blind_control0_IN_PreIDLE;
                                                                                        temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                                        Relay_PWR := FALSE;
                                                                                    END_IF;

                                                                            END_CASE;

                                                                        Blind_control0_IN_IDLE: 
                                                                            temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                            IF temporalCounter_i2.done THEN 

                                                                                IF Relay_DIR THEN 
                                                                                    Relay_DIR := FALSE;
                                                                                    is_Motor := Blind_control0_IN_IDLE;
                                                                                    temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                                    Relay_PWR := FALSE;
                                                                                END_IF;

                                                                            END_IF;

                                                                        Blind_control0_IN_PreIDLE: 
                                                                            temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                            IF temporalCounter_i2.done THEN 
                                                                                is_Motor := Blind_control0_IN_IDLE;
                                                                                temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                                Relay_PWR := FALSE;
                                                                            END_IF;

                                                                        Blind_control0_IN_UP_j: 

                                                                            CASE is_UP OF
                                                                                Blind_control0_IN_MOV_UP: 
                                                                                    is_UP := c_Blind_contro_IN_NO_ACTIVE;
                                                                                    UP_mode := FALSE;
                                                                                    is_Motor := Blind_control0_IN_PreIDLE;
                                                                                    temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                                    Relay_PWR := FALSE;
                                                                                c_Blind_control0_IN_MOV_UP_: 
                                                                                    temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                                    IF temporalCounter_i2.done THEN 
                                                                                        is_UP := Blind_control0_IN_MOV_UP;
                                                                                        Relay_PWR := TRUE;
                                                                                    ELSE 
                                                                                        is_UP := c_Blind_contro_IN_NO_ACTIVE;
                                                                                        UP_mode := FALSE;
                                                                                        is_Motor := Blind_control0_IN_PreIDLE;
                                                                                        temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                                        Relay_PWR := FALSE;
                                                                                    END_IF;

                                                                            END_CASE;

                                                                    END_CASE;

                                                                END_IF;

                                                                is_Released := Blind_control0_IN_STOP_DOWN;
                                                                was_Released := Blind_control0_IN_STOP_DOWN;
                                                            ELSE 
                                                                temporalCounter_i1(timerAction := 2, maxTime := TRUNC(REAL_TO_LREAL(Mot_timeout) * 1000.0));

                                                                IF temporalCounter_i1.done THEN 
                                                                    is_Released := Blind_control0_IN_UP_Tout;
                                                                    was_Released := Blind_control0_IN_UP_Tout;
                                                                    b_st := FALSE;

                                                                    IF is_active_Motor <> 0 THEN 

                                                                        CASE is_Motor OF
                                                                            Blind_control0_IN_DOWN: 

                                                                                CASE is_DOWN OF
                                                                                    Blind_control0_IN_MOV_DOWN: 
                                                                                        is_DOWN := c_Blind_contro_IN_NO_ACTIVE;
                                                                                        DOWN_mode := FALSE;
                                                                                        is_Motor := Blind_control0_IN_PreIDLE;
                                                                                        temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                                        Relay_PWR := FALSE;
                                                                                    c_Blind_control0_IN_MOV_DOW: 
                                                                                        temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                                        IF temporalCounter_i2.done THEN 
                                                                                            is_DOWN := Blind_control0_IN_MOV_DOWN;
                                                                                            Relay_PWR := TRUE;
                                                                                        ELSE 
                                                                                            is_DOWN := c_Blind_contro_IN_NO_ACTIVE;
                                                                                            DOWN_mode := FALSE;
                                                                                            is_Motor := Blind_control0_IN_PreIDLE;
                                                                                            temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                                            Relay_PWR := FALSE;
                                                                                        END_IF;

                                                                                END_CASE;

                                                                            Blind_control0_IN_IDLE: 
                                                                                temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                                IF temporalCounter_i2.done THEN 

                                                                                    IF Relay_DIR THEN 
                                                                                        Relay_DIR := FALSE;
                                                                                        is_Motor := Blind_control0_IN_IDLE;
                                                                                        temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                                        Relay_PWR := FALSE;
                                                                                    END_IF;

                                                                                END_IF;

                                                                            Blind_control0_IN_PreIDLE: 
                                                                                temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                                IF temporalCounter_i2.done THEN 
                                                                                    is_Motor := Blind_control0_IN_IDLE;
                                                                                    temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                                    Relay_PWR := FALSE;
                                                                                END_IF;

                                                                            Blind_control0_IN_UP_j: 

                                                                                CASE is_UP OF
                                                                                    Blind_control0_IN_MOV_UP: 
                                                                                        is_UP := c_Blind_contro_IN_NO_ACTIVE;
                                                                                        UP_mode := FALSE;
                                                                                        is_Motor := Blind_control0_IN_PreIDLE;
                                                                                        temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                                        Relay_PWR := FALSE;
                                                                                    c_Blind_control0_IN_MOV_UP_: 
                                                                                        temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                                        IF temporalCounter_i2.done THEN 
                                                                                            is_UP := Blind_control0_IN_MOV_UP;
                                                                                            Relay_PWR := TRUE;
                                                                                        ELSE 
                                                                                            is_UP := c_Blind_contro_IN_NO_ACTIVE;
                                                                                            UP_mode := FALSE;
                                                                                            is_Motor := Blind_control0_IN_PreIDLE;
                                                                                            temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                                            Relay_PWR := FALSE;
                                                                                        END_IF;

                                                                                END_CASE;

                                                                        END_CASE;

                                                                    END_IF;

                                                                END_IF;

                                                            END_IF;

                                                        Blind_control0_IN_UP_Tout: 
                                                            is_Released := Blind_control0_IN_STOP_UP;
                                                            was_Released := Blind_control0_IN_STOP_UP;
                                                    END_CASE;

                                                END_IF;

                                        END_CASE;

                                    END_IF;

                                Blind_control0_IN_Mode2: 

                                    IF Btn_mode <> 2 THEN 
                                        is_Mode2 := c_Blind_contro_IN_NO_ACTIVE;
                                        is_Local_control := c_Blind_contro_IN_NO_ACTIVE;
                                        is_Button := Blind_control0_IN_Begin;
                                    ELSE 

                                        CASE is_Mode2 OF
                                            Blind_control0_IN_Begin: 

                                                IF Btn_1 THEN 
                                                    is_Mode2 := Blind_control0_IN_Press1;
                                                    temporalCounter_i1(timerAction := 1, maxTime := 0);
                                                ELSE 
                                                    temporalCounter_i1(timerAction := 2, maxTime := TRUNC(REAL_TO_LREAL(Mot_timeout) * 1000.0));

                                                    IF temporalCounter_i1.done THEN 

                                                        IF is_active_Motor <> 0 THEN 

                                                            CASE is_Motor OF
                                                                Blind_control0_IN_DOWN: 

                                                                    CASE is_DOWN OF
                                                                        Blind_control0_IN_MOV_DOWN: 
                                                                            is_DOWN := c_Blind_contro_IN_NO_ACTIVE;
                                                                            DOWN_mode := FALSE;
                                                                            is_Motor := Blind_control0_IN_PreIDLE;
                                                                            temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                            Relay_PWR := FALSE;
                                                                        c_Blind_control0_IN_MOV_DOW: 
                                                                            temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                            IF temporalCounter_i2.done THEN 
                                                                                is_DOWN := Blind_control0_IN_MOV_DOWN;
                                                                                Relay_PWR := TRUE;
                                                                            ELSE 
                                                                                is_DOWN := c_Blind_contro_IN_NO_ACTIVE;
                                                                                DOWN_mode := FALSE;
                                                                                is_Motor := Blind_control0_IN_PreIDLE;
                                                                                temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                                Relay_PWR := FALSE;
                                                                            END_IF;

                                                                    END_CASE;

                                                                Blind_control0_IN_IDLE: 
                                                                    temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                    IF temporalCounter_i2.done THEN 

                                                                        IF Relay_DIR THEN 
                                                                            Relay_DIR := FALSE;
                                                                            is_Motor := Blind_control0_IN_IDLE;
                                                                            temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                            Relay_PWR := FALSE;
                                                                        END_IF;

                                                                    END_IF;

                                                                Blind_control0_IN_PreIDLE: 
                                                                    temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                    IF temporalCounter_i2.done THEN 
                                                                        is_Motor := Blind_control0_IN_IDLE;
                                                                        temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                        Relay_PWR := FALSE;
                                                                    END_IF;

                                                                Blind_control0_IN_UP_j: 

                                                                    CASE is_UP OF
                                                                        Blind_control0_IN_MOV_UP: 
                                                                            is_UP := c_Blind_contro_IN_NO_ACTIVE;
                                                                            UP_mode := FALSE;
                                                                            is_Motor := Blind_control0_IN_PreIDLE;
                                                                            temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                            Relay_PWR := FALSE;
                                                                        c_Blind_control0_IN_MOV_UP_: 
                                                                            temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                            IF temporalCounter_i2.done THEN 
                                                                                is_UP := Blind_control0_IN_MOV_UP;
                                                                                Relay_PWR := TRUE;
                                                                            ELSE 
                                                                                is_UP := c_Blind_contro_IN_NO_ACTIVE;
                                                                                UP_mode := FALSE;
                                                                                is_Motor := Blind_control0_IN_PreIDLE;
                                                                                temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                                Relay_PWR := FALSE;
                                                                            END_IF;

                                                                    END_CASE;

                                                            END_CASE;

                                                        END_IF;

                                                        is_Mode2 := Blind_control0_IN_Begin;
                                                        temporalCounter_i1(timerAction := 1, maxTime := 0);
                                                    END_IF;

                                                END_IF;

                                            Blind_control0_IN_Press1: 

                                                IF is_Motor <> 2 THEN 
                                                    is_Mode2 := c_Blind_control0_IN_Stop_mo;

                                                    IF is_active_Motor <> 0 THEN 

                                                        CASE is_Motor OF
                                                            Blind_control0_IN_DOWN: 

                                                                CASE is_DOWN OF
                                                                    Blind_control0_IN_MOV_DOWN: 
                                                                        is_DOWN := c_Blind_contro_IN_NO_ACTIVE;
                                                                        DOWN_mode := FALSE;
                                                                        is_Motor := Blind_control0_IN_PreIDLE;
                                                                        temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                        Relay_PWR := FALSE;
                                                                    c_Blind_control0_IN_MOV_DOW: 
                                                                        temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                        IF temporalCounter_i2.done THEN 
                                                                            is_DOWN := Blind_control0_IN_MOV_DOWN;
                                                                            Relay_PWR := TRUE;
                                                                        ELSE 
                                                                            is_DOWN := c_Blind_contro_IN_NO_ACTIVE;
                                                                            DOWN_mode := FALSE;
                                                                            is_Motor := Blind_control0_IN_PreIDLE;
                                                                            temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                            Relay_PWR := FALSE;
                                                                        END_IF;

                                                                END_CASE;

                                                            Blind_control0_IN_IDLE: 
                                                                temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                IF temporalCounter_i2.done THEN 

                                                                    IF Relay_DIR THEN 
                                                                        Relay_DIR := FALSE;
                                                                        is_Motor := Blind_control0_IN_IDLE;
                                                                        temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                        Relay_PWR := FALSE;
                                                                    END_IF;

                                                                END_IF;

                                                            Blind_control0_IN_PreIDLE: 
                                                                temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                IF temporalCounter_i2.done THEN 
                                                                    is_Motor := Blind_control0_IN_IDLE;
                                                                    temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                    Relay_PWR := FALSE;
                                                                END_IF;

                                                            Blind_control0_IN_UP_j: 

                                                                CASE is_UP OF
                                                                    Blind_control0_IN_MOV_UP: 
                                                                        is_UP := c_Blind_contro_IN_NO_ACTIVE;
                                                                        UP_mode := FALSE;
                                                                        is_Motor := Blind_control0_IN_PreIDLE;
                                                                        temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                        Relay_PWR := FALSE;
                                                                    c_Blind_control0_IN_MOV_UP_: 
                                                                        temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                        IF temporalCounter_i2.done THEN 
                                                                            is_UP := Blind_control0_IN_MOV_UP;
                                                                            Relay_PWR := TRUE;
                                                                        ELSE 
                                                                            is_UP := c_Blind_contro_IN_NO_ACTIVE;
                                                                            UP_mode := FALSE;
                                                                            is_Motor := Blind_control0_IN_PreIDLE;
                                                                            temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                            Relay_PWR := FALSE;
                                                                        END_IF;

                                                                END_CASE;

                                                        END_CASE;

                                                    END_IF;

                                                ELSE 
                                                    temporalCounter_i1(timerAction := 2, maxTime := 1000);

                                                    IF temporalCounter_i1.done THEN 
                                                        is_Mode2 := Blind_control0_IN_Start_UP;
                                                        temporalCounter_i1(timerAction := 1, maxTime := 0);

                                                        IF is_active_Motor <> 0 THEN 

                                                            CASE is_Motor OF
                                                                Blind_control0_IN_DOWN: 

                                                                    CASE is_DOWN OF
                                                                        Blind_control0_IN_MOV_DOWN: 
                                                                            ;
                                                                            ;
                                                                        c_Blind_control0_IN_MOV_DOW: 
                                                                            temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                            IF temporalCounter_i2.done THEN 
                                                                                is_DOWN := Blind_control0_IN_MOV_DOWN;
                                                                                Relay_PWR := TRUE;
                                                                            END_IF;

                                                                    END_CASE;

                                                                Blind_control0_IN_IDLE: 
                                                                    is_Motor := Blind_control0_IN_UP_j;
                                                                    UP_mode := TRUE;
                                                                    is_UP := c_Blind_control0_IN_MOV_UP_;
                                                                    temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                    Relay_DIR := TRUE;
                                                                Blind_control0_IN_PreIDLE: 
                                                                    temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                    IF temporalCounter_i2.done THEN 
                                                                        is_Motor := Blind_control0_IN_IDLE;
                                                                        temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                        Relay_PWR := FALSE;
                                                                    END_IF;

                                                                Blind_control0_IN_UP_j: 

                                                                    CASE is_UP OF
                                                                        Blind_control0_IN_MOV_UP: 
                                                                            ;
                                                                            ;
                                                                        c_Blind_control0_IN_MOV_UP_: 
                                                                            temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                            IF temporalCounter_i2.done THEN 
                                                                                is_UP := Blind_control0_IN_MOV_UP;
                                                                                Relay_PWR := TRUE;
                                                                            END_IF;

                                                                    END_CASE;

                                                            END_CASE;

                                                        END_IF;

                                                    ELSIF  NOT Btn_1 THEN 
                                                        is_Mode2 := Blind_control0_IN_Releas1;
                                                        temporalCounter_i1(timerAction := 1, maxTime := 0);
                                                    END_IF;

                                                END_IF;

                                            Blind_control0_IN_Releas1: 

                                                IF Btn_1 THEN 
                                                    is_Mode2 := c_Blind_control0_IN_Start_D;
                                                    temporalCounter_i1(timerAction := 1, maxTime := 0);

                                                    IF is_active_Motor <> 0 THEN 

                                                        CASE is_Motor OF
                                                            Blind_control0_IN_DOWN: 

                                                                CASE is_DOWN OF
                                                                    Blind_control0_IN_MOV_DOWN: 
                                                                        ;
                                                                        ;
                                                                    c_Blind_control0_IN_MOV_DOW: 
                                                                        temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                        IF temporalCounter_i2.done THEN 
                                                                            is_DOWN := Blind_control0_IN_MOV_DOWN;
                                                                            Relay_PWR := TRUE;
                                                                        END_IF;

                                                                END_CASE;

                                                            Blind_control0_IN_IDLE: 
                                                                is_Motor := Blind_control0_IN_DOWN;
                                                                DOWN_mode := TRUE;
                                                                is_DOWN := c_Blind_control0_IN_MOV_DOW;
                                                                temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                Relay_DIR := FALSE;
                                                            Blind_control0_IN_PreIDLE: 
                                                                temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                IF temporalCounter_i2.done THEN 
                                                                    is_Motor := Blind_control0_IN_IDLE;
                                                                    temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                    Relay_PWR := FALSE;
                                                                END_IF;

                                                            Blind_control0_IN_UP_j: 

                                                                CASE is_UP OF
                                                                    Blind_control0_IN_MOV_UP: 
                                                                        ;
                                                                        ;
                                                                    c_Blind_control0_IN_MOV_UP_: 
                                                                        temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                        IF temporalCounter_i2.done THEN 
                                                                            is_UP := Blind_control0_IN_MOV_UP;
                                                                            Relay_PWR := TRUE;
                                                                        END_IF;

                                                                END_CASE;

                                                        END_CASE;

                                                    END_IF;

                                                ELSE 
                                                    temporalCounter_i1(timerAction := 2, maxTime := 1000);

                                                    IF temporalCounter_i1.done THEN 
                                                        is_Mode2 := Blind_control0_IN_Start_UP;
                                                        temporalCounter_i1(timerAction := 1, maxTime := 0);

                                                        IF is_active_Motor <> 0 THEN 

                                                            CASE is_Motor OF
                                                                Blind_control0_IN_DOWN: 

                                                                    CASE is_DOWN OF
                                                                        Blind_control0_IN_MOV_DOWN: 
                                                                            ;
                                                                            ;
                                                                        c_Blind_control0_IN_MOV_DOW: 
                                                                            temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                            IF temporalCounter_i2.done THEN 
                                                                                is_DOWN := Blind_control0_IN_MOV_DOWN;
                                                                                Relay_PWR := TRUE;
                                                                            END_IF;

                                                                    END_CASE;

                                                                Blind_control0_IN_IDLE: 
                                                                    is_Motor := Blind_control0_IN_UP_j;
                                                                    UP_mode := TRUE;
                                                                    is_UP := c_Blind_control0_IN_MOV_UP_;
                                                                    temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                    Relay_DIR := TRUE;
                                                                Blind_control0_IN_PreIDLE: 
                                                                    temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                    IF temporalCounter_i2.done THEN 
                                                                        is_Motor := Blind_control0_IN_IDLE;
                                                                        temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                        Relay_PWR := FALSE;
                                                                    END_IF;

                                                                Blind_control0_IN_UP_j: 

                                                                    CASE is_UP OF
                                                                        Blind_control0_IN_MOV_UP: 
                                                                            ;
                                                                            ;
                                                                        c_Blind_control0_IN_MOV_UP_: 
                                                                            temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                            IF temporalCounter_i2.done THEN 
                                                                                is_UP := Blind_control0_IN_MOV_UP;
                                                                                Relay_PWR := TRUE;
                                                                            END_IF;

                                                                    END_CASE;

                                                            END_CASE;

                                                        END_IF;

                                                    END_IF;

                                                END_IF;

                                            c_Blind_control0_IN_Start_D: 

                                                IF  NOT Btn_1 THEN 
                                                    is_Mode2 := Blind_control0_IN_Begin;
                                                    temporalCounter_i1(timerAction := 1, maxTime := 0);
                                                ELSE 
                                                    temporalCounter_i1(timerAction := 2, maxTime := TRUNC(REAL_TO_LREAL(Mot_timeout) * 1000.0));

                                                    IF temporalCounter_i1.done THEN 

                                                        IF is_active_Motor <> 0 THEN 

                                                            CASE is_Motor OF
                                                                Blind_control0_IN_DOWN: 

                                                                    CASE is_DOWN OF
                                                                        Blind_control0_IN_MOV_DOWN: 
                                                                            is_DOWN := c_Blind_contro_IN_NO_ACTIVE;
                                                                            DOWN_mode := FALSE;
                                                                            is_Motor := Blind_control0_IN_PreIDLE;
                                                                            temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                            Relay_PWR := FALSE;
                                                                        c_Blind_control0_IN_MOV_DOW: 
                                                                            temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                            IF temporalCounter_i2.done THEN 
                                                                                is_DOWN := Blind_control0_IN_MOV_DOWN;
                                                                                Relay_PWR := TRUE;
                                                                            ELSE 
                                                                                is_DOWN := c_Blind_contro_IN_NO_ACTIVE;
                                                                                DOWN_mode := FALSE;
                                                                                is_Motor := Blind_control0_IN_PreIDLE;
                                                                                temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                                Relay_PWR := FALSE;
                                                                            END_IF;

                                                                    END_CASE;

                                                                Blind_control0_IN_IDLE: 
                                                                    temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                    IF temporalCounter_i2.done THEN 

                                                                        IF Relay_DIR THEN 
                                                                            Relay_DIR := FALSE;
                                                                            is_Motor := Blind_control0_IN_IDLE;
                                                                            temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                            Relay_PWR := FALSE;
                                                                        END_IF;

                                                                    END_IF;

                                                                Blind_control0_IN_PreIDLE: 
                                                                    temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                    IF temporalCounter_i2.done THEN 
                                                                        is_Motor := Blind_control0_IN_IDLE;
                                                                        temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                        Relay_PWR := FALSE;
                                                                    END_IF;

                                                                Blind_control0_IN_UP_j: 

                                                                    CASE is_UP OF
                                                                        Blind_control0_IN_MOV_UP: 
                                                                            is_UP := c_Blind_contro_IN_NO_ACTIVE;
                                                                            UP_mode := FALSE;
                                                                            is_Motor := Blind_control0_IN_PreIDLE;
                                                                            temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                            Relay_PWR := FALSE;
                                                                        c_Blind_control0_IN_MOV_UP_: 
                                                                            temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                            IF temporalCounter_i2.done THEN 
                                                                                is_UP := Blind_control0_IN_MOV_UP;
                                                                                Relay_PWR := TRUE;
                                                                            ELSE 
                                                                                is_UP := c_Blind_contro_IN_NO_ACTIVE;
                                                                                UP_mode := FALSE;
                                                                                is_Motor := Blind_control0_IN_PreIDLE;
                                                                                temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                                Relay_PWR := FALSE;
                                                                            END_IF;

                                                                    END_CASE;

                                                            END_CASE;

                                                        END_IF;

                                                        is_Mode2 := c_Blind_control0_IN_Start_D;
                                                        temporalCounter_i1(timerAction := 1, maxTime := 0);

                                                        IF is_active_Motor <> 0 THEN 

                                                            CASE is_Motor OF
                                                                Blind_control0_IN_DOWN: 

                                                                    CASE is_DOWN OF
                                                                        Blind_control0_IN_MOV_DOWN: 
                                                                            ;
                                                                            ;
                                                                        c_Blind_control0_IN_MOV_DOW: 
                                                                            temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                            IF temporalCounter_i2.done THEN 
                                                                                is_DOWN := Blind_control0_IN_MOV_DOWN;
                                                                                Relay_PWR := TRUE;
                                                                            END_IF;

                                                                    END_CASE;

                                                                Blind_control0_IN_IDLE: 
                                                                    is_Motor := Blind_control0_IN_DOWN;
                                                                    DOWN_mode := TRUE;
                                                                    is_DOWN := c_Blind_control0_IN_MOV_DOW;
                                                                    temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                    Relay_DIR := FALSE;
                                                                Blind_control0_IN_PreIDLE: 
                                                                    temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                    IF temporalCounter_i2.done THEN 
                                                                        is_Motor := Blind_control0_IN_IDLE;
                                                                        temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                        Relay_PWR := FALSE;
                                                                    END_IF;

                                                                Blind_control0_IN_UP_j: 

                                                                    CASE is_UP OF
                                                                        Blind_control0_IN_MOV_UP: 
                                                                            ;
                                                                            ;
                                                                        c_Blind_control0_IN_MOV_UP_: 
                                                                            temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                            IF temporalCounter_i2.done THEN 
                                                                                is_UP := Blind_control0_IN_MOV_UP;
                                                                                Relay_PWR := TRUE;
                                                                            END_IF;

                                                                    END_CASE;

                                                            END_CASE;

                                                        END_IF;

                                                    END_IF;

                                                END_IF;

                                            Blind_control0_IN_Start_UP: 

                                                IF  NOT Btn_1 THEN 
                                                    is_Mode2 := Blind_control0_IN_Begin;
                                                    temporalCounter_i1(timerAction := 1, maxTime := 0);
                                                ELSE 
                                                    temporalCounter_i1(timerAction := 2, maxTime := TRUNC(REAL_TO_LREAL(Mot_timeout) * 1000.0));

                                                    IF temporalCounter_i1.done THEN 

                                                        IF is_active_Motor <> 0 THEN 

                                                            CASE is_Motor OF
                                                                Blind_control0_IN_DOWN: 

                                                                    CASE is_DOWN OF
                                                                        Blind_control0_IN_MOV_DOWN: 
                                                                            is_DOWN := c_Blind_contro_IN_NO_ACTIVE;
                                                                            DOWN_mode := FALSE;
                                                                            is_Motor := Blind_control0_IN_PreIDLE;
                                                                            temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                            Relay_PWR := FALSE;
                                                                        c_Blind_control0_IN_MOV_DOW: 
                                                                            temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                            IF temporalCounter_i2.done THEN 
                                                                                is_DOWN := Blind_control0_IN_MOV_DOWN;
                                                                                Relay_PWR := TRUE;
                                                                            ELSE 
                                                                                is_DOWN := c_Blind_contro_IN_NO_ACTIVE;
                                                                                DOWN_mode := FALSE;
                                                                                is_Motor := Blind_control0_IN_PreIDLE;
                                                                                temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                                Relay_PWR := FALSE;
                                                                            END_IF;

                                                                    END_CASE;

                                                                Blind_control0_IN_IDLE: 
                                                                    temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                    IF temporalCounter_i2.done THEN 

                                                                        IF Relay_DIR THEN 
                                                                            Relay_DIR := FALSE;
                                                                            is_Motor := Blind_control0_IN_IDLE;
                                                                            temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                            Relay_PWR := FALSE;
                                                                        END_IF;

                                                                    END_IF;

                                                                Blind_control0_IN_PreIDLE: 
                                                                    temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                    IF temporalCounter_i2.done THEN 
                                                                        is_Motor := Blind_control0_IN_IDLE;
                                                                        temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                        Relay_PWR := FALSE;
                                                                    END_IF;

                                                                Blind_control0_IN_UP_j: 

                                                                    CASE is_UP OF
                                                                        Blind_control0_IN_MOV_UP: 
                                                                            is_UP := c_Blind_contro_IN_NO_ACTIVE;
                                                                            UP_mode := FALSE;
                                                                            is_Motor := Blind_control0_IN_PreIDLE;
                                                                            temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                            Relay_PWR := FALSE;
                                                                        c_Blind_control0_IN_MOV_UP_: 
                                                                            temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                            IF temporalCounter_i2.done THEN 
                                                                                is_UP := Blind_control0_IN_MOV_UP;
                                                                                Relay_PWR := TRUE;
                                                                            ELSE 
                                                                                is_UP := c_Blind_contro_IN_NO_ACTIVE;
                                                                                UP_mode := FALSE;
                                                                                is_Motor := Blind_control0_IN_PreIDLE;
                                                                                temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                                Relay_PWR := FALSE;
                                                                            END_IF;

                                                                    END_CASE;

                                                            END_CASE;

                                                        END_IF;

                                                        is_Mode2 := Blind_control0_IN_Start_UP;
                                                        temporalCounter_i1(timerAction := 1, maxTime := 0);

                                                        IF is_active_Motor <> 0 THEN 

                                                            CASE is_Motor OF
                                                                Blind_control0_IN_DOWN: 

                                                                    CASE is_DOWN OF
                                                                        Blind_control0_IN_MOV_DOWN: 
                                                                            ;
                                                                            ;
                                                                        c_Blind_control0_IN_MOV_DOW: 
                                                                            temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                            IF temporalCounter_i2.done THEN 
                                                                                is_DOWN := Blind_control0_IN_MOV_DOWN;
                                                                                Relay_PWR := TRUE;
                                                                            END_IF;

                                                                    END_CASE;

                                                                Blind_control0_IN_IDLE: 
                                                                    is_Motor := Blind_control0_IN_UP_j;
                                                                    UP_mode := TRUE;
                                                                    is_UP := c_Blind_control0_IN_MOV_UP_;
                                                                    temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                    Relay_DIR := TRUE;
                                                                Blind_control0_IN_PreIDLE: 
                                                                    temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                    IF temporalCounter_i2.done THEN 
                                                                        is_Motor := Blind_control0_IN_IDLE;
                                                                        temporalCounter_i2(timerAction := 1, maxTime := 0);
                                                                        Relay_PWR := FALSE;
                                                                    END_IF;

                                                                Blind_control0_IN_UP_j: 

                                                                    CASE is_UP OF
                                                                        Blind_control0_IN_MOV_UP: 
                                                                            ;
                                                                            ;
                                                                        c_Blind_control0_IN_MOV_UP_: 
                                                                            temporalCounter_i2(timerAction := 2, maxTime := 100);

                                                                            IF temporalCounter_i2.done THEN 
                                                                                is_UP := Blind_control0_IN_MOV_UP;
                                                                                Relay_PWR := TRUE;
                                                                            END_IF;

                                                                    END_CASE;

                                                            END_CASE;

                                                        END_IF;

                                                    END_IF;

                                                END_IF;

                                            c_Blind_control0_IN_Stop_mo: 

                                                IF (is_Motor = 2) AND tmp THEN 
                                                    is_Mode2 := Blind_control0_IN_Begin;
                                                    temporalCounter_i1(timerAction := 1, maxTime := 0);
                                                END_IF;

                                        END_CASE;

                                    END_IF;

                            END_CASE;

                        END_IF;

                END_CASE;


                IF temp2 THEN 
                    HMI_Btn_Down_req := FALSE;
                    HMI_Btn_Stop_req := FALSE;
                    is_HMI_control := Blind_control0_IN_DoStop;
                    temporalCounter_i1(timerAction := 1, maxTime := 0);

                    IF is_active_Motor <> 0 THEN 

                        CASE is_Motor OF
                            Blind_control0_IN_DOWN: 

                                CASE is_DOWN OF
                                    Blind_control0_IN_MOV_DOWN: 
                                        is_DOWN := c_Blind_contro_IN_NO_ACTIVE;
                                        DOWN_mode := FALSE;
                                        is_Motor := Blind_control0_IN_PreIDLE;
                                        temporalCounter_i2(timerAction := 1, maxTime := 0);
                                        Relay_PWR := FALSE;
                                    c_Blind_control0_IN_MOV_DOW: 
                                        temporalCounter_i2(timerAction := 2, maxTime := 100);

                                        IF temporalCounter_i2.done THEN 
                                            is_DOWN := Blind_control0_IN_MOV_DOWN;
                                            Relay_PWR := TRUE;
                                        ELSE 
                                            is_DOWN := c_Blind_contro_IN_NO_ACTIVE;
                                            DOWN_mode := FALSE;
                                            is_Motor := Blind_control0_IN_PreIDLE;
                                            temporalCounter_i2(timerAction := 1, maxTime := 0);
                                            Relay_PWR := FALSE;
                                        END_IF;

                                END_CASE;

                            Blind_control0_IN_IDLE: 
                                temporalCounter_i2(timerAction := 2, maxTime := 100);

                                IF temporalCounter_i2.done THEN 

                                    IF Relay_DIR THEN 
                                        Relay_DIR := FALSE;
                                        is_Motor := Blind_control0_IN_IDLE;
                                        temporalCounter_i2(timerAction := 1, maxTime := 0);
                                        Relay_PWR := FALSE;
                                    END_IF;

                                END_IF;

                            Blind_control0_IN_PreIDLE: 
                                temporalCounter_i2(timerAction := 2, maxTime := 100);

                                IF temporalCounter_i2.done THEN 
                                    is_Motor := Blind_control0_IN_IDLE;
                                    temporalCounter_i2(timerAction := 1, maxTime := 0);
                                    Relay_PWR := FALSE;
                                END_IF;

                            Blind_control0_IN_UP_j: 

                                CASE is_UP OF
                                    Blind_control0_IN_MOV_UP: 
                                        is_UP := c_Blind_contro_IN_NO_ACTIVE;
                                        UP_mode := FALSE;
                                        is_Motor := Blind_control0_IN_PreIDLE;
                                        temporalCounter_i2(timerAction := 1, maxTime := 0);
                                        Relay_PWR := FALSE;
                                    c_Blind_control0_IN_MOV_UP_: 
                                        temporalCounter_i2(timerAction := 2, maxTime := 100);

                                        IF temporalCounter_i2.done THEN 
                                            is_UP := Blind_control0_IN_MOV_UP;
                                            Relay_PWR := TRUE;
                                        ELSE 
                                            is_UP := c_Blind_contro_IN_NO_ACTIVE;
                                            UP_mode := FALSE;
                                            is_Motor := Blind_control0_IN_PreIDLE;
                                            temporalCounter_i2(timerAction := 1, maxTime := 0);
                                            Relay_PWR := FALSE;
                                        END_IF;

                                END_CASE;

                        END_CASE;

                    END_IF;

                END_IF;


                IF temp1 THEN 
                    HMI_Btn_UP_req := FALSE;
                    HMI_Btn_Stop_req := FALSE;
                    is_HMI_control := Blind_control0_IN_DoStop;
                    temporalCounter_i1(timerAction := 1, maxTime := 0);

                    IF is_active_Motor <> 0 THEN 

                        CASE is_Motor OF
                            Blind_control0_IN_DOWN: 

                                CASE is_DOWN OF
                                    Blind_control0_IN_MOV_DOWN: 
                                        is_DOWN := c_Blind_contro_IN_NO_ACTIVE;
                                        DOWN_mode := FALSE;
                                        is_Motor := Blind_control0_IN_PreIDLE;
                                        temporalCounter_i2(timerAction := 1, maxTime := 0);
                                        Relay_PWR := FALSE;
                                    c_Blind_control0_IN_MOV_DOW: 
                                        temporalCounter_i2(timerAction := 2, maxTime := 100);

                                        IF temporalCounter_i2.done THEN 
                                            is_DOWN := Blind_control0_IN_MOV_DOWN;
                                            Relay_PWR := TRUE;
                                        ELSE 
                                            is_DOWN := c_Blind_contro_IN_NO_ACTIVE;
                                            DOWN_mode := FALSE;
                                            is_Motor := Blind_control0_IN_PreIDLE;
                                            temporalCounter_i2(timerAction := 1, maxTime := 0);
                                            Relay_PWR := FALSE;
                                        END_IF;

                                END_CASE;

                            Blind_control0_IN_IDLE: 
                                temporalCounter_i2(timerAction := 2, maxTime := 100);

                                IF temporalCounter_i2.done THEN 

                                    IF Relay_DIR THEN 
                                        Relay_DIR := FALSE;
                                        is_Motor := Blind_control0_IN_IDLE;
                                        temporalCounter_i2(timerAction := 1, maxTime := 0);
                                        Relay_PWR := FALSE;
                                    END_IF;

                                END_IF;

                            Blind_control0_IN_PreIDLE: 
                                temporalCounter_i2(timerAction := 2, maxTime := 100);

                                IF temporalCounter_i2.done THEN 
                                    is_Motor := Blind_control0_IN_IDLE;
                                    temporalCounter_i2(timerAction := 1, maxTime := 0);
                                    Relay_PWR := FALSE;
                                END_IF;

                            Blind_control0_IN_UP_j: 

                                CASE is_UP OF
                                    Blind_control0_IN_MOV_UP: 
                                        is_UP := c_Blind_contro_IN_NO_ACTIVE;
                                        UP_mode := FALSE;
                                        is_Motor := Blind_control0_IN_PreIDLE;
                                        temporalCounter_i2(timerAction := 1, maxTime := 0);
                                        Relay_PWR := FALSE;
                                    c_Blind_control0_IN_MOV_UP_: 
                                        temporalCounter_i2(timerAction := 2, maxTime := 100);

                                        IF temporalCounter_i2.done THEN 
                                            is_UP := Blind_control0_IN_MOV_UP;
                                            Relay_PWR := TRUE;
                                        ELSE 
                                            is_UP := c_Blind_contro_IN_NO_ACTIVE;
                                            UP_mode := FALSE;
                                            is_Motor := Blind_control0_IN_PreIDLE;
                                            temporalCounter_i2(timerAction := 1, maxTime := 0);
                                            Relay_PWR := FALSE;
                                        END_IF;

                                END_CASE;

                        END_CASE;

                    END_IF;

                END_IF;

            END_IF;


            IF (is_active_HMI_buttons <> 0) AND (is_HMI_buttons = 1) THEN 

                IF rtb_FixPtRelationalOperator THEN 
                    HMI_Btn_UP_req := TRUE;
                    HMI_req := TRUE;
                    local_block := TRUE;
                    is_HMI_buttons := Blind_control0_IN_Btns;
                ELSIF c_rtb_FixPtRelationalOperat THEN 
                    HMI_Btn_Stop_req := TRUE;
                    HMI_req := TRUE;
                    local_block := TRUE;
                    is_HMI_buttons := Blind_control0_IN_Btns;
                ELSIF b_rtb_FixPtRelationalOperat THEN 
                    HMI_Btn_Down_req := TRUE;
                    HMI_req := TRUE;
                    local_block := TRUE;
                    is_HMI_buttons := Blind_control0_IN_Btns;
                END_IF;

            END_IF;

        END_IF;

        DelayInput1_DSTATE := HMI_Btn_Up;
        DelayInput1_DSTATE_i := HMI_Btn_Down;
        DelayInput1_DSTATE_m := HMI_Btn_Stop;
END_CASE;

Размер кода больше 240 Кб и он рабочий!
Код был откомпилирован в среде e!COCKPIT , загружен в ПЛК и протестирован.

Но попытка все реализовать внутри ПЛК привела к большому объему кода. В исходном тексте на языке STL такой программы уже невозможно ориентироваться. Выручает только графическая нотация MATLAB Stateflow.

С другой стороны проект совершенно не зависит от кода на стороне HMI. На HMI могут быть только кнопки отражающие состояния переменных в ПЛК и никакого кода.
Стоит отметить, что нередко HMI программируются даже не на STL, а например, на неких диалектах BASIC и прочей экзотике и это еще более усложняет программирование скриптов HMI.

Словом централизация кода с точки зрения создания систем на ПЛК удобна если вы работаете в одиночку, без детального утвержденного ТЗ, и с неясным составом оборудования. Но даже в этом случае лучше подумать о более прогрессивных нотациях чем стандартная пятерка: LAD, FBD, SFC, ST, IL.

Комментарии (15)


  1. hooperer
    04.10.2021 17:49
    +1

    Многие ПЛК позволяют реализовать подпрограммы.

    А некоторые ещё и позволяют делать "библиотечные типы"

    но Вы наверняка и сами это знаете.

    Код обширный, даже возникает соблазн его запустить и проверить)


    1. Indemsys Автор
      05.10.2021 10:27

      Согласен.
      Более того, исходник полученный из матлаба был завернут в переиспользуемый компонент в ПЛК с простым интерфейсом.


  1. Efi-fi
    04.10.2021 18:20
    +3

    Даже несмотря на возможность создавать подпрограммы, функциональные блоки, функции и т. д., многие не хотят разбираться в новых возможностях и "по красоте" переписывать старые куски кода. Я в таких случая обычно с 0 всё делаю, но это не всегда возможно по времени и желанию.

    Спасибо за практический пример - добавлю на него ссылку в статье.


  1. tzlom
    04.10.2021 20:00
    +2

    Правда когда это на реальном контроллере не заведется круто уже не будет.


  1. Dotarev
    05.10.2021 07:42
    +1

    В MATLAB я и начал разработку, чтобы не изучать глубоко языки ПЛК и их библиотеки.

    Отсюда и результат: многословный плохо поддерживаемый код. ST+SFC — всё что Вам нужно было изучить. Два дня на вхождение, если неплохо знаете MatLab.


  1. PR200SD
    05.10.2021 08:48

    Какой-то сильно серьезный заплет для такой простой задачи, еще и Matlab тут, с таким справится даже ПР100 на FBD я думаю, и сразу же в симуляции можно все проверить.


    1. Anton_Andreevich
      05.10.2021 09:09

      Я одним ПР200 двумя шторами управлял :)

      управление было как в этом варианте

      Сценарий 1 управления одной кнопкой

      • 1.Нажали кнопку и отпустили - движется вверх

      • 2.Нажали кнопку - остановка

      • 3.Нажали кнопку - движется вниз

      • 4.Нажали кнопку - остановка

      • Переход к пункту 1

      правда ещё с этой кнопки можно было отметить верхнее и нижнее положение шторы (для настройки).


  1. sudalin
    05.10.2021 10:27

    Хороший, скорее всего, пример.

    Однако вот что не понятно, а почему все реализовано в одном огромном блоке? Если можно отдельно описать каждый из способов, потом результат завести в какой-нибудь блок сравнения, где согласно приоритетов будет уже один управляющий сигнал, который и будет заходить fb управления рольставнями.

    При таком подходе мы получаем три блока управления, которые можно использовать. Блок выбора приоритетного сигнала, который тоже можно где угодно использовать и блок управления самими рольставнями. Где, хотя бы, можно легко изменить нужную логику.


    1. Indemsys Автор
      05.10.2021 10:41

      Потому что я не писал там сам ни строчки кода.
      Это все сгенерировал MATLAB.
      Вернее MATLAB сгенерировал полный текст компонента для ПЛК в виде XML файла с STL программой. Мне оставалось лишь импортировать этот файл в среду разработки WAGO и потом вызывать его как стандартный компонент.
      А в статье я дал сам код STL без всего содержимого XML файла, поскольку оно не существенно.
      Т.е. на самом деле тот исходник я не то что не изучал, но даже не смотрел вовсе. Он не представляет никакого интереса. Я с ним непосредственно не работаю и не рефакторю.
      Этот исходник полностью рабочий поскольку он протестировал неоднократно и даже укладывается в цикл 10 мс для ПЛК средней производительности.

      Интерес представляет только исходная диаграмма в Stateflow. Только в ней я меняю логику, меняю даже архитектуру просто создавая, удаляя, совмещая или разделяя разные автоматы состояний. И вот по поводу нее и стоило бы подискутировать. Правильно ли я идентифицировал состояния, правильно ли изолировал их, правильные ли условия в переходах и нет ли где-то избыточности. Может быть сам дизайн диаграммы недостаточно читабелен, может иерархия блоков недостаточная или избыточная. Как диаграмма приспособлена для рефакторинга. Вот только такие вопросы важны если вы работает с No-Code технологией типа MATLAB - Simulink - Stateflow.

      Кстати сейчас только заметил что не все блоки модели раскрыл для обозрения.
      Если будут пожелания могу выложить на Github этот проект, хотя это будет стоить мне времени.


      1. PR200SD
        05.10.2021 11:59

        Интересно что выдаст матлаб, если запихнуть в него уравнение для получения температуры по сопротивлению Pt1000 например. На FBD это довольно большое кол-во блоков, на ST пару строчек.


        1. Indemsys Автор
          05.10.2021 13:21

          На STL такое делать не пробовал.
          У семейств ПЛК либо есть отдельный специализированный модуль сразу это вычисляющий, либо я делаю свою плату с микроконтроллером и там уже генерю для него исходники не на STL, а на чистом C++. И поскольку использую ARM Cortex, то там с учетом мат.сопроцессора MATLAB выдаст это одной строкой. Правда файлов в итоге получиться много, так как MATLAB не генерит примитивные сниппеты, а генерит полностью законченные проекты с функцией main, API, всеми объявлениями своих типов, хидерами и проч.


  1. pt200
    05.10.2021 16:41

    А как отлаживать такой сгенеренный код?


    1. Indemsys Автор
      05.10.2021 17:15

      Никак.

      Отлаживается модель в MATLAB-е, а не сгенерированный исходник.
      Для того на верхнем уровне у меня и изображена модель в окружении тестовой оснастки в которую входят генераторы последовательностей тестовых сигналов, блоки тестовых констант, блоки визуализации сигналов на выходах и проч.

      Тут просто надо довериться сгенеренному коду. С другой стороны все же доверяются компиляторам, интерпретаторам, библиотекам и т.д.
      Понятно что такое доверие не сразу возникнет. Нужен некоторый опыт применения и разграничения: что делать в матлабе, а что кодить напрямую.


  1. freemanon
    06.10.2021 14:01

    Модель самой рольставни вы не делали? Использование Simulink PLC Coder это же часть Model Based Design, где все начинается с модели объекта управления.


    1. Indemsys Автор
      06.10.2021 15:24

      Что вы подразумеваете под моделью?
      На каком уровне детализации?
      Получить точную модель физических рольставней нереально.
      Сам движок рольставней - черный ящик.
      Отчасти потому модельный подход Stateflow и применен. Поскольку были опасения за слишком частые изменения архитектуры конечных автоматов управления. Так оно и произошло. Вместо двух состояний двигателя - включен, выключен, появилось много состояний. И это от того что модель рольставней упирается во множество неопределенностей. Модель меняется после каждых неудачных натурных испытаний.

      С другой стороны частично логическая модель мотора у меня представлена блоком Motor.
      В этом блоке отражены основные состояния мотора с его коммутирующими элементами насколько удалось идентифицировать эти состояния.
      Тут надо понять что у меня нет никакой обратной связи от рольставней. Поэтому управление идет по внутренней модели выполненной в блоке Motor.