fbdrt.h

/**
 * @file fbdrt.h
 * @author crossrw1@gmail.com
 * @brief FBD-Runtime Library Headers
 * @version 11.0
 * @date 13-02-2026
 */

#ifndef FBDRT_H
#define	FBDRT_H

#include <stdbool.h>        // for true/false definition
#include <stdint.h>         // type definition

// 7    - базовая
// 8    - поддержка экранов
// 9    - Modbus
// 10   - журналы и элемент MOD
// 11   - сумматор с установкой значения
#define FBD_LIB_VERSION 11

// описание упакованной структуры
#if defined ( __CC_ARM   )
  #define __packed_struct           __packed struct
#elif defined   (  __GNUC__  )
  #define __packed_struct           struct __attribute__ ((__packed__))
#elif defined   (  __TASKING__  )
  #define __packed_struct           struct __packed
#endif

//
//
// =========================================================================
// = начало настроек =======================================================
//
// определение порядка байт, по умолчанию используется LOW_ENDIAN
//#define BIG_ENDIAN
//
// размер памяти для сигнала схемы (1, 2 или 4)
#define SIGNAL_SIZE 4
//
// размер пямяти для индекса элемента (1 или 2)
#define INDEX_SIZE 2
//
// префикс и суфикс используемые для определения памяти в ROM или FLASH
#define ROM_CONST const
#define ROM_CONST_SUFX
//
// префикс и суфикс используемые для определения памяти в которой хранится описание схемы
#define DESCR_MEM const
#define DESCR_MEM_SUFX
//
// нобходимо определить символ USE_HMI если планируете использовать функции HMI
#define USE_HMI
//
#ifdef USE_HMI
// нобходимо определить символ USE_EVENTS если планируете использовать события и журнал
#define USE_EVENTS
#endif


//
// нобходимо определить символ USE_MATH если планируете использовать генератор sin
#define USE_MATH
//
// максимальный размер стека, используемый при расчете схемы
// один элемент стека занимает (sizeof(tElemIndex)+1) байт
#define FBDSTACKSIZE        128
#define FBDSTACKSIZEMASK    (FBDSTACKSIZE-1)
//
// data type for stack pointer
typedef uint8_t tFBDStackPnt;
//
typedef int32_t tLongSignal;
//
// размер NVRAM
#define NVRAMSIZE 4096
//
// максимальный индекс при обрашении к NVRAM
#define MAXNVRAMINDEX (NVRAMSIZE/SIGNAL_SIZE-1)

//
// = конец настроек ========================================================
// =========================================================================
//
// типы элементов:
#define ELEMMASK    0x3F
#define INVERTFLAG  0x40
#define ELEMENDFLAG 0x80
//
// Описание элемента
// | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
// +---+---+---+---+---+---+---+---+
// | 0 |INV|     ELEMENT_TYPE      |
//
//
typedef enum {
    ELEM_OUT_PIN =  0,
    ELEM_CONST   =  1,
    ELEM_NOT     =  2,
    ELEM_AND     =  3,
    ELEM_OR      =  4,
    ELEM_XOR     =  5,
    ELEM_RSTRG   =  6,
    ELEM_DTRG    =  7,
    ELEM_ADD     =  8,
    ELEM_SUB     =  9,
    ELEM_MUL     =  10,
    ELEM_DIV     =  11,
    ELEM_TON     =  12,
    ELEM_CMP     =  13,
    ELEM_OUT_VAR =  14,
    ELEM_INP_PIN =  15,
    ELEM_INP_VAR =  16,
    ELEM_PID     =  17,
    ELEM_SUM     =  18,
    ELEM_COUNTER =  19,
    ELEM_MUX     =  20,
    ELEM_ABS     =  21,
    ELEM_WP      =  22,
    ELEM_SP      =  23,
    ELEM_TP      =  24,
    ELEM_MIN     =  25,
    ELEM_MAX     =  26,
    ELEM_LIM     =  27,
    ELEM_EQ      =  28,
    ELEM_BAND    =  29,
    ELEM_BOR     =  30,
    ELEM_BXOR    =  31,
    ELEM_GEN     =  32,
    ELEM_INP_MDBS=  33,
    ELEM_OUT_MDBS=  34,
    ELEM_MOD     =  35,
    ELEM_MFUN    =  36,
    ELEM_EVENT   =  37,
    ELEM_LUT     =  38,
    ELEM_NLUT    =  39,
    ELEM_SUMM    =  40,         // интегратор с записью значений
    //
    ELEM_TYPE_COUNT
} tFBD_ELEMENT_TYPE;

enum FBD_GETSETTYPE {
    FBD_PIN     = 0,            // входной/выходной сигнал
    FBD_NVRAM   = 1,            // значение NVRAM
    FBD_HRDW    = 2             // значение параметра аппаратуры
};

enum FBD_GETHRDWTYPE {
    FBD_HRDW_ETH    = 0,        // статус Ethernet
    FBD_HRDW_NTP    = 1,        // статус NTP
    FBD_HRDW_TZO    = 2,        // смещение TimeZone в минутах
    FBD_HRDW_BAT    = 3         // напряжение батареи в 0.01В
};

//
#ifdef USE_MATH
#include <math.h>
#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif // M_PI
#endif // USE_MATH

typedef uint16_t tOffset;
//
#if defined(BIG_ENDIAN) && (SIGNAL_SIZE > 1)
#define SIGNAL_BYTE_ORDER(x) lotobigsign(x)
#else
#define SIGNAL_BYTE_ORDER(x) (x)
#endif // defined

#if defined(BIG_ENDIAN) && (INDEX_SIZE > 1)
#define ELEMINDEX_BYTE_ORDER(x) lotobigidx(x)
#else
#define ELEMINDEX_BYTE_ORDER(x) (x)
#endif // defined

#if (SIGNAL_SIZE == 1)
typedef int8_t tSignal;
#define MAX_SIGNAL INT8_MAX
#define MIN_SIGNAL INT8_MIN
//
#elif (SIGNAL_SIZE == 2)
typedef int16_t tSignal;
#define MAX_SIGNAL INT16_MAX
#define MIN_SIGNAL INT16_MIN
//
#elif (SIGNAL_SIZE == 4)
typedef int32_t tSignal;
#define MAX_SIGNAL INT32_MAX
#define MIN_SIGNAL INT32_MIN
#else
#error Invalid value of SIGNAL_SIZE
#endif // SIGNAL_SIZE
//
#if INDEX_SIZE == 1
typedef uint8_t tElemIndex;
#define MAX_INDEX UINT8_MAX
#elif INDEX_SIZE == 2
typedef uint16_t tElemIndex;
#define MAX_INDEX UINT16_MAX
#else
#error Invalid value of INDEX_SIZE
#endif // INDEX_SIZE
//
// end element description flag
#define END_MARK (unsigned char)((sizeof(tSignal)|(sizeof(tElemIndex)<<3))|0x80)
// END_MARK:
// bit 0-2: sizeof(tSignal)
// bit 3-4: sizeof(tElemIndex)
// bit 5:   reserved
// bit 6:   reserved
// bit 7:   1

// коды ошибок, возвращаемые fbdInit()
typedef enum {
    ERR_INVALID_ELEMENT_TYPE    =   -1,
    ERR_INVALID_SIZE_TYPE       =   -2,
    ERR_INVALID_LIB_VERSION     =   -3,
    ERR_INVALID_CHECK_SUM       =   -4
} FBD_INIT_RESULT;

// -------------------------------------------------------------------------------------------------------
// Инициализация схемы
// -------------------------------------------------------------------------------------------------------

int fbdInit(DESCR_MEM unsigned char *descr);

void fbdSetMemory(char *buf, bool needReset);

void fbdDoStep(tSignal period);

// -------------------------------------------------------------------------------------------------------
// Экраны
// -------------------------------------------------------------------------------------------------------
#ifdef USE_HMI

#define SCREEN_WIDTH 320
#define SCREEN_HEIGHT 240

typedef uint16_t tScreenDim;
typedef uint16_t tColor;

// описание структуры экрана
typedef __packed_struct Screen_t {
    uint16_t len;                                               // размер экрана                    2
    tColor bkcolor;                                             // цвет фона                        2
    uint16_t period;                                            // период обновления                2
    uint16_t elemCount;                                         // количество элементов экрана      2
    // тут элементы экрана
} tScreen;

// описание элементов экрана
// базовый элемент с видимостью
typedef __packed_struct ScrElemBase_t {
    uint16_t len;                                               // размер структуры                 2
    uint16_t type;                                              // тип элемента                     2
    //
    uint16_t visibleCond;                                       // условие видимости                2
    tElemIndex visibleElem;                                     // индекс элемента                  2
    tSignal visibleValue;                                       // константа - значение сигнала     4
    //
    tScreenDim x1;                                              // координата x                     2
    tScreenDim y1;                                              // координата y                     2
} tScrElemBase;

// элемент прямоугольник
typedef __packed_struct ScrElemRect_t {
    tScrElemBase parent;                                        //                                  16
    //
    tScreenDim x2;                                              // координата x2                    2
    tScreenDim y2;                                              // координата y2                    2
    tColor color;                                               // цвет                             2
    uint16_t reserve;                                           //                                  2
} tScrElemRect;

// элемент эллипс
typedef __packed_struct ScrElemCircle_t {
    tScrElemBase parent;                                        //                                  16
    //
    tScreenDim x2;                                              // координата x2                    2
    tScreenDim y2;                                              // координата y2                    2
    tColor color;                                               // цвет                             2
    uint16_t reserve;                                           //                                  2
} tScrElemCircle;

// элемент линия
typedef __packed_struct ScrElemLine_t {
    tScrElemBase parent;                                        //                                  16
    //
    tScreenDim x2;                                              // координата x2                    2
    tScreenDim y2;                                              // координата y2                    2
    tColor color;                                               // цвет                             2
    tScreenDim width;                                           // толщина линии                    2
    float sine;                                                 //                                  4
    float cosinus;                                              //                                  4
} tScrElemLine;

// элемент картинка
typedef __packed_struct ScrElemImage_t {
    tScrElemBase parent;                                        //                                  16
    //
    uint16_t index;                                             // индекс картинки                  2
    uint16_t reserve;                                           //                                  2 !!!
} tScrElemImage;

// элемент текст
typedef __packed_struct ScrElemText_t {
    tScrElemBase parent;                                        //                                  16
    //
    tColor color;                                               // цвет                             2
    tColor bkcolor;                                             // цвет фона                        2
    //
    tElemIndex valueElem;                                       // индекс элемента                  2
    uint8_t font;                                               // индекс шрифта, старший бит прозрачность 1
    uint8_t divider;                                            // делитель                         1
    char text[];                                                // сам текст, заканчивается 0       длинна должны быть кратна 4 !
} tScrElemText;

// элемент шкала
typedef __packed_struct ScrElemGauge_t {
    tScrElemBase parent;                                        //                                  16
    //
    tScreenDim x2;                                              // координата x2                    2
    tScreenDim y2;                                              // координата y2                    2
    //
    tColor color;                                               // цвет                             2
    tColor bkcolor;                                             // цвет фона                        2
    //
    tSignal maxvalue;                                           // максимальное значение шкалы      4
    tElemIndex valueElem;                                       // индекс элемента                  2
    uint16_t orientation;                                       // ориентация: 0 - гор, 1 - вер     2
} tScrElemGauge;

// один шаг вычисления схемы с последующим рисованием (при необходимости) экрана screen
void fbdDoStepEx(tSignal period, short screenIndex);

// перечисление используется в процедуре отрисовки текcтовых сообщений на экране для получения текущего времени
enum GP_RTC_PARAMS {
    GP_RTC_HOUR     =  20,
    GP_RTC_MINUTE   =  21,
    GP_RTC_SECOND   =  22,
    GP_RTC_DAY      =  23,
    GP_RTC_MONTH    =  24,
    GP_RTC_YEAR     =  25,
    GP_RTC_WDAY     =  26               // 1 - понедельник, 2 - вторник ...
};
#endif

// -------------------------------------------------------------------------------------------------------
// Сетевые переменные
// -------------------------------------------------------------------------------------------------------
//
// структура описания сетевой переменной
typedef struct netvar_t {
    tSignal index;              // номер сетевой переменной
    tSignal value;              // значение сетевой переменной
} tNetVar;
//
void fbdSetNetVar(const tNetVar *netvar);
//
bool fbdGetNetVar(tNetVar *netvar);
//
void fbdChangeAllNetVars(void);

// -------------------------------------------------------------------------------------------------------
// MODBUS
// -------------------------------------------------------------------------------------------------------
//
// настройки последовательного порта для Modbus RTU
//
// скорость обмена:
typedef enum {
    FBD_BR_1200                 = 0,
    FBD_BR_2400                 = 1,
    FBD_BR_4800                 = 2,
    FBD_BR_9600                 = 3,
    FBD_BR_19200                = 4,
    FBD_BR_38400                = 5,
    FBD_BR_57600                = 6,
    FBD_BR_115200               = 7
} tFBD_BAUDRATE;
//
// контроль чётности:
typedef enum {
    FBD_PAR_NONE                = 0,
    FBD_PAR_ODD                 = 1,
    FBD_PAR_EVEN                = 2
} tFBD_PARITY;
//
// стоп-биты:
typedef enum {
    FBD_SB_1                    = 0,
    FBD_SB_2                    = 1
} tFBD_STOPB;
//
// статус использования Modbus
typedef enum {
    FBD_MODBUS_NONE             = 0,
    FBD_MODBUS_RTU              = 1,
    FBD_MODBUS_TCP              = 2,
    FBD_MODBUS_BOTH             = 3
} tFBD_MODBUS_USAGE;
//
// функция Modbus
typedef enum {
    FBD_MODBUS_READ_COILS               = 1,
    FBD_MODBUS_READ_DISCRETE_INPUTS     = 2,
    FBD_MODBUS_READ_HOLDING_REGISTERS   = 3,
    FBD_MODBUS_READ_INPUT_REGISTERS     = 4,
    //
    FBD_MODBUS_WRITE_SINGLE_COIL        = 5,
    FBD_MODBUS_WRITE_SINGLE_REGISTER    = 6,
    FBD_MODBUS_WRITE_MULTIPLE_COILS     = 15,
    FBD_MODBUS_WRITE_MULTIPLE_REGISTERS = 16
} tFBD_MODBUS_FUNCTION;

// структура описания настроек последовательного порта Modbus RTU
typedef struct modbusrtusettings_t {
    unsigned int timeout;                   // время одидания ответа в мс (0..4095)
    tFBD_BAUDRATE baudRate;                 // скорость обмена
    tFBD_PARITY parity;                     // контроль чётности: 0-None, 1-Odd, 2-Even
    tFBD_STOPB stopBits;                    // количество стоп-бит: 0-1, 1-2
} tModbusRTUsettings;

// данные Modbus
typedef union {
    tSignal         intData;
    float           floatData;
    uint16_t        ushortData[2];
    int16_t         shortData[2];
    uint8_t         byteData[4];
} tModbusData;

// структура описания запроса MODBUS
typedef struct modbusreq_t {
    tSignal ip;                             // ip адрес устройства, если ==0, то использовать протокол RTU
    uint8_t slaveAddr;                      // адрес устройства
    tFBD_MODBUS_FUNCTION funcCode;          // код функции
    uint16_t regAddr;                       // адрес регистра ModBus
    uint16_t regCount;                      // количество регистров
    tModbusData data;                       // данные, только для запросов записи
} tModbusReq;

// modbus bytes order
#define FBD_MODBUS_OPT_BO 0x04000000
// modbus words order
#define FBD_MODBUS_OPT_WO 0x08000000

// Получить статус использования Modbus загруженной схемой
// Вызывать только после выполнения "fbdSetMemory()"
// Результат выполнения:
//  FBD_MODBUS_NONE   - Modbus не используется
//  FBD_MODBUS_RTU    - Используется только Modbus RTU
//  FBD_MODBUS_TCP    - Используется только Modbus TCP
//  FBD_MODBUS_BOTH   - Используется только Modbus RTU и TCP
tFBD_MODBUS_USAGE fbdModbusUsage(void);

// Получить значения настроек Modbus RTU
// Вызывать только после выполнения "fbdSetMemory()"
// Результат выполнения:
//  false - менять настройки последовательного порта не надо (использовать текущие)
//  true  - необходимо установить значения настроек последовательного порта, настройки помещены в структуру *pnt
bool fbdModbusGetSerialSettings(tModbusRTUsettings *pnt);

// Modbus RTU

// Получить очередной запрос ModBus RTU для выполнения
// Результат выполнения:
//  false - запросов больше нет
//  true  - запрос есть, он помещен в структуру mbrequest
bool fbdGetNextModbusRTURequest(tModbusReq *mbrequest);
//
// Установка результата успешного выполнения предыдущего запроса Modbus RTU.
// Функция должна быть вызвана после успешного получения ответа на запрос Modbus RTU.
// Параметр response - данные возвращённые запросом.
void fbdSetModbusRTUResponse(tSignal response);
//
// Установить признак неуспешного результата полученного ранее запроса ModBus RTU
// Функция должна быть вызвана после неудачного выполнения запроса Modbus RTU
void fbdSetModbusRTUNoResponse(int errCode);

// Modbus TCP

// Получить очередной запрос ModBus TCP для выполнения
// Результат выполнения:
//  false - запросов больше нет
//  true  - запрос есть, он помещен в структуру mbrequest
bool fbdGetNextModbusTCPRequest(tModbusReq *mbrequest);
//
// Установка результата успешного выполнения предыдущего запроса Modbus TCP.
// Функция должна быть вызвана после успешного получения ответа на запрос Modbus TCP.
// Параметр response - данные возвращённые запросом.
void fbdSetModbusTCPResponse(tSignal response);
//
// Установить признак неуспешного результата полученного ранее запроса ModBus TCP
// Функция должна быть вызвана после неудачного выполнения запроса Modbus TCP
void fbdSetModbusTCPNoResponse(int errCode);

// -------------------------------------------------------------------------------------------------------
// Получение значений глобальных настроек схемы
// -------------------------------------------------------------------------------------------------------
// 
enum FBD_OPTIONS {
    FBD_OPT_REQ_VERSION     = 0,
    FBD_OPT_NETVAR_USE      = 1,
    FBD_OPT_NETVAR_PORT     = 2,
    FBD_OPT_NETVAR_GROUP    = 3,
    FBD_OPT_SCREEN_COUNT    = 4,
    FBD_OPT_SCHEMA_SIZE     = 5,
    FBD_OPT_HINTS_COUNT     = 6,
    FBD_OPT_MODBUSRTU_OPT   = 7,
    FBD_OPT_MODBUSRTU_OPT2  = 8,
    FBD_OPT_EVENTS_COUNT    = 9
};

extern DESCR_MEM unsigned char DESCR_MEM_SUFX *fbdGlobalOptionsCount;
extern DESCR_MEM tSignal DESCR_MEM_SUFX *fbdGlobalOptions;
#define FBD_REQ_VERSION         fbdGlobalOptions[FBD_OPT_REQ_VERSION]
#define FBD_NETVAR_USE          fbdGlobalOptions[FBD_OPT_NETVAR_USE]
#define FBD_NETVAR_PORT         fbdGlobalOptions[FBD_OPT_NETVAR_PORT]
#define FBD_NETVAR_GROUP        fbdGlobalOptions[FBD_OPT_NETVAR_GROUP]
#define FBD_SCREEN_COUNT        ((*fbdGlobalOptionsCount>FBD_OPT_SCREEN_COUNT)?fbdGlobalOptions[FBD_OPT_SCREEN_COUNT]:0)
#define FBD_SCHEMA_SIZE         ((*fbdGlobalOptionsCount>FBD_OPT_SCHEMA_SIZE)?fbdGlobalOptions[FBD_OPT_SCHEMA_SIZE]:0)
#define FBD_HINTS_COUNT         ((*fbdGlobalOptionsCount>FBD_OPT_HINTS_COUNT)?fbdGlobalOptions[FBD_OPT_HINTS_COUNT]:0)
#define FBD_MODBUSRTU_OPT       ((*fbdGlobalOptionsCount>FBD_OPT_MODBUSRTU_OPT)?fbdGlobalOptions[FBD_OPT_MODBUSRTU_OPT]:0)
#define FBD_MODBUSRTU_OPT2      ((*fbdGlobalOptionsCount>FBD_OPT_MODBUSRTU_OPT2)?fbdGlobalOptions[FBD_OPT_MODBUSRTU_OPT2]:0)
#define FBD_MODBUS_RETRYCOUNT   ((FBD_MODBUSRTU_OPT >> 19) & 3)
#define FBD_MODBUS_PAUSE        ((FBD_MODBUSRTU_OPT >> 21) & 1023)
#define FBD_MODBUSRTU_DELAY     (FBD_MODBUSRTU_OPT2 & 255)
#define FBD_MODBUSSAVEOLDVALUE  ((FBD_MODBUSRTU_OPT2 >> 8) & 1)

#define FBD_EVENTS_COUNT        ((*fbdGlobalOptionsCount>FBD_OPT_EVENTS_COUNT)?fbdGlobalOptions[FBD_OPT_EVENTS_COUNT]:0)

// FBD_MODBUS_OPT
// |31|30|29|28|27|26|25|24|23|22|21|20|19|18|17|16|15|14|13|12|11|10| 9| 8| 7| 6| 5| 4| 3| 2| 1| 0|
// +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
// |1 |            Pause            |  RC |SB| Par | Baud Rate |           Таймаут ответа          |
//
// 00..11: Таймаут ответа - время одидания ответа (0..4095), мс
// 12..15: Baud Rate:
//  0000 - 9600
//  0001 - 19200
//  0010 - 38400
//  0011 - 57600
//  0100 - 115200
// 16..17: Check Parity:
//  00   - None
//  01   - Odd
//  10   - Even
// 18: StopBits:
//  0    - 1
//  1    - 2
// 19..20: RC - количество повторных попыток при ошибке чтения
//  00   - 0
//  01   - 1
//  10   - 2
//  11   - 3
// 21..30: Pause - пауза между запросами (0..1023), мс
// 31:
//  0    - не менять настройки последовательного порта
//  1    - менять настройки последовательного порта

// FBD_MODBUS_OPT2
// |31|30|29|28|27|26|25|24|23|22|21|20|19|18|17|16|15|14|13|12|11|10| 9| 8| 7| 6| 5| 4| 3| 2| 1| 0|
// +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
// |                               Reserve                              |SV|         Delay         |
//
// 0..7:   Задержка между любыми запросами - 0..255, мс
// 8:      SV: действия при ошибке чтения: 0 - записывать значение по умолчанию, 1 - сохранять старое значение
// 9..31:  Резерв

// -------------------------------------------------------------------------------------------------------
// События/Журнал
// -------------------------------------------------------------------------------------------------------
//
#ifdef USE_EVENTS

// события в описании схемы (12)
typedef __packed_struct EventDescription_t {
    uint16_t imessage : 8;                                      // индекс сообщения
    uint16_t severity : 2;                                      // уровень "серьёзности"
    uint16_t logBegin : 1;                                      // требует регистрации в журнале
    uint16_t logEnd : 1;                                        // требует регистрации в журнале
    uint16_t conditions : 2;                                    // условие события
    uint16_t cr : 1;                                            // событие требует подтверждения
} tEventDescription;

typedef union {
    tEventDescription flags;
    tSignal value;
} tEventDescriptionView;


// tEventDescription.flags
// |31 |30 |29 |28 |27 |26 |25 |24 |23 |22 |21 |20 |19 |18 |17 |16 |15 |14 |13 |12 |11 |10 | 9 | 8 | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
// +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
// |                                                                   |CR | Cond  |LB |LE | Svrt  |           imessage            |
//
// 8..9: Severity:
//      00 - Information
//      01 - Notice
//      10 - Warning
//      11 - Emergency
// 10: LE Помещать конец события в журнал
// 11: LB Помещать начало события в журнал
// 12..13: Cond - Условие возникновения события
//      00 - значение элемента == "level"
//      01 - значение элемента != "level"
//      10 - значение элемента >  "level"
//      11 - значение элемента <  "level"
// 14: CR Событие требует подтверждения

// условие возникновения события
enum FBD_EVENT_COND {
    FBD_EVENT_COND_EQU              = 0,
    FBD_EVENT_COND_NOTEQU           = 1,
    FBD_EVENT_COND_GREATER          = 2,
    FBD_EVENT_COND_LESS             = 3
};
// важность события
enum FBD_EVENT_SEVERITY {
    FBD_EVENT_SEVERITY_INFO         = 0,
    FBD_EVENT_SEVERITY_NOTICE       = 1,
    FBD_EVENT_SEVERITY_WARNING      = 2,
    FBD_EVENT_SEVERITY_EMERGENCY    = 3
};

#define FBD_EVENTS_FLAG_SIGN 5

typedef enum FBD_EVENT_SEVERITY tEventSeverity;

// метка времени события/журнала с флагами
typedef __packed_struct EventFlags_t {
    uint32_t seconds : 6;                                       // метка времени: секунды (0..59)
    uint32_t minutes : 6;                                       // метка времени: минуты (0..59)
    uint32_t hours : 5;                                         // метка времени: часы (0..23)
    uint32_t day : 5;                                           // метка времени: день (1..31)
    uint32_t month : 4;                                         // метка времени: месяц (1..12)
    uint32_t severity : 2;                                      // важность
    uint32_t started : 1;                                       // начало события
    uint32_t sign : 3;                                          // признак наличия события: 101
} tEventFlags;

typedef union {
    tEventFlags flags;
    tSignal value;
} tEventFlagsView;


// Запись журнала в NVRAM занимает 2 32-х битных слова:
//    |31 |30 |29 |28 |27 |26 |25 |24 |23 |22 |21 |20 |19 |18 |17 |16 |15 |14 |13 |12 |11 |10 | 9 | 8 | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
//    +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
// 0  |   Sign    | SE| Svrt  |     Month     |        Day        |       Hour        |        Minutes        |        Seconds        |
// 1  |                                         Reserve                                               |           imessage            |

typedef struct {
    tEventFlags flags;
    DESCR_MEM char DESCR_MEM_SUFX *message;
} tEventLogItem;

// Возвращает количество событий в проекте, если результат 0, то проект не использует события и журнал.
tSignal fbdTotalEventsCount(void);

// Получить описание активного события с индексом index
// Результат выполнения:
//  false - события с таким индексом нет
//  true  - активное событие есть, оно помещено в структуру event
bool fbdGetCurrentEvent(tSignal index, tEventLogItem *event);

// Возвращает признак активности текущего события с указанным индексом 
// Результат выполнения:
//  false - события с таким индексом нет
//  true  - активное событие есть
bool fbdCurrentEventIsActive(tSignal index);

// Подтверждение (сброс) текущего события
bool fbdConfirmCurrentEvent(tSignal index);

// Проверка возможности подтверждения текущего события
bool fbdCanConfirmCurrentEvent(tSignal index);

//  Возвращает количество записей в журнале событий
int fbdGetLogEventCount(void);

// Получить описание события с индексом index из журнала событий
// index - индекс записи в журнале событий, 0 - самое новое (последнее)
// Результат выполнения:
//  false - события с таким индексом в журнале нет
//  true  - событие в журнале есть, оно помещено в структуру event
bool fbdGetLogEvent(tSignal index, tEventLogItem *event);

// Изменился текущий лог
bool fbdLogEventChanged(void);

// Изменился журнал событий
bool fbdCurrentEventChanged(void);

// Очистка журнала событий
void fbdClearLogEvent(void);

#endif  // USE_EVENTS

#ifdef USE_HMI
// HMI
// -------------------------------------------------------------------------------------------------------
// структура описания точки контроля или регулирования
typedef struct hmidata_t {
    tSignal value;              // текущее значение точки
    tSignal lowlimit;           // нижний предел значения (только для точек регулирования)
    tSignal upperLimit;         // верхний предел значения (только для точек регулирования)
    tSignal defValue;           // значение "по умолчанию" (только для точек регулирования)
    tSignal divider;            // делитель для отображения на индикаторе
    tSignal step;               // шаг регулирования (только для точек регулирования)
    DESCR_MEM char *caption;    // текстовая надпись
} tHMIdata;
//
// получить значение точки регулирования
bool fbdHMIgetSP(tSignal index, tHMIdata *pnt);
//
// установить значение точки регулирования
void fbdHMIsetSP(tSignal index, tSignal value);
//
// получить значение точки контроля
bool fbdHMIgetWP(tSignal index, tHMIdata *pnt);
//
// структура описания проекта
typedef struct hmidescription_t {
    DESCR_MEM char *name;       // наименование проекта
    DESCR_MEM char *version;    // версия проекта
    DESCR_MEM char *btime;      // дата и время компиляции
} tHMIdescription;
//
// получить структуру с описанием проекта
void fbdHMIgetDescription(tHMIdescription *pnt);
//
// возвращает указатель на текстовое описание (хинт) входа или выхода, если такого описание не найдено, то возвращает NULL
DESCR_MEM char DESCR_MEM_SUFX *fbdHMIgetIOhint(char type, char index);
//
#endif  // USE_HMI

#endif