/**

* @file fbdrt.c

* @author [email protected]

* @brief FBD-Runtime library

* @version 9.0

* @date 2021-11-17

*/

#include <string.h>

#include "fbdrt.h"

#ifdef USE_HMI

// для snprintf

#include <stdio.h>

#endif

// 06-01-2018

// добавлены битовые операции

// добавлен генератор сигналов

// для входных сетевых переменных добавлено значение "по умолчанию"

// * изменен способ проверки версии RTL

// * добавлено определение USE_MATH, с ним для некоторых расчетов используется плавающая точка

// 12-01-2018

// * починил SPEED_OPT

// 14-08-2018

// добавлены экраны интерфейса для контроллера

// 27-03-2019

// добавлена контрольная сумма для схемы

// 29-03-2019

// добавлены хинты для входов и выходов контроллера

// 14-11-2021

// Modbus

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

// FBDgetProc() и FBDsetProc() - callback, должны быть описаны в основной программе

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

/**

* @brief Чтение значения входного сигнала или NVRAM.

* Должна быть описана в основной программе.

*

* @param type Tип чтения: 0 - входной сигнал, 1 - значение NVRAM

* @param index Индекс читаемого значения

* @return tSignal Прочитанное значение сигнала

*/

extern tSignal FBDgetProc(char type, tSignal index);

/**

* @brief Запись значения выходного сигнала или NVRAM.

* Должна быть описана в основной программе.

*

* @param type Tип записи: 0 - выходной сигнал, 1 - значение NVRAM

* @param index Индекс записываемого значения

* @param value Записываемое значение.

*/

extern void FBDsetProc(char type, tSignal index, tSignal *value);

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

#ifdef USE_HMI

// рисование графических примитивов

//

// рисование залитого прямоугольника

extern void FBDdrawRectangle(tScreenDim x1, tScreenDim y1, tScreenDim x2, tScreenDim y2, tColor color);

// рисование текста

extern void FBDdrawText(tScreenDim x1, tScreenDim y1, unsigned char font, tColor color, tColor bkcolor, bool transparent, char *text);

// рисование линии

extern void FBDdrawLine(tScreenDim x1, tScreenDim y1, tScreenDim x2, tScreenDim y2, tColor color);

// рисование залитого эллипса

extern void FBDdrawEllipse(tScreenDim x1, tScreenDim y1, tScreenDim x2, tScreenDim y2, tColor color);

// рисование картинки

extern void FBDdrawImage(tScreenDim x1, tScreenDim y1, tScreenDim image);

// завершение рисования экрана (копирование видеообласти)

extern void FBDdrawEnd(void);

#endif

//

void fbdCalcElement(tElemIndex index);

void fbdSetStorage(tElemIndex element, unsigned char index, tSignal value);

#ifdef USE_HMI

DESCR_MEM char DESCR_MEM_SUFX * fbdGetCaptionByIndex(tElemIndex captionIndex);

#ifndef SPEED_OPT

DESCR_MEM char DESCR_MEM_SUFX * DESCR_MEM_SUFX fbdGetCaption(tElemIndex index);

#endif

#endif

#if defined(BIG_ENDIAN) && (SIGNAL_SIZE > 1)

tSignal lotobigsign(tSignal val);

#endif // defined

#if defined(BIG_ENDIAN) && (INDEX_SIZE > 1)

tElemIndex lotobigidx(tElemIndex val);

#endif // defined

// элемент стека вычислений

typedef struct fbdstackitem_t {

tElemIndex index; // индекс элемента

unsigned char input; // номер входа

} tFBDStackItem;

void setCalcFlag(tElemIndex element);

void setRiseFlag(tElemIndex element);

void setChangeVarFlag(tElemIndex index);

void setChangeModbusFlag(tElemIndex index);

bool getAndClearChangeModbusFlag(tElemIndex index);

void setModbusNoResponse(tElemIndex index);

void setModbusResponse(tElemIndex index, tSignal response);

void fillModbusRequest(tElemIndex index, tModbusReq *mbrequest);

void setModbusFloat(tElemIndex index, float data, float mul);

uint32_t getCoilBitsMask(unsigned count);

void swapModbusByteOrder(tModbusData *data);

void swapModbusWordOrder(tModbusData *data);

char getCalcFlag(tElemIndex element);

char getRiseFlag(tElemIndex element);

tSignal intAbs(tSignal val);

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

// массив описания схемы (расположен в ROM или RAM)

DESCR_MEM unsigned char DESCR_MEM_SUFX *fbdDescrBuf;

// формат данных:

// TypeElement1 <- тип элемента

// TypeElement2

// ...

// TypeElementN

// -1 <- флаг окончания описания элементов

// описания входов элемента

DESCR_MEM tElemIndex DESCR_MEM_SUFX *fbdInputsBuf;

// InputOfElement <- вход элемента

// InputOfElement

// ..

// описания параметров элементов

DESCR_MEM tSignal DESCR_MEM_SUFX *fbdParametersBuf;

// ParameterOfElement <- параметр элемента

// ParameterOfElement

// ...

// количество глобальных параметров схемы

DESCR_MEM unsigned char DESCR_MEM_SUFX *fbdGlobalOptionsCount;

// глобальные параметры схемы

DESCR_MEM tSignal DESCR_MEM_SUFX *fbdGlobalOptions;

//

#ifdef USE_HMI

// текстовые описания для HMI

DESCR_MEM char DESCR_MEM_SUFX *fbdCaptionsBuf;

// text, 0 <- captions

// text, 0

// ...

// экраны (начало выровнено по границе 4-х байт)

DESCR_MEM tScreen DESCR_MEM_SUFX *fbdScreensBuf;

// screen0

// screen1

// ...

// текстовые описания входов и выходов, количество указано в параметре FBD_OPT_HINTS_COUNT

DESCR_MEM char DESCR_MEM_SUFX *fbdIOHints;

// type(char), index(char), text, 0

// type(char), index(char), text, 0

// ...

// контрольная сумма всей программы CRC32

#endif // USE_HMI

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

// массив расчета схемы (расположен только в RAM)

tSignal *fbdMemoryBuf;

// формат данных:

// OutputValue0

// OutputValue1

// ...

// OutputValueN

//

// storage values

tSignal *fbdStorageBuf;

// Storage0

// Storage1

// ...

// StorageN

//

// флаги "расчет выполнен" и "нарастающий фронт", 2 бита для каждого элемента

char *fbdFlagsBuf;

// Flags0

// Flags1

// ...

// FlagsN

// флаги "значение изменилось", 1 бит для каждого элемента ELEM_OUT_VAR (14)

char *fbdChangeVarBuf;

// ChangeVar0

// ChangeVar1

// ...

// ChangeVarN

// флаги "значение изменилось", 1 бит для каждого элемента ELEM_OUT_MDBS (34)

char *fbdChangeModbusBuf;

// ChangeModbus0

// ChangeModbus1

// ...

// ChangeModbusN

#ifdef SPEED_OPT

// только при использовании оптимизации по скорости выполнения

tOffset *inputOffsets;

// Смещение входа 0 элемента 0

// Смещение входа 0 элемента 1

// ...

// Смещение входа 0 элемента N

tOffset *parameterOffsets;

// Смещение параметра 0 элемента 0

// Смещение параметра 0 элемента 1

// ...

// Смещение параметра 0 элемента N

tOffset *storageOffsets;

// Смещение хранимого значения 0 элемента 0

// Смещение хранимого значения 1

// ...

// Смещение хранимого значения N

#ifdef USE_HMI

// Структура для быстрого доступа к текстовым описаниям

typedef struct pointaccess_t {

tElemIndex index; // point element index

DESCR_MEM char DESCR_MEM_SUFX *caption; // указатель на текстовую строку

} tPointAccess;

//

tPointAccess *wpOffsets;

tPointAccess *spOffsets;

#endif // USE_HMI

// указатели для быстрого доступа к тектовым описаниям проекта

DESCR_MEM char *fbdCaptionName;

DESCR_MEM char *fbdCaptionVersion;

DESCR_MEM char *fbdCaptionBTime;

//

#endif // SPEED_OPT

tElemIndex fbdElementsCount;

tElemIndex fbdStorageCount;

tElemIndex fbdFlagsByteCount;

tElemIndex fbdChangeVarByteCount;

tElemIndex fbdChangeModbusByteCount;

tElemIndex fbdModbusRTUCount;

tElemIndex fbdModbusTCPCount;

tElemIndex fbdModbusRTUIndex;

tElemIndex fbdModbusTCPIndex;

short fbdModbusRTUTimer;

short fbdModbusTCPTimer;

unsigned char fbdModbusRTUErrorCounter;

unsigned char fbdModbusTCPErrorCounter;

#ifdef USE_HMI

tElemIndex fbdWpCount;

tElemIndex fbdSpCount;

short fbdCurrentScreen; // текущий экран

unsigned short fbdCurrentScreenTimer; // таймер текущего экрана

#endif // USE_HMI

//

char fbdFirstFlag;

// массив с количествами входов для элементов каждого типа

ROM_CONST uint8_t ROM_CONST_SUFX FBDdefInputsCount[ELEM_TYPE_COUNT] = {1,0,1,2,2,2,2,2,2,2,2,2,2,2,1,0,0,4,3,3,5,1,1,0,2,2,2,3,2,2,2,2,2,0,1};

// массив с количествами параметров для элементов каждого типа

ROM_CONST uint8_t ROM_CONST_SUFX FBDdefParametersCount[ELEM_TYPE_COUNT] = {1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,2,0,0,0,0,0,1,5,0,0,0,0,0,0,0,0,1,3,2};

// массив с количествами хранимых данных для элементов каждого типа

ROM_CONST uint8_t ROM_CONST_SUFX FBDdefStorageCount[ELEM_TYPE_COUNT] = {0,0,0,0,0,0,1,1,0,0,0,0,1,0,0,0,1,2,1,1,0,0,0,1,1,0,0,0,0,0,0,0,1,0,0};

// 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 3 3 3 3 3

// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4

// Параметры элемента ELEM_INP_MDBS (чтение Modbus)

//

// |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|

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

// | FMT/CNT |WO|BO| FNC | Адрес устройства | Адрес регистра MODBUS |

//

// BO - byte order: 0 - HiLo, 1 - LoHi

// WO - word order: 0 - HiLo, 1 - LoHi

// FNC - Modbus function:

// 00 - read coil (0x01)

// 01 - read discrete input (0x02)

// 10 - read holding registers (0x03)

// 11 - read input registers (0x04)

// FMT/CNT - формат читаемых данных (для "read input registers" и "read holding registers") или количество регистров для чтения (для "read coil" и "read discrete input")

// FMT - формат читаемых данных (для "read input registers" и "read holding registers"):

// 0000 - uint16 (0..65535) 1 регистр

// 0001 - int16 (0..65535) 1 регистр

// 0010 - int32 2 регистра

// MM11 - single 2 регистра, MM - множитель 00 - 1, 01 - 10, 10 - 100, 11 - 1000

// CNT - количество читаемых бит (для "read coil" и "read discrete input"):

// WO = 0

// 0000 - 1

// ...

// 1111 - 16

// WO = 1

// 0000 - 17

// ...

// 1111 - 32

//

// Параметры элемента ELEM_OUT_MDBS (запись Modbus)

//

// |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|

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

// | FMT/CNT |WO|BO| FNC | Адрес устройства | Адрес регистра MODBUS |

//

// BO - byte order: 0 - HiLo, 1 - LoHi

// WO - word order: 0 - HiLo, 1 - LoHi

// FNC - Modbus function:

// 00 - Write Single Coil (0x05)

// 01 - Write Multiple Coils (0x0F)

// 10 - Write Single Register (0x06)

// 11 - Write Multiple registers (0x10)

// FMT/CNT - формат записываемых данных (для "Write Single Register" и "Write Multiple registers") или количество регистров для записи (для "Write Multiple Coils")

// FMT - формат данных (для "Write Single Register" и "Write Multiple registers"):

// 0000 - uint16 (0..65535) 1 регистр

// 0001 - int16 (0..65535) 1 регистр

// 0010 - int32 2 регистра

// MM11 - single 2 регистра, MM - делитель 00 - 1, 01 - 10, 10 - 100, 11 - 1000 (только Write Multiple registers)

// CNT - количество записываемых бит (для "Write Multiple Coils"):

// WO = 0

// 0000 - 1

// ...

// 1111 - 16

// WO = 1

// 0000 - 17

// ...

// 1111 - 32

//

#ifdef SPEED_OPT

// описания "быстрых" вариантов функций

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

#define FBDINPUTOFFSET(index) *(inputOffsets (index))

#define FBDGETPARAMETER(element,index) SIGNAL_BYTE_ORDER(fbdParametersBuf[*(parameterOffsets element) index])

#define FBDGETSTORAGE(element,index) fbdStorageBuf[*(storageOffsets element) index]

#else // SPEED_OPT

// описания "медленных" вариантов функций

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

// расчет смещения на первый вход элемента

#define FBDINPUTOFFSET(index) _fbdInputOffset(index)

tOffset _fbdInputOffset(tElemIndex index)

{

tElemIndex i = 0;

tOffset offset = 0;

//

while (i < index) offset = FBDdefInputsCount[fbdDescrBuf[i ] & ELEMMASK];

return offset;

}

// получить значение параметра элемента

#define FBDGETPARAMETER(element,index) _fbdGetParameter(element,index)

tSignal _fbdGetParameter(tElemIndex element, unsigned char index)

{

tElemIndex elem = 0;

tOffset offset = 0;

//

while (elem < element) offset = FBDdefParametersCount[fbdDescrBuf[elem ] & ELEMMASK];

return SIGNAL_BYTE_ORDER(fbdParametersBuf[offset index]);

}

// получить хранимое значение для элемента

#define FBDGETSTORAGE(element,index) _fbdGetStorage(element,index)

tSignal _fbdGetStorage(tElemIndex element, unsigned char index)

{

tElemIndex elem = 0;

tOffset offset = 0;

//

while (elem<element) offset = FBDdefStorageCount[fbdDescrBuf[elem ] & ELEMMASK];

return fbdStorageBuf[offset index];

}

#endif // SPEED_OPT

/**

* @brief Расчёт контрльной суммы CRC32

* Используется при проверке корректности программы.

* @param data Указатель на массив данных

* @param size Размер массива данных

* @return uint32_t Результат вычисления

*/

uint32_t fbdCRC32(DESCR_MEM unsigned char DESCR_MEM_SUFX *data, int size)

{

uint32_t crc = ~0;

//

while(size--) {

crc ^= *data ;

for(int i = 0; i < 8; i ) {

uint32_t t = ~((crc&1)-1);

crc = (crc>>1) ^ (0xEDB88320 & t);

}

}

return crc;

}

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

/**

* @brief Инициализация схемы

* Функция должна быть вызвана один раз в самом начале работы.

* Результат: количество ОЗУ, необходимое для выполнения схемы (значение больше 0) или (в случае ошибки) отрицательное значение:

* ERR_INVALID_ELEMENT_TYPE - неверный код элемента в описании схемы

* ERR_INVALID_SIZE_TYPE - неверный размер tSignal или tElementIndex

* ERR_INVALID_LIB_VERSION - несовпадает версия программы и библиотеки

* ERR_INVALID_CHECK_SUM - неверная контрольная сумма программы

* @param buf Указатель на массив описания схемы

* @return Количество байт RAM, необходимое для выполнения схемы или код ошибки

*/

int fbdInit(DESCR_MEM unsigned char DESCR_MEM_SUFX *buf)

{

tOffset inputs = 0;

tOffset parameters = 0;

unsigned char elem;

//

fbdElementsCount = 0;

fbdStorageCount = 0;

fbdChangeVarByteCount = 0;

fbdChangeModbusByteCount = 0;

//

fbdModbusRTUIndex = MAX_INDEX;

fbdModbusTCPIndex = MAX_INDEX;

fbdModbusRTUErrorCounter = 0;

fbdModbusTCPErrorCounter = 0;

fbdModbusRTUCount = 0;

fbdModbusTCPCount = 0;

#ifdef USE_HMI

fbdWpCount = 0;

fbdSpCount = 0;

DESCR_MEM char DESCR_MEM_SUFX *curCap;

tElemIndex i;

#endif // USE_HMI

//

if(!buf) return ERR_INVALID_ELEMENT_TYPE;

fbdDescrBuf = buf;

// цикл по всем элементам

while(1) {

elem = fbdDescrBuf[fbdElementsCount];

if(elem & 0x80) break;

elem &= ELEMMASK;

if(elem >= ELEM_TYPE_COUNT) return ERR_INVALID_ELEMENT_TYPE;

// подсчет всех входов

inputs = FBDdefInputsCount[elem];

// подсчет всех параметров

parameters = FBDdefParametersCount[elem];

// подсчет всех хранимых параметров

fbdStorageCount = FBDdefStorageCount[elem];

// подсчёт элементов некоторых типов

switch (elem) {

case ELEM_OUT_VAR:

fbdChangeVarByteCount ; // подсчёт выходных переменных

break;

case ELEM_OUT_MDBS:

fbdChangeModbusByteCount ; // подсчёт элементов записи в Modbus

break;

#ifdef USE_HMI

case ELEM_WP:

fbdWpCount ; // точки контроля

break;

case ELEM_SP:

fbdSpCount ; // точки регулирования

break;

#endif // USE_HMI

}

// общий подсчёт элементов

fbdElementsCount ;

}

// проверка правильности флага завершения

if(elem != END_MARK) return ERR_INVALID_SIZE_TYPE;

// расчет указателей

fbdInputsBuf = (DESCR_MEM tElemIndex DESCR_MEM_SUFX *)(fbdDescrBuf fbdElementsCount 1);

fbdParametersBuf = (DESCR_MEM tSignal DESCR_MEM_SUFX *)(fbdInputsBuf inputs);

fbdGlobalOptionsCount = (DESCR_MEM unsigned char DESCR_MEM_SUFX *)(fbdParametersBuf parameters);

fbdGlobalOptions = (DESCR_MEM tSignal DESCR_MEM_SUFX *)(fbdGlobalOptionsCount 1);

// проверка версии программы

if(*fbdGlobalOptions > FBD_LIB_VERSION) return ERR_INVALID_LIB_VERSION;

#ifdef USE_HMI

// указатель на начало текстовых строк точек контроля и регулирования

fbdCaptionsBuf = (DESCR_MEM char DESCR_MEM_SUFX *)(fbdGlobalOptions *fbdGlobalOptionsCount);

// после текстовых строк точек контроля и регулирования идут еще 3 строки: имя проекта, версия проекта, дата создания проекта

// расчет указателя на первый экран

// первый экран идет после текстовых описаний в количестве (fbdWpCount fbdSpCount), причем его начало выровнено на 4 байта

curCap = fbdCaptionsBuf;

// перебираем все строки текстовых описаний

// 3 - это имя проекта, версия проекта, дата создания проекта

for(i=0; i < (fbdWpCount fbdSpCount 3); i ) {

while(*(curCap ));

}

// выравнивание curCap по границе 32 бита

while((int)curCap % 4) curCap ;

// ставим указатель на начало экранов

fbdScreensBuf = (DESCR_MEM tScreen DESCR_MEM_SUFX *)curCap;

// хинты входов и выходов идут после экранов

if(FBD_HINTS_COUNT > 0) {

// перебираем все экраны (если экраны есть) в поисках окончания

DESCR_MEM tScreen DESCR_MEM_SUFX *screen = fbdScreensBuf;

i = 0;

while (i < FBD_SCREEN_COUNT) {

screen = (tScreen *)((char *)screen screen->len);

i ;

}

fbdIOHints = (DESCR_MEM char DESCR_MEM_SUFX *)screen;

}

#endif // USE_HMI

// расчёт и проверка CRC, если указан параметр FBD_SCHEMA_SIZE

if(FBD_SCHEMA_SIZE) {

// если результат 0, то CRC не используется (старая версия редактора)

if(fbdCRC32(fbdDescrBuf, FBD_SCHEMA_SIZE)) return ERR_INVALID_CHECK_SUM;

}

// память для флагов расчета и фронта

fbdFlagsByteCount = (fbdElementsCount>>2) ((fbdElementsCount&3)?1:0);

// память для флагов изменений значения выходной переменной

fbdChangeVarByteCount = (fbdChangeVarByteCount>>3) ((fbdChangeVarByteCount&7)?1:0);

// память для флагов изменений значения записи в Modbus

fbdChangeModbusByteCount = (fbdChangeModbusByteCount>>3) ((fbdChangeModbusByteCount&7)?1:0);

//

#ifdef SPEED_OPT

#ifdef USE_HMI

return (fbdElementsCount fbdStorageCount)*sizeof(tSignal) fbdFlagsByteCount fbdChangeVarByteCount fbdChangeModbusByteCount fbdElementsCount*3*sizeof(tOffset) (fbdWpCount fbdSpCount)*sizeof(tPointAccess);

#else // USE_HMI

return (fbdElementsCount fbdStorageCount)*sizeof(tSignal) fbdFlagsByteCount fbdChangeVarByteCount fbdChangeModbusByteCount fbdElementsCount*3*sizeof(tOffset);

#endif // USE_HMI

#else // SPEED_OPT

return (fbdElementsCount fbdStorageCount)*sizeof(tSignal) fbdFlagsByteCount fbdChangeVarByteCount fbdChangeModbusByteCount;

#endif // SPEED_OPT

}

/**

* @brief Инициализация памяти схемы

* Функция должна быть вызвана после fbdInit().

*

* @param buf Указатель на буфер памяти (размер возвращается fbdInit()), используемой при расчёте схемы

* @param needReset Признак необходимости сброса NVRAM после загрузки новой (ранее не выполнявщейся) схемы

*/

void fbdSetMemory(char *buf, bool needReset)

{

tElemIndex i;

#ifdef USE_HMI

tHMIdata hmiData;

#endif // USE_HMI

#ifdef SPEED_OPT

tOffset curInputOffset = 0;

tOffset curParameterOffset = 0;

tOffset curStorageOffset = 0;

#ifdef USE_HMI

tOffset curWP = 0;

tOffset curSP = 0;

DESCR_MEM char DESCR_MEM_SUFX *curCap;

#endif // USE_HMI

#endif // SPEED_OPT

fbdModbusRTUIndex = MAX_INDEX;

fbdModbusTCPIndex = MAX_INDEX;

//

fbdModbusRTUErrorCounter = 0;

fbdModbusTCPErrorCounter = 0;

//

fbdModbusRTUTimer = 0;

fbdModbusTCPTimer = 0;

//

fbdModbusRTUCount = 0;

fbdModbusTCPCount = 0;

//

fbdMemoryBuf = (tSignal *)buf;

// инициализация указателей

fbdStorageBuf = fbdMemoryBuf fbdElementsCount;

fbdFlagsBuf = (char *)(fbdStorageBuf fbdStorageCount);

fbdChangeVarBuf = (char *)(fbdFlagsBuf fbdFlagsByteCount);

fbdChangeModbusBuf = (char *)(fbdChangeVarBuf fbdChangeVarByteCount);

// инициализация памяти (выходы элементов)

memset(fbdMemoryBuf, 0, sizeof(tSignal)*fbdElementsCount);

// инициализация памяти (установка всех флагов изменения значения)

fbdChangeAllNetVars();

// установка всех флагов изменения значений записи в Modbus

if(fbdChangeModbusByteCount > 0) memset(fbdChangeModbusBuf, 255, fbdChangeModbusByteCount);

// восстановление значений триггеров из nvram

for(i = 0; i < fbdStorageCount; i ) {

if(needReset) {

fbdStorageBuf[i] = 0;

FBDsetProc(1, i, &fbdStorageBuf[i]);

} else {

fbdStorageBuf[i] = FBDgetProc(1, i);

}

}

#ifdef SPEED_OPT

// инициализация буферов быстрого доступа

inputOffsets = (tOffset *)(fbdChangeModbusBuf fbdChangeModbusByteCount);

parameterOffsets = inputOffsets fbdElementsCount;

storageOffsets = parameterOffsets fbdElementsCount;

//

fbdCaptionName = 0;

fbdCaptionVersion = 0;

fbdCaptionBTime = 0;

#ifdef USE_HMI

// инициализация буферов для быстрого доступа к watch- и set- points

wpOffsets = (tPointAccess *)(storageOffsets fbdElementsCount);

spOffsets = wpOffsets fbdWpCount;

curCap = fbdCaptionsBuf;

#endif // USE_HMI

for(i=0; i < fbdElementsCount; i ) {

*(inputOffsets i) = curInputOffset;

*(parameterOffsets i) = curParameterOffset;

*(storageOffsets i) = curStorageOffset;

//

unsigned char elem = fbdDescrBuf[i] & ELEMMASK;

curInputOffset = FBDdefInputsCount[elem];

curParameterOffset = FBDdefParametersCount[elem];

curStorageOffset = FBDdefStorageCount[elem];

//

#ifdef USE_HMI

switch(elem) {

case ELEM_WP:

(wpOffsets curWP)->index = i;

(wpOffsets curWP)->caption = curCap;

curWP ;

while(*(curCap ));

break;

case ELEM_SP:

(spOffsets curSP)->index = i;

(spOffsets curSP)->caption = curCap;

curSP ;

while(*(curCap ));

break;

}

#endif // USE_HMI

}

#endif // SPEED_OPT

// подсчёт количества элементов Modbus и инициализация значений чтения Modbus

// цикл по всем элементам

for(i=0; i < fbdElementsCount; i ) {

switch (fbdDescrBuf[i] & ELEMMASK) {

case ELEM_INP_MDBS:

// установка значения элемента на значение по умолчанию

// параметр 2: значение по умолчанию

fbdMemoryBuf[i] = FBDGETPARAMETER(i, 2);

case ELEM_OUT_MDBS:

// параметр 0: IP-адрес

if(FBDGETPARAMETER(i, 0)) fbdModbusTCPCount ; else fbdModbusRTUCount ;

}

}

// инициализация входных переменных

if(needReset) {

// при загрузке новой схемы значение входных сетевых переменных (до того, как они будут получены) равны 0, это не совсем хорошо...

// инициализируем их значениями "по умолчанию" из программы

for(i = 0; i < fbdElementsCount; i ) {

if(fbdDescrBuf[i] == ELEM_INP_VAR) {

fbdSetStorage(i, 0, FBDGETPARAMETER(i, 1));

}

}

}

#ifdef USE_HMI

// инициализация значений точек регулирования (HMI setpoints)

i = 0;

while(fbdHMIgetSP(i, &hmiData)) {

// если значение точки регулирования не корректное, то устанавливаем значение по умолчанию

if(needReset||(hmiData.value > hmiData.upperLimit)||(hmiData.value < hmiData.lowlimit)) fbdHMIsetSP(i, hmiData.defValue);

i ;

}

//

fbdCurrentScreen = -1;

fbdCurrentScreenTimer = 0;

#endif // USE_HMI

//

fbdFirstFlag = 1;

}

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

#ifdef USE_HMI

/**

* @brief Проверка видимости экранного элемента

*

* @param elem Указатель на описание экранного элемента

* @return true Элемент видим

* @return false Элемент не видим

*/

bool isScrElemVisible(tScrElemBase *elem)

{

if(elem->visibleElem == 0xffff) return true; // не выбран элемент видимости

switch(elem->visibleCond) {

case 0:

return true; // условие "всегда"

case 1: // условие "равно"

return fbdMemoryBuf[elem->visibleElem] == elem->visibleValue;

case 2: // условие "не равно"

return fbdMemoryBuf[elem->visibleElem] != elem->visibleValue;

case 3: // условие "больше"

return fbdMemoryBuf[elem->visibleElem] > elem->visibleValue;

case 4: // условие "меньше"

return fbdMemoryBuf[elem->visibleElem] < elem->visibleValue;

default:

return true;

}

}

tSignal getElementOutputValue(tElemIndex index)

{

if(index == 0xffff) return 0;

return fbdMemoryBuf[index];

}

void sprintf2d(char *buf, tSignal val)

{

*(buf 1) = val % 10 '0';

val /= 10;

*(buf) = val % 10 '0';

}

void sprintf4d(char *buf, tSignal val)

{

*(buf 3) = val % 10 '0';

val /= 10;

*(buf 2) = val % 10 '0';

val /= 10;

*(buf 1) = val % 10 '0';

val /= 10;

*(buf) = val % 10 '0';

}

/**

* @brief Отрисовка экрана

*

* @param screen Указатель на описание экрана

*/

void drawCurrentScreen(DESCR_MEM tScreen DESCR_MEM_SUFX *screen)

{

tScrElemBase *elem;

char dttext[32];

char text[32]; // больше на экран не лезет

tSignal v2;

int i,j,k;

char c,nc;

float f;

// очистка экрана

FBDdrawRectangle(0, 0, SCREEN_WIDTH-1, SCREEN_HEIGHT-1, screen->bkcolor);

//

// цикл по элементам экрана

i = 0;

elem = (tScrElemBase *)((char *)screen sizeof(tScreen));

while(i < screen->elemCount) {

// проверка видимости

if(isScrElemVisible(elem)) {

// рисование

switch(elem->type) {

case 0: // линия

k = ((tScrElemLine *)elem)->width;

if(k > 1) {

k--;

for(j=-k/2; j<=k/2 k%2; j ) {

FBDdrawLine(roundf(elem->x1-j*((tScrElemLine *)elem)->sine), roundf(elem->y1 j*((tScrElemLine *)elem)->cosinus), roundf(((tScrElemLine *)elem)->x2-j*((tScrElemLine *)elem)->sine), roundf(((tScrElemLine *)elem)->y2 j*((tScrElemLine *)elem)->cosinus), ((tScrElemLine *)elem)->color);

}

} else {

FBDdrawLine(elem->x1, elem->y1, ((tScrElemLine *)elem)->x2, ((tScrElemLine *)elem)->y2, ((tScrElemLine *)elem)->color);

}

break;

case 1: // прямоугольник

FBDdrawRectangle(elem->x1, elem->y1, ((tScrElemRect *)elem)->x2, ((tScrElemRect *)elem)->y2, ((tScrElemRect *)elem)->color);

break;

case 2: // текст

f = getElementOutputValue(((tScrElemText *)elem)->valueElem) * (float)1.0;

switch (((tScrElemText *)elem)->divider) {

case 1:

f = f / (float)10.0;

break;

case 2:

f = f / (float)100.0;

break;

case 3:

f = f / (float)1000.0;

}

// форматирование даты и времени

j = 0;

k = 0;

do {

c = ((tScrElemText *)elem)->text[j ];

if(c == '%') {

nc = ((tScrElemText *)elem)->text[j];

switch(nc) {

case 'd':

if(k < (sizeof(dttext)-2)) {

sprintf2d(&dttext[k], FBDgetProc(0, GP_RTC_DAY));

k = 2;

}

j ;

break;

case 'm':

if(k < (sizeof(dttext)-2)) {

sprintf2d(&dttext[k], FBDgetProc(0, GP_RTC_MONTH));

k = 2;

}

j ;

break;

case 'y':

if(k < (sizeof(dttext)-2)) {

sprintf2d(&dttext[k], FBDgetProc(0, GP_RTC_YEAR)-2000);

k = 2;

}

j ;

break;

case 'h':

if(k < (sizeof(dttext)-2)) {

sprintf2d(&dttext[k], FBDgetProc(0, GP_RTC_HOUR));

k = 2;

}

j ;

break;

case 'n':

if(k < (sizeof(dttext)-2)) {

sprintf2d(&dttext[k], FBDgetProc(0, GP_RTC_MINUTE));

k = 2;

}

j ;

break;

case 's':

if(k < (sizeof(dttext)-2)) {

sprintf2d(&dttext[k], FBDgetProc(0, GP_RTC_SECOND));

k = 2;

}

j ;

break;

case 'Y':

if(k < (sizeof(dttext)-4)) {

sprintf4d(&dttext[k], FBDgetProc(0, GP_RTC_YEAR));

k = 4;

}

j ;

break;

default:

dttext[k ] = c;

}

} else {

dttext[k ] = c;

}

} while (c);

//

snprintf(text, sizeof(text), dttext, f);

FBDdrawText(elem->x1, elem->y1, ((tScrElemText *)elem)->font & 0x7f, ((tScrElemText *)elem)->color, ((tScrElemText *)elem)->bkcolor, (((tScrElemText *)elem)->font & 0x80) != 0, text);

break;

case 3: // картинка

FBDdrawImage(elem->x1, elem->y1, ((tScrElemImage *)elem)->index);

break;

case 4: // шкала

v2 = getElementOutputValue(((tScrElemGauge *)elem)->valueElem);

// нормирование значения

if(v2 < 0) v2 = 0; else

if(v2 > ((tScrElemGauge *)elem)->maxvalue) v2 = ((tScrElemGauge *)elem)->maxvalue;

//

if(((tScrElemGauge *)elem)->orientation == 0) {

// горизонтальная ориентация

v2 = elem->x1 v2*(((tScrElemGauge *)elem)->x2 - elem->x1) / ((tScrElemGauge *)elem)->maxvalue;

// рисуем прямоугольник значения

FBDdrawRectangle(elem->x1, elem->y1, v2, ((tScrElemGauge *)elem)->y2, ((tScrElemGauge *)elem)->color);

if(v2 < ((tScrElemGauge *)elem)->x2) {

// рисуем прямоугольник остатка

FBDdrawRectangle(v2, elem->y1, ((tScrElemGauge *)elem)->x2, ((tScrElemGauge *)elem)->y2, ((tScrElemGauge *)elem)->bkcolor);

}

} else {

// вертикальная ориентация

v2 = ((tScrElemGauge *)elem)->y2 - v2*(((tScrElemGauge *)elem)->y2 - elem->y1) / ((tScrElemGauge *)elem)->maxvalue;

// рисуем прямоугольник значения

FBDdrawRectangle(elem->x1, v2, ((tScrElemGauge *)elem)->x2, ((tScrElemGauge *)elem)->y2, ((tScrElemGauge *)elem)->color);

if(elem->y1 < v2) {

// рисуем прямоугольник остатка

FBDdrawRectangle(elem->x1, elem->y1, ((tScrElemGauge *)elem)->x2, v2, ((tScrElemGauge *)elem)->bkcolor);

}

}

break;

case 5: // эллипс

FBDdrawEllipse(elem->x1, elem->y1, ((tScrElemCircle *)elem)->x2, ((tScrElemCircle *)elem)->y2, ((tScrElemCircle *)elem)->color);

break;

}

}

// переход к следующему элементу

elem = (tScrElemBase *)((char *)elem elem->len);

}

//

FBDdrawEnd();

}

/**

* @brief Выполнение одного шага вычисления схемы.

* Функция выполняет один шаг вычисления схемы и перерисовку указанноего экрана при необходимости.

*

* @param period Время с момента предыдущего вызова fbdDoStepEx(), например в мс.

* @param screenIndex Индекс текущего отображаемого экрана.

*/

void fbdDoStepEx(tSignal period, short screenIndex)

{

DESCR_MEM tScreen DESCR_MEM_SUFX *screen;

int i;

// расчет схемы

fbdDoStep(period);

// проверка корректности номера экрана

if(screenIndex >= FBD_SCREEN_COUNT) return;

// не показывать экран

if(screenIndex < 0) {

fbdCurrentScreen = screenIndex;

return;

}

// расчет указателя на экран

i = 0;

screen = fbdScreensBuf;

while (i < screenIndex) {

screen = (tScreen *)((char *)screen screen->len);

i ;

}

// проверка необходимости перерисовки

if(screenIndex != fbdCurrentScreen) {

// сменился экран

fbdCurrentScreen = screenIndex;

fbdCurrentScreenTimer = 0;

drawCurrentScreen(screen);

} else {

fbdCurrentScreenTimer = period;

if(fbdCurrentScreenTimer >= screen->period) {

fbdCurrentScreenTimer = 0;

drawCurrentScreen(screen);

}

}

}

#endif // USE_HMI

/**

* @brief Выполнение одного шага вычисления схемы

* Функция выполняет один шаг вычисления схемы

*

* @param period время с момента предыдущего вызова fbdDoStep(), например в милисекундах

*/

void fbdDoStep(tSignal period)

{

tSignal value, param;

tElemIndex index;

// сброс признаков расчета и нарастающего фронта

memset(fbdFlagsBuf, 0, fbdFlagsByteCount);

// модификация таймеров Modbus

if(period) {

if(period <= fbdModbusRTUTimer) fbdModbusRTUTimer -= period; else fbdModbusRTUTimer = 0;

if(period <= fbdModbusTCPTimer) fbdModbusTCPTimer -= period; else fbdModbusTCPTimer = 0;

}

// основной цикл расчета

for(index=0; index < fbdElementsCount; index ) {

unsigned char element = fbdDescrBuf[index] & ELEMMASK;

switch(element) {

// элементы с таймером

case ELEM_TON: // timer TON

case ELEM_PID: // PID

case ELEM_SUM: // SUM

case ELEM_TP: // timer TP

case ELEM_GEN: // GEN

if(!period) break;

value = FBDGETSTORAGE(index, 0);

if(value) {

value -= period;

if(value < 0) value = 0;

fbdSetStorage(index, 0, value);

}

break;

case ELEM_OUT_PIN: // output PIN

fbdCalcElement(index);

param = FBDGETPARAMETER(index, 0);

FBDsetProc(0, param, &fbdMemoryBuf[index]); // установка значения выходного контакта

break;

case ELEM_OUT_VAR: // выходная переменная

case ELEM_OUT_MDBS: // запись Modbus

#ifdef USE_HMI

case ELEM_WP: // точка контроля

#endif // USE_HMI

fbdCalcElement(index);

break;

}

}

fbdFirstFlag = 0;

}

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

/**

* @brief Установить принятое по сети значение переменной

*

* @param netvar Указатель на структуру описания сетевой переменной

*/

void fbdSetNetVar(tNetVar *netvar)

{

tElemIndex i;

//

for(i=0; i < fbdElementsCount; i ) {

if(fbdDescrBuf[i] == ELEM_INP_VAR) {

if(FBDGETPARAMETER(i, 0) == netvar->index) {

fbdSetStorage(i, 0, netvar->value);

return;

}

}

}

return;

}

/**

* @brief Получить значение переменной для отправки по сети

* Функцию необходимо вызывать до тех пор, пока она не вернет false.

*

* @param netvar Указатель на структуру описания сетевой переменной

* @return true Переменная для отправки есть, она помещена в структуру netvar

* @return false Переменных для отправки больше нет