Подтягивание всех изменений с релиза в ветку

2025-11-04 22:02:28 +03:00
parent 7e21fc7f28
commit fbc424e507
25 changed files with 4410 additions and 896 deletions
--- a/Modbus/Inc/modbus.h
+++ b/Modbus/Inc/modbus.h
@@ -5,7 +5,7 @@
 ******************************************************************************
@addtogroup MODBUS Modbus tools
 ******************************************************************************
-@addtogroup MODBUS_FUNCTIONS Modbus library funtions
+@addtogroup MODBUS_FUNCTIONS Main API for Modbus Library
@ingroup    MODBUS
@{
 ******************************************************************************
@@ -17,35 +17,45 @@
@section Инструкция по подключению
 Для корректной работы надо:
 - Подключить обработчики RS_UART_Handler(), RS_TIM_Handler(), в соответствубщие 
-  низкоуровневые прерывания UART_IRQHandler, TIM_IRQHandler. Вместо HAL'овского обработчика
+  низкоуровневые прерывания UART_IRQHandler, TIM_IRQHandler вместо HAL'овского обработчика
 
-В modbus_config.h настроить дефайны для нужной работы UART
+- В modbus_config.h настроить дефайны для нужной работы UART

- Инициализировать хендл мобдас. По умолчанию глобально создается hmodbus1, но можно сделать свой
-После для запуска Modbus:
-@verbatim
-//----------------Прием модбас----------------//
-#include "modbus.h"
+- Инициализировать хендл мобдас. По умолчанию глобально создается hmodbus1
+- После для запуска Modbus:
+  @verbatim
+  //----------------Слейв модбас----------------//
+  #include "modbus.h"

-MODBUS_SetupHardware(&hmodbus1, &huart1, &htim3);
-MODBUS_SlaveStart(&hmodbus1, NULL);
-// или если нужно переключится на другой 
-@endverbatim
+  MODBUS_FirstInit(&hmodbus1, &huart1, &htim3);
+  MODBUS_Config(&hmodbus1, 1, 1000, MODBUS_MODE_SLAVE);
+  MODBUS_SlaveStart(&hmodbus1, NULL);
+  @endverbatim
+  @verbatim
+  //----------------Мастер модбас----------------//
+  #include "modbus.h"
+
+  MODBUS_FirstInit(&hmodbus1, &huart1, &htim3);
+  MODBUS_Config(&hmodbus1, 0, 1000, MODBUS_MODE_MASTER); // - если нужны другие настройки, не из modbus_config.h
+  // Запрос на 1 ID, считать холдинг регистры с 0 адреса 10 штук
+  RS_MsgTypeDef msg = MB_REQUEST_READ_HOLDING_REGS(1, 0, 10);
+  MODBUS_MasterRequest(&hmodbus1, &msg, &callback_func);
+  
+  void callback_func(RS_HandleTypeDef *hmodbus, RS_MsgTypeDef *modbus_msg) 
+  {
+    // modbus_msg содержит ответ от устройства
+  }
+  @endverbatim


@section Подключаемые модули:
+- rs_message.h - работа с uart
 - modbus_core.h - базовые определения
 - modbus_coils.h - работа с дискретными выходами
 - modbus_holdregs.h - работа с регистрами хранения  
 - modbus_inputregs.h - работа с входными регистрами
 - modbus_devid.h - идентификация устройства
- __crc_algs.h - алгоритмы CRC
-
-@section Использование в проекте:
-1. Настроить modbus_config.h под устройство
-2. Определить структуры данных в modbus_data.h
-3. Подключить этот файл в rs_message.h
-4. Вызвать MODBUS_FirstInit() и RS_Receive_IT()
+- modbus_diag.h - диагностика modbus


@section Структура данных Modbus
@@ -62,12 +72,14 @@ MODBUS_SlaveStart(&hmodbus1, NULL);
 #ifndef __MODBUS_H_
 #define __MODBUS_H_
 
-#include "__crc_algs.h"
 #include "rs_message.h"
+#include "modbus_master.h"
+#include "modbus_slave.h"
 #include "modbus_coils.h"
 #include "modbus_holdregs.h"
 #include "modbus_inputregs.h"
 #include "modbus_devid.h"
+#include "modbus_diag.h"

  

@@ -76,20 +88,16 @@ MODBUS_SlaveStart(&hmodbus1, NULL);

  
 //----------------FUNCTIONS FOR USER----------------
-/** 
-  * @addtogroup MODBUS_INIT_FUNCTIONS Functions for Init
-  * @ingroup    MODBUS_FUNCTIONS
-  * @brief      Функции для инициализации
-  @{
-  */
-/* Инициализация периферии модбас. */
-void MODBUS_SetupHardware(RS_HandleTypeDef *hmodbus, UART_HandleTypeDef *huart, TIM_HandleTypeDef *htim);
-/* Программная конфигурация модбас. */
-void MODBUS_Config(RS_HandleTypeDef *hmodbus, uint8_t ID, uint16_t Timeout, uint8_t master);

-/** MODBUS_INIT_FUNCTIONS
-  * @} 
-  */
+/* Инициализация периферии модбас. */
+HAL_StatusTypeDef MODBUS_FirstInit(RS_HandleTypeDef *hmodbus, UART_HandleTypeDef *huart, TIM_HandleTypeDef *htim);
+/* Программная конфигурация модбас. */
+HAL_StatusTypeDef MODBUS_Config(RS_HandleTypeDef *hmodbus, uint8_t ID, uint16_t Timeout, uint8_t master);
+/* Запуск слейв устройства */
+HAL_StatusTypeDef MODBUS_SlaveStart(RS_HandleTypeDef *hmodbus, RS_MsgTypeDef *modbus_msg);
+/* Реквест мастера модбас */
+HAL_StatusTypeDef MODBUS_MasterRequest(RS_HandleTypeDef *hmodbus, RS_MsgTypeDef *modbus_msg, void (*pClbk)(RS_HandleTypeDef*, RS_MsgTypeDef*));
+
  
 //---------PROCESS MODBUS COMMAND FUNCTIONS---------
 /////////////////////////---FUNCTIONS---/////////////////////////////
--- a/Modbus/Inc/modbus_coils.h
+++ b/Modbus/Inc/modbus_coils.h
@@ -42,13 +42,14 @@ typedef enum
 //--------------------------------------------------

 /** 
-  * @brief  Macros to set pointer to a certain register that contains certain coil
-  * @param  _parr_        - массив коилов.
-  * @param  _coil_        - Номер коила от начала массива _arr_.
+  * @brief  Макрос для установки указателя на регистр, содержащий запрашиваемый коил
+  * @param  _parr_  - массив коилов.
+  * @param  _coil_  - Номер коила от начала массива _arr_.
  * @note   Используется вместе с @ref MB_Set_Coil_Mask
  @verbatim Пояснение выражений
-            (_coil_/16) - get index (address shift) of register that contain certain coil
-  Visual explanation: 30th coil in coils registers array
+  - (_coil_/16) - индекс регистра, в котором содержится коил по адресу _coil_
+
+Визуальный пример: 30 коил будет в 30/16 = 1 регистре (индексация с 0)
  xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxCx
  |register[0]----| |register[1]----|
  |skip this------| |get this-------|
@@ -57,15 +58,17 @@ typedef enum
  */
 #define MB_Set_Coil_Reg_Ptr(_parr_, _coil_)           ((uint16_t *)(_parr_)+((_coil_)/16))
 /** 
-  * @brief  Macros to set mask to a certain bit in coils register
-  * @param  _coil_        - Номер коила от начала массива _arr_.
+  * @brief  Макрос для установки маски, чтобы выделить запрашиваемый коил из регистра
+  * @param  _coil_  - Номер коила от начала массива _arr_.
  * @note   Используется вместе с @ref MB_Set_Coil_Reg_Ptr
  @verbatim Пояснение выражений
-            (16*(_coil_/16) - how many coils we need to skip. e.g. (16*30/16) - skip 16 coils from first register
-            _coil_-(16*(_coil_/16)) - shift to certain coil in certain register
-          e.g. Coil(30) gets in register[1] (30/16 = 1) coil №14 (30 - (16*30/16) = 30 - 16 = 14)
+  - (16*(_coil_/16) - сколько коилов нужно пропустить. прим. (16*30/16) - первые 16 коилов находятся вне регистра
+  - _coil_-(16*(_coil_/16)) - сдвинуть бит на место запрашиваемого коила в регистре
  
-  Visual explanation: 30th coil in coils registers array
+  Визуальный пример: 30 коил будет регистре[1], на 14 бите:
+    register = 30/16 = 1
+    bit = 30 - (16*30/16) = 30 - 16 = 14
+    
  xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxCx
  |register[0]----| |register[1]----|
  |skip this------| |get this-------|
@@ -79,14 +82,49 @@ typedef enum
 /////////////////////////---FUNCTIONS---/////////////////////////////
  
 /** 
-* @addtogroup MODBUS_DATA_ACCESS_FUNCTIONS Modbus Data Access
+* @addtogroup MODBUS_DATA_ACCESS_FUNCTIONS API for Data Access
 * @ingroup    MODBUS_FUNCTIONS
-* @brief      Функции для доступа к данным модбас (коилы)
+* @brief      Функции для доступа к данным модбас
@{
 */
+
+
+/**
+  * @addtogroup MODBUS_REQ_COILS_API API for Coils  
+  * @ingroup    MODBUS_REQUEST_MSG
+  * @brief API для чтения coils из ответа в режиме мастер
+  * @details Примеры использования:
+  * 
+  * @code
+  * // Пример: Запросили 10 coils с адреса 20, хотим узнать состояние coil 25
+  * int coil_state;
+  * if(MB_GetCoilState(&MODBUS_MSG, 25, &coil_state))
+  * {
+  *   printf("Coil 25 state: %s\n", coil_state ? "ON" : "OFF");
+  * }
+  * 
+  * // Пример: Получить состояние всех запрошенных coils
+  * for(int addr = MODBUS_MSG.Addr; addr < MODBUS_MSG.Addr + MODBUS_MSG.Qnt; addr++)
+  * {
+  *   int state;
+  *   if(MB_GetCoilState(&MODBUS_MSG, addr, &state))
+  *   {
+  *     printf("Coil %d: %s\n", addr, state ? "ON" : "OFF");
+  *   }
+  * }
+  * @endcode
+  */
+
+int MB_GetCoilState(RS_MsgTypeDef *modbus_msg, uint16_t coil_addr, int *coil_state);
+
+/** MODBUS_REQ_COILS_API
+  * @} 
+  */
+  
+
  
 /** 
-  * @brief  Read Coil at its local address.
+  * @brief  Считать коил по локальному адресу.
  * @param  _parr_        - массив коилов.
  * @param  _coil_        - Номер коила от начала массива _arr_.
  * @return uint16_t      Возвращает запрошенный коил на 0м бите.
@@ -95,7 +133,7 @@ typedef enum
  */
 #define MB_Read_Coil_Local(_parr_, _coil_)          ((  *MB_Set_Coil_Reg_Ptr(_parr_, _coil_)  &   MB_Set_Coil_Mask(_coil_) ) >> (_coil_))
 /** 
-  * @brief  Set Coil at its local address.
+  * @brief  Выставить коил по локальному адресу.
  * @param  _parr_        Указатель на массив коилов.
  * @param  _coil_        - Номер коила от начала массива _arr_.
  * 
@@ -103,7 +141,7 @@ typedef enum
  */
 #define MB_Set_Coil_Local(_parr_, _coil_)             *MB_Set_Coil_Reg_Ptr(_parr_, _coil_)  |=  MB_Set_Coil_Mask(_coil_)
 /** 
-  * @brief  Reset Coil at its local address.
+  * @brief  Сбросить коил по локальному адресу.
  * @param  _parr_        Указатель на массив коилов.
  * @param  _coil_        - Номер коила от начала массива _arr_.
  *
@@ -111,7 +149,7 @@ typedef enum
  */
 #define MB_Reset_Coil_Local(_parr_, _coil_)           *MB_Set_Coil_Reg_Ptr(_parr_, _coil_)  &= ~(MB_Set_Coil_Mask(_coil_))
 /** 
-  * @brief  Set Coil at its local address.
+  * @brief  Переключить состояние коила по локальному адресу.
  * @param  _parr_        Указатель на массив коилов.
  * @param  _coil_        - Номер коила от начала массива _arr_.
  * 
@@ -119,9 +157,9 @@ typedef enum
  */
 #define MB_Toogle_Coil_Local(_parr_, _coil_)          *MB_Set_Coil_Reg_Ptr(_parr_, _coil_)  ^=  MB_Set_Coil_Mask(_coil_)

-/* Set or Reset Coil at its global address */
+/* Выставить/сбросить коил по глобальному адресу */
 MB_ExceptionTypeDef MB_Write_Coil_Global(uint16_t Addr, MB_CoilsOpTypeDef WriteVal);
-/* Read Coil at its global address */
+/* Считать коил по глобальному адресу */
 uint16_t MB_Read_Coil_Global(uint16_t Addr, MB_ExceptionTypeDef *Exception);

 /** MODBUS_DATA_ACCESS_FUNCTIONS
@@ -133,11 +171,11 @@ uint16_t MB_Read_Coil_Global(uint16_t Addr, MB_ExceptionTypeDef *Exception);
  * @addtogroup MODBUS_CMD_PROCESS_FUNCTIONS
  @{
  */
-/* Proccess command Read Coils (01 - 0x01) */
-uint8_t MB_Proccess_Read_Coils(RS_MsgTypeDef *modbus_msg);
-/*  Proccess command Write Single Coils (05 - 0x05) */
-uint8_t MB_Proccess_Write_Single_Coil(RS_MsgTypeDef *modbus_msg);
-/* Proccess command Write Multiple Coils (15 - 0x0F) */
+/* Обработать функцию Read Coils (01 - 0x01) */
+uint8_t MB_Process_Read_Coils(RS_MsgTypeDef *modbus_msg);
+/*  Обработать функцию Write Single Coils (05 - 0x05) */
+uint8_t MB_Process_Write_Single_Coil(RS_MsgTypeDef *modbus_msg);
+/* Обработать функцию Write Multiple Coils (15 - 0x0F) */
 uint8_t MB_Write_Miltuple_Coils(RS_MsgTypeDef *modbus_msg);

 /** MODBUS_CMD_PROCESS_FUNCTIONS
--- a/Modbus/Inc/modbus_config.h
+++ b/Modbus/Inc/modbus_config.h
@@ -25,17 +25,30 @@
 // Строковые идентификаторы устройства
 #define MODBUS_VENDOR_NAME            "NIO-12"
 #define MODBUS_PRODUCT_CODE           ""
-#define MODBUS_REVISION               "Ver. 1.0"
+#define MODBUS_REVISION               ""
 #define MODBUS_VENDOR_URL             ""
 #define MODBUS_PRODUCT_NAME           ""
-#define MODBUS_MODEL_NAME             "STM32F103"
+#define MODBUS_MODEL_NAME             ""
 #define MODBUS_USER_APPLICATION_NAME  ""
 #define MODBUS_NUMB_OF_USEROBJECTS    0

 // Периферия (опционально)
 #define mb_huart                      huart1        ///< Удобный дефайн для модбасовского uart
-#define mb_htim                       htim3         ///< Удобный дефайн для модбасовского таймера
-///< 
+#define mb_htim                       htim2         ///< Удобный дефайн для модбасовского таймера
+//#define RS_EnableReceive()          ///< Функция изменения направления передачи на ПРИЕМ для RS-485
+//#define RS_EnableTransmit()         ///< Функция изменения направления передачи на ПЕРЕДАЧУ для RS-485
+
+
+// Модули modbus
+#define MODBUS_ENABLE_SLAVE                   ///< Включить обработку МАСТЕР режима
+//#define MODBUS_ENABLE_MASTER                  ///< Включить обработку СЛЕЙВ режима
+
+#define MODBUS_ENABLE_COILS                   ///< Включить обработку коилов
+#define MODBUS_ENABLE_HOLDINGS                ///< Включить обработку регистров хранения
+#define MODBUS_ENABLE_INPUTS                  ///< Включить обработку входных регистров
+#define MODBUS_ENABLE_DEVICE_IDENTIFICATORS   ///< Включить обработку идентификаторы устройства
+#define MODBUS_ENABLE_DIAGNOSTICS             ///< Включить обработку диагностики модбас
+

 /**
  * @brief    Поменять комманды 0x03 и 0x04 местами (для LabView терминалки от двигателей)
--- a/Modbus/Inc/modbus_core.h
+++ b/Modbus/Inc/modbus_core.h
@@ -27,6 +27,7 @@
 
 #include "modbus_config.h"
 #include "modbus_data.h"
+#include "__crc_algs.h"

 /** 
  * @addtogroup MODBUS_MESSAGE_DEFINES Modbus Message Tools
@@ -93,8 +94,8 @@ typedef enum //MB_FunctonTypeDef
  MB_W_COILS            = 0x0F,     ///< Запись нескольких битовых ячеек
  MB_W_HOLD_REGS        = 0x10,     ///< Запись нескольких регистров
  
-  MB_R_DIAGNOSTIC       = 0x08,			///< Чтение диагностической информации устройства
-  MB_R_DEVICE_INFO      = 0x2B,			///< Чтение информации об устройстве
+  MB_R_DIAGNOSTIC       = 0x08,     ///< Чтение диагностической информации устройства
+  MB_R_DEVICE_INFO      = 0x2B,     ///< Чтение информации об устройстве
  
  /* ERRORS */
  // error reading
@@ -116,39 +117,39 @@ typedef enum //MB_FunctonTypeDef
 /** @brief Structure for MEI func codes */
 typedef enum //MB_FunctonTypeDef
 {
-  MEI_DEVICE_IDENTIFICATION = 0x0E,
+  MEI_DEVICE_IDENTIFICATIONS = 0x0E,
 }MB_MEITypeDef;

 /** @brief Structure for comformity */
 typedef enum //MB_FunctonTypeDef
 {
-  MB_BASIC_IDENTIFICATION         = 0x01,	  /*!<  @brief Basic Device Identification. 
+  MB_BASIC_IDENTIFICATIONS         = 0x01,   /*!<  @brief Basic Device Identifications. 
                                                  @details All objects of this category are mandatory: 
                                                  VendorName,Product code, and revision number */
  
-  MB_REGULAR_IDENTIFICATION       = 0x02,	  /*!<  @brief Regular Device Identification. 
+  MB_REGULAR_IDENTIFICATIONS       = 0x02,   /*!<  @brief Regular Device Identifications. 
                                                  @details The device provides additional and optional 
-                                                  identification and description data objects */
+                                                  identifications and description data objects */
  
-  MB_EXTENDED_IDENTIFICATION      = 0x03,	  /*!<  @brief Extended Device Identification. 
+  MB_EXTENDED_IDENTIFICATIONS      = 0x03,   /*!<  @brief Extended Device Identifications. 
                                                  @details The device provides additional and optional 
-                                                  identification and description private data about the physical
+                                                  identifications and description private data about the physical
                                                  device itself. All of these data are device dependent. */
  
-  MB_SPEDIFIC_IDENTIFICATION      = 0x04,	  /*!<  @brief Specific Device Identification. 
-                                                  @details The device provides one specific identification object. */
+  MB_SPEDIFIC_IDENTIFICATIONS      = 0x04,   /*!<  @brief Specific Device Identifications. 
+                                                  @details The device provides one specific identifications object. */
  
  /* ERRORS */  
-  MB_ERR_BASIC_IDENTIFICATION = MB_BASIC_IDENTIFICATION + ERR_VALUES_START,
-  MB_ERR_REGULAR_IDENTIFICATION = MB_REGULAR_IDENTIFICATION + ERR_VALUES_START,
-  MB_ERR_EXTENDED_IDENTIFICATION  = MB_REGULAR_IDENTIFICATION + ERR_VALUES_START,
-  MB_ERR_SPEDIFIC_IDENTIFICATION  = MB_REGULAR_IDENTIFICATION + ERR_VALUES_START,
+  MB_ERR_BASIC_IDENTIFICATIONS = MB_BASIC_IDENTIFICATIONS + ERR_VALUES_START,
+  MB_ERR_REGULAR_IDENTIFICATIONS = MB_REGULAR_IDENTIFICATIONS + ERR_VALUES_START,
+  MB_ERR_EXTENDED_IDENTIFICATIONS  = MB_REGULAR_IDENTIFICATIONS + ERR_VALUES_START,
+  MB_ERR_SPEDIFIC_IDENTIFICATIONS  = MB_REGULAR_IDENTIFICATIONS + ERR_VALUES_START,
 }MB_ConformityTypeDef;

-/** @brief Structure for decive identification message type */
+/** @brief Structure for decive identifications message type */
 typedef struct
 {
-  MB_MEITypeDef             MEI_Type;       ///< MEI Type assigned number for Device Identification Interface
+  MB_MEITypeDef             MEI_Type;       ///< MEI Type assigned number for Device Identifications Interface
  MB_ConformityTypeDef      ReadDevId;
  MB_ConformityTypeDef      Conformity;
  uint8_t                   MoreFollows;
@@ -162,7 +163,7 @@ typedef struct  // RS_MsgTypeDef
 {
  uint8_t               MbAddr;             ///< Modbus Slave Address
  MB_FunctonTypeDef     Func_Code;          ///< Modbus Function Code
-  MB_DevIdMsgTypeDef    DevId;              ///< Read Device Identification Header struct
+  MB_DevIdMsgTypeDef    DevId;              ///< Read Device Identifications Header struct
  uint16_t              Addr;               ///< Modbus Address of data
  uint16_t              Qnt;                ///< Quantity of modbus data
  uint8_t               ByteCnt;            ///< Quantity of bytes of data in message to transmit/receive
--- a/Modbus/Inc/modbus_devid.h
+++ b/Modbus/Inc/modbus_devid.h
@@ -1,14 +1,14 @@
 /**
 ******************************************************************************
 * @file modbus_devid.h
-* @brief Идентификация устройства Modbus
+* @brief Идентификаторы устройства Modbus
 ******************************************************************************
-@addtogroup MODBUS_DEVID Device Identificators Tools
+@addtogroup MODBUS_DEVID Device Identifications Tools
@ingroup MODBUS_INTERNAL
@{
 ******************************************************************************
 * @details
-Модуль реализации функции Read Device Identification (0x2B):
+Модуль реализации функции Read Device Identifications (0x2B):
 - Базовая идентификация (Vendor, Product, Revision)
 - Расширенная идентификация (URL, Model, User fields)
 - Поддержка потоковой передачи больших объектов
@@ -48,35 +48,11 @@ typedef struct
  MB_DeviceObjectTypeDef  Reserved[0x79];
  
  MB_DeviceObjectTypeDef  User[MODBUS_NUMB_OF_USEROBJECTS];
-}MB_DeviceIdentificationTypeDef;
-extern MB_DeviceIdentificationTypeDef MB_DEVID;
+}MB_DeviceIdentificationsTypeDef;
+extern MB_DeviceIdentificationsTypeDef MB_DEVID;
 void MB_DeviceInentificationInit(void);
 ///////////////---DEVICE IDENTIVICATIONS DEFINES---//////////////////

-/////////////////////////////////////////////////////////////////////
-/////////////////---DEVICE DIAGNOSTICS DEFINES---////////////////////
-
-/** @brief Структура со диагностической информацией устройства модбас */
-typedef struct
-{
-  uint16_t DiagnosticRegister;
-  struct
-  {
-    uint16_t BusMessage;
-    uint16_t BusCommunicationErr;
-    uint16_t BusExceptionErr;
-    uint16_t SlaveMessage;
-    uint16_t SlaveNoResponse;
-    uint16_t SlaveNAK;
-    uint16_t SlaveBusy;
-    uint16_t BusCharacterOverrun;
-  }Counters;
-}MB_DiagnosticsInfoTypeDef;
-extern MB_DiagnosticsInfoTypeDef MB_DINFO;
-
-
-/////////////////---DEVICE DIAGNOSTICS DEFINES---////////////////////
-

 /////////////////////////////////////////////////////////////////////
 ////////////////////---MODBUS FUNCTION DEFINES---////////////////////
@@ -101,18 +77,65 @@ extern MB_DiagnosticsInfoTypeDef MB_DINFO;
 /////////////////////////////////////////////////////////////////////
 /////////////////////////---FUNCTIONS---/////////////////////////////
  
+/**
+  * @addtogroup MODBUS_REQ_DEFID_API API for Device Identifications
+  * @ingroup    MODBUS_REQUEST_MSG
+  * @brief Макросы для чтения идентификторов из ответа в режиме мастер
+  * @details Примеры использования:
+  * 
+  * @code
+  * // Пример 1: Получить VendorName (ID = 0x00)
+  * uint8_t length;
+  * char vendor_name[64];
+  * if(MB_FindObjectById(&MODBUS_MSG, 0x00, vendor_name, &length))
+  * {
+  *   // получено
+  * }
+  * 
+  * // Пример 2: Перебрать все объекты в сообщении
+  * uint8_t obj_id, obj_length;
+  * char obj_data[256];
+  * 
+  * int obj_count = MB_GetNumberOfObjects(&MODBUS_MSG);
+  * printf("Total objects: %d\n", obj_count);
+  * 
+  * for(int i = 0; i < obj_count; i++)
+  * {
+  *   if(MB_GetObjectByIndex(&MODBUS_MSG, i, &obj_id, obj_data, &obj_length))
+  *   {
+  *     // получено
+  *   }
+  * }
+  * @endcode
+  */
+  
+/* Получить количество объектов в сообщении */
+int MB_GetNumberOfObjects(RS_MsgTypeDef *modbus_msg);
+/* Найти объект по ID в сообщении */
+int MB_FindObjectById(RS_MsgTypeDef *modbus_msg, uint8_t obj_id, char *obj_data, uint8_t *obj_length);
+/* Получить объект по индексу в сообщении */
+int MB_GetObjectByIndex(RS_MsgTypeDef *modbus_msg, int index, uint8_t *obj_id, char *obj_data, uint8_t *obj_length);
+
+    
+/** MODBUS_REQ_DEFID_API
+* @} 
+*/
+  
+  
+  
+/* Записать Один Объект Идентификатора в массив данных */
+void MB_WriteSingleObjectToMessage(char *mbdata, unsigned *ind, MB_DeviceObjectTypeDef *obj);
+/* Записать Массив Объектов Идентификатора в массив данных */
+void MB_WriteObjectsToMessage(RS_MsgTypeDef *modbus_msg, unsigned maxidofobj);
+
 //---------PROCESS MODBUS COMMAND FUNCTIONS---------
 /** 
  * @addtogroup MODBUS_CMD_PROCESS_FUNCTIONS
  @{
  */
  
-/* Write Object of Device Identification to MessageData */
-void MB_WriteSingleObjectToMessage(char *mbdata, unsigned *ind, MB_DeviceObjectTypeDef *obj);
-/* Write Object of Device Identification to MessageData */
-void MB_WriteObjectsToMessage(RS_MsgTypeDef *modbus_msg, unsigned maxidofobj);
-/* Proccess command Read Device Identification (43/14 - 0x2B/0E) */
-uint8_t MB_Proccess_Read_Device_Identification(RS_MsgTypeDef *modbus_msg);
+/* Обработать функцию Read Device Identifications (43/14 - 0x2B/0E) */
+uint8_t MB_Process_Read_Device_Identifications(RS_MsgTypeDef *modbus_msg);
 /** MODBUS_CMD_PROCESS_FUNCTIONS
  * @} 
  */
--- a/Modbus/Inc/modbus_diag.h
+++ b/Modbus/Inc/modbus_diag.h
@@ -0,0 +1,133 @@
+/**
+******************************************************************************
+* @file modbus_diag.h
+* @brief Диагностика устройства Modbus
+******************************************************************************
+@addtogroup MODBUS_DIAG Diagnostics Tools
+@ingroup MODBUS_INTERNAL
+@{
+******************************************************************************
+* @details
+Модуль реализации Diagnostics (Serial Line only) (0x08):
+- Полная поддержка всех подфункций диагностики
+- Возможность выставить/сбросить любой бит в диагностическом регистре
+- Сбор статистики работы устройства
+- Управление режимами работы
+******************************************************************************/
+#ifndef __MODBUS_DIAG_H_
+#define __MODBUS_DIAG_H_ 
+#include "modbus_core.h"
+
+/////////////////////////////////////////////////////////////////////
+/////////////////---DEVICE DIAGNOSTICS DEFINES---////////////////////
+
+/** @brief Режимы работы устройства */
+typedef enum
+{
+  MODBUS_NORMAL_MODE = 0,
+  MODBUS_LISTEN_ONLY_MODE = 1
+} MB_DeviceModeTypeDef;
+
+
+/** @brief Структура со диагностической информацией устройства модбас */
+typedef struct
+{
+  uint16_t DiagnosticRegister;    ///< Регистр диагностики. 0 бит - overrun. Остальное заполняется пользователем
+  MB_DeviceModeTypeDef DeviceMode;///< Режим устройства - NORMAL/LISTEN_ONLY
+  struct
+  {
+    uint16_t BusMessage;          ///< Все принятые фреймы modbus на линии (с всех адресов)
+    uint16_t BusCommunicationErr; ///< Ошибки при приеме фрейма modbus
+    uint16_t BusExceptionErr;     ///< Ошибки при обработке фрейма modbus
+    uint16_t SlaveMessage;        ///< Принятые сообщения (только запросы на адрес данного устройства)
+    uint16_t SlaveNoResponse;     ///< Счетчик сколько мы раз не ответили на запрос 
+    uint16_t SlaveNAK;            ///< Счетчик аномальной ошибки при обработке фрейма
+    uint16_t SlaveBusy;           ///< Счетчик принятых запросов когда устройство занято. Здесь не работает: из-за архитектуры отследить невозможно
+    uint16_t BusCharacterOverrun; ///< Overrun Error
+  } Counters;
+} MB_DiagnosticsInfoTypeDef;
+
+extern MB_DiagnosticsInfoTypeDef MB_DIAG;
+
+/////////////////---DEVICE DIAGNOSTICS DEFINES---////////////////////
+
+/////////////////////////////////////////////////////////////////////
+/////////////////////////---FUNCTIONS---/////////////////////////////
+
+/* Инициализация диагностических счетчиков */
+void MB_DiagnosticsInit(void);
+
+/**
+  * @addtogroup MODBUS_REQ_DIAG_API API for Diagnostics
+  * @ingroup    MODBUS_REQUEST_MSG  
+  * @brief API для чтения диагностической информации из ответа в режиме мастер
+  * @details Примеры использования:
+  * 
+  * @code
+  * Получить данные диагностики (значение счетчика)
+  * uint16_t counter_value;
+  * if(MB_GetDiagnosticResponse(&MODBUS_MSG, &counter_value))
+  * {
+  *   printf("Counter value: %d\n", counter_value);
+  * }
+  * @endcode
+  */
+int MB_GetDiagnosticResponse(RS_MsgTypeDef *modbus_msg, uint16_t *data);
+/** MODBUS_REQ_DIAG_API
+  * @} 
+  */
+
+
+
+
+
+
+
+
+/** 
+* @addtogroup MODBUS_DATA_ACCESS_FUNCTIONS
+@{
+*/
+
+/* Выставить бит в регистре диагностике */
+int MB_Diagnostics_WriteBit(int bit_num, int bit_state);
+/*ь Прочитать состояние бита диагностического регистра */
+int MB_Diagnostics_GetBit(int bit_num);
+/* Получение текущего режима устройства */
+MB_DeviceModeTypeDef MB_GetDeviceMode(void);
+/** MODBUS_CMD_PROCESS_FUNCTIONS
+  * @} 
+  */
+
+//---------PROCESS MODBUS COMMAND FUNCTIONS---------
+/** 
+  * @addtogroup MODBUS_CMD_PROCESS_FUNCTIONS
+  @{
+  */
+  
+/* Обработка команды диагностики (0x08) */
+uint8_t MB_Process_Diagnostics(RS_MsgTypeDef *modbus_msg);
+
+/** MODBUS_CMD_PROCESS_FUNCTIONS
+  * @} 
+  */
+  
+  
+/* Функции для обновления счетчиков диагностики */
+void MB_Diagnostics_BusMessageCnt(void);
+void MB_Diagnostics_CommunicationErrorCnt(void);
+void MB_Diagnostics_ExceptionErrorCnt(void);
+void MB_Diagnostics_CharacterOverrunCnt(void);
+void MB_Diagnostics_SlaveMessageCnt(void);
+void MB_Diagnostics_SlaveNoResponseCnt(void);
+void MB_Diagnostics_SlaveNAKCnt(void);
+void MB_Diagnostics_SlaveBusyCnt(void);
+
+
+/////////////////////////---FUNCTIONS---/////////////////////////////
+
+#endif //__MODBUS_DIAG_H_
+
+/** MODBUS_DIAG
+  * @} 
+  */
--- a/Modbus/Inc/modbus_holdregs.h
+++ b/Modbus/Inc/modbus_holdregs.h
@@ -29,12 +29,12 @@
  * @addtogroup MODBUS_CMD_PROCESS_FUNCTIONS
  @{
  */
-/* Proccess command Read Holding Registers (03 - 0x03) */
-uint8_t MB_Proccess_Read_Hold_Regs(RS_MsgTypeDef *modbus_msg);
-/*  Proccess command Write Single Coils (06 - 0x06) */
-uint8_t MB_Proccess_Write_Single_Reg(RS_MsgTypeDef *modbus_msg);
-/* Proccess command Write Multiple Register (16 - 0x10) */
-uint8_t MB_Proccess_Write_Miltuple_Regs(RS_MsgTypeDef *modbus_msg);
+/* Обработать функцию Read Holding Registers (03 - 0x03) */
+uint8_t MB_Process_Read_Hold_Regs(RS_MsgTypeDef *modbus_msg);
+/* Обработать функцию Write Single Coils (06 - 0x06) */
+uint8_t MB_Process_Write_Single_Reg(RS_MsgTypeDef *modbus_msg);
+/* Обработать функцию Write Multiple Register (16 - 0x10) */
+uint8_t MB_Process_Write_Miltuple_Regs(RS_MsgTypeDef *modbus_msg);

 /** MODBUS_CMD_PROCESS_FUNCTIONS
  * @} 
--- a/Modbus/Inc/modbus_inputregs.h
+++ b/Modbus/Inc/modbus_inputregs.h
@@ -24,13 +24,13 @@

 //---------PROCESS MODBUS COMMAND FUNCTIONS---------
 /** 
-  * @addtogroup MODBUS_CMD_PROCESS_FUNCTIONS Proccess Functions
+  * @addtogroup MODBUS_CMD_PROCESS_FUNCTIONS Internal Process Functions
  * @ingroup    MODBUS_FUNCTIONS
  * @brief      Функции обработки запросов модбас
  @{
  */
-/* Proccess command Read Input Registers (04 - 0x04) */
-uint8_t MB_Proccess_Read_Input_Regs(RS_MsgTypeDef *modbus_msg);
+/* Обработать функцию Read Input Registers (04 - 0x04) */
+uint8_t MB_Process_Read_Input_Regs(RS_MsgTypeDef *modbus_msg);

 /** MODBUS_CMD_PROCESS_FUNCTIONS
  * @} 
--- a/Modbus/Inc/modbus_master.h
+++ b/Modbus/Inc/modbus_master.h
@@ -0,0 +1,121 @@
+/**
+******************************************************************************
+* @file modbus_master.h
+* @brief Главный заголовочный файл Modbus библиотеки
+******************************************************************************
+@addtogroup MODBUS_MASTER Modbus master funtions
+@ingroup    MODBUS_CMD_PROCESS_FUNCTIONS
+@{
+******************************************************************************
+* @details
+Модуль реализации обработки UART сообщение в режиме мастер
+******************************************************************************/
+#ifndef __MODBUS_MASTER_H_
+#define __MODBUS_MASTER_H_
+ 
+#include "rs_message.h"
+
+#ifdef MODBUS_ENABLE_MASTER
+#define MODBUS_MODE_MASTER 1
+#endif
+
+/**
+  * @addtogroup MODBUS_REQUEST_MSG API for Master Requests
+  * @ingroup    MODBUS_FUNCTIONS
+  * @brief Макросы для создания запросов в режиме мастер
+  * @details Примеры использования:
+  * 
+  * // Чтение 10 holding registers начиная с адреса 0
+  * RS_MsgTypeDef read_msg = MB_REQUEST_READ_HOLDING_REGS(1, 0, 10);
+  * 
+  * // Запись одного coil
+  * RS_MsgTypeDef write_coil_msg = MB_REQUEST_WRITE_SINGLE_COIL(1, 5, 1);
+  * 
+  * // Диагностический запрос
+  * RS_MsgTypeDef diag_msg = MB_REQUEST_RETURN_BUS_MESSAGE_COUNT(1);
+  * 
+  * // Идентификация устройства
+  * RS_MsgTypeDef dev_id_msg = MB_REQUEST_READ_DEVICE_ID_BASIC(1);
+  */
+  
+//---------КЛАССИЧЕСКИЕ ДАННЫЕ-----------
+RS_MsgTypeDef MB_REQUEST_READ_COILS(uint8_t slave_addr, uint16_t start_addr, uint16_t quantity);
+RS_MsgTypeDef MB_REQUEST_READ_DISCRETE_INPUTS(uint8_t slave_addr, uint16_t start_addr, uint16_t quantity);
+RS_MsgTypeDef MB_REQUEST_READ_HOLDING_REGS(uint8_t slave_addr, uint16_t start_addr, uint16_t quantity);
+RS_MsgTypeDef MB_REQUEST_READ_INPUT_REGS(uint8_t slave_addr, uint16_t start_addr, uint16_t quantity);
+RS_MsgTypeDef MB_REQUEST_WRITE_SINGLE_COIL(uint8_t slave_addr, uint16_t coil_addr, uint8_t value);
+RS_MsgTypeDef MB_REQUEST_WRITE_SINGLE_REG(uint8_t slave_addr, uint16_t reg_addr, uint16_t value);
+RS_MsgTypeDef MB_REQUEST_WRITE_MULTIPLE_COILS(uint8_t slave_addr, uint16_t start_addr, uint16_t quantity, uint8_t *coils_data);
+RS_MsgTypeDef MB_REQUEST_WRITE_MULTIPLE_REGS(uint8_t slave_addr, uint16_t start_addr, uint16_t quantity, uint16_t *regs_data);
+
+//---------ДИАГНОСТИЧЕСКИЕ ДАННЫЕ-----------
+RS_MsgTypeDef MB_REQUEST_DIAGNOSTIC_QUERY(uint8_t slave_addr, uint16_t sub_function, uint16_t data);
+RS_MsgTypeDef MB_REQUEST_RETURN_QUERY_DATA(uint8_t slave_addr);
+RS_MsgTypeDef MB_REQUEST_RESTART_COMMUNICATIONS(uint8_t slave_addr, uint16_t data);
+RS_MsgTypeDef MB_REQUEST_RETURN_DIAGNOSTIC_REGISTER(uint8_t slave_addr);
+RS_MsgTypeDef MB_REQUEST_FORCE_LISTEN_ONLY_MODE(uint8_t slave_addr);
+RS_MsgTypeDef MB_REQUEST_CLEAR_COUNTERS_AND_DIAGNOSTIC_REGISTER(uint8_t slave_addr);
+RS_MsgTypeDef MB_REQUEST_RETURN_BUS_MESSAGE_COUNT(uint8_t slave_addr);
+RS_MsgTypeDef MB_REQUEST_RETURN_BUS_COMMUNICATION_ERROR_COUNT(uint8_t slave_addr);
+RS_MsgTypeDef MB_REQUEST_RETURN_SLAVE_EXCEPTION_ERROR_COUNT(uint8_t slave_addr);
+RS_MsgTypeDef MB_REQUEST_RETURN_SLAVE_MESSAGE_COUNT(uint8_t slave_addr);
+RS_MsgTypeDef MB_REQUEST_RETURN_SLAVE_NO_RESPONSE_COUNT(uint8_t slave_addr);
+RS_MsgTypeDef MB_REQUEST_RETURN_SLAVE_NAK_COUNT(uint8_t slave_addr);
+RS_MsgTypeDef MB_REQUEST_RETURN_SLAVE_BUSY_COUNT(uint8_t slave_addr);
+RS_MsgTypeDef MB_REQUEST_RETURN_BUS_CHARACTER_OVERRUN_COUNT(uint8_t slave_addr);
+
+//---------ИДЕНТИФИКАТОРЫ МОДБАС-----------
+RS_MsgTypeDef MB_REQUEST_READ_DEVICE_ID_BASIC(uint8_t slave_addr);
+RS_MsgTypeDef MB_REQUEST_READ_DEVICE_ID_REGULAR(uint8_t slave_addr);
+RS_MsgTypeDef MB_REQUEST_READ_DEVICE_ID_EXTENDED(uint8_t slave_addr);
+RS_MsgTypeDef MB_REQUEST_READ_DEVICE_ID_SPECIFIC(uint8_t slave_addr, uint8_t object_id);
+/** MODBUS_REQUEST_MSG
+  * @} 
+  */
+  
+  
+/**
+  * @addtogroup MODBUS_REGS_API API for Registers
+  * @ingroup    MODBUS_REQUEST_MSG
+  * @brief API для чтения регистров из ответа в режиме мастер
+  * @details Примеры использования:
+  * 
+  * @code
+  * // Пример: Запросили 10 регистров с адреса 100, хотим получить значение регистра 105
+  * uint16_t reg_value;
+  * if(MB_GetRegisterValue(&MODBUS_MSG, 105, &reg_value))
+  * {
+  *   printf("Register 105 value: %d\n", reg_value);
+  * }
+  * 
+  * // Пример: Получить все запрошенные регистры
+  * for(int addr = MODBUS_MSG.Addr; addr < MODBUS_MSG.Addr + MODBUS_MSG.Qnt; addr++)
+  * {
+  *   uint16_t value;
+  *   if(MB_GetRegisterValue(&MODBUS_MSG, addr, &value))
+  *   {
+  *     printf("Register %d: %d\n", addr, value);
+  *   }
+  * }
+  * @endcode
+  */
+  
+int MB_GetRegisterValue(RS_MsgTypeDef *modbus_msg, uint16_t reg_addr, uint16_t *reg_value);
+  
+
+/** MODBUS_REQ_REGS_API
+  * @} 
+  */
+
+
+/* Сбор сообщения в буфер UART в режиме мастер (фрейм мастера из msg -> uart) */
+RS_StatusTypeDef MB_Master_Collect_Message(RS_HandleTypeDef *hmodbus, RS_MsgTypeDef *modbus_msg, uint8_t *modbus_uart_buff);
+/* Парс сообщения в режиме мастер (фрейм слейва из uart -> msg) */
+RS_StatusTypeDef MB_Master_Parse_Message(RS_HandleTypeDef *hmodbus, RS_MsgTypeDef *modbus_msg, uint8_t *modbus_uart_buff);
+
+
+#endif //__MODBUS_MASTER_H_
+
+/** MODBUS_MASTER
+  * @} 
+  */
--- a/Modbus/Inc/modbus_slave.h
+++ b/Modbus/Inc/modbus_slave.h
@@ -0,0 +1,34 @@
+/**
+******************************************************************************
+* @file modbus_slave.h
+* @brief Главный заголовочный файл Modbus библиотеки
+******************************************************************************
+@addtogroup MODBUS_SLAVE Modbus slave funtions
+@ingroup    MODBUS_CMD_PROCESS_FUNCTIONS
+@{
+******************************************************************************
+* @details
+Модуль реализации обработки UART сообщение в режиме слейв
+******************************************************************************/
+#ifndef __MODBUS_SLAVE_H_
+#define __MODBUS_SLAVE_H_
+ 
+#include "rs_message.h"
+
+
+#ifdef MODBUS_ENABLE_SLAVE
+#define MODBUS_MODE_SLAVE 0
+#endif
+
+/* Ответ на сообщение в режиме слейва */
+RS_StatusTypeDef MB_Slave_Response(RS_HandleTypeDef *hmodbus, RS_MsgTypeDef *modbus_msg);
+/* Сбор сообщения в буфер UART в режиме слейв (фрейм слейва из msg -> uart) */
+RS_StatusTypeDef MB_Slave_Collect_Message(RS_HandleTypeDef *hmodbus, RS_MsgTypeDef *modbus_msg, uint8_t *modbus_uart_buff);
+/* Парс сообщения в режиме слейв (фрейм мастера из uart -> msg) */
+RS_StatusTypeDef MB_Slave_Parse_Message(RS_HandleTypeDef *hmodbus, RS_MsgTypeDef *modbus_msg, uint8_t *modbus_uart_buff);
+
+#endif //__MODBUS_SLAVE_H_
+
+/** MODBUS_MASTER
+  * @} 
+  */
--- a/Modbus/Inc/rs_message.h
+++ b/Modbus/Inc/rs_message.h
@@ -40,10 +40,6 @@
 #error Define MSG_SIZE_MAX (Maximum size of message). This is necessary to create buffer for UART.
 #endif

-#ifndef RX_FIRST_PART_SIZE
-#error Define RX_FIRST_PART_SIZE (Size of first part of message). This is necessary to receive the first part of the message, from which determine the size of the remaining part of the message.
-#endif
-
 /**
  * @cond Заглушки и внутренний недокументированный стаф
  */
@@ -55,14 +51,14 @@
 #define RS_Set_Free(_hRS_)          _hRS_->f.RS_Busy = 0
 #define RS_Set_Busy(_hRS_)          _hRS_->f.RS_Busy = 1

-#define RS_Set_RX_Flags(_hRS_)          _hRS_->f.RX_Busy = 1; _hRS_->f.RX_Done = 0; _hRS_->f.RX_Half = 0
+#define RS_Set_RX_Flags(_hRS_)          _hRS_->f.RX_Busy = 1; _hRS_->f.RX_Done = 0;
 #define RS_Set_RX_Active_Flags(_hRS_)   _hRS_->f.RX_Ongoing = 1


 #define RS_Set_TX_Flags(_hRS_)          _hRS_->f.TX_Busy = 1; _hRS_->f.TX_Done = 0

-#define RS_Reset_RX_Active_Flags(_hRS_) _hRS_->f.RX_Ongoing = 0
-#define RS_Reset_RX_Flags(_hRS_)        RS_Reset_RX_Active_Flags(_hRS_); _hRS_->f.RX_Busy = 0; _hRS_->f.RX_Done = 0; _hRS_->f.RX_Half = 0
+#define RS_Reset_RX_Active_Flags(_hRS_) _hRS_->f.RX_Ongoing = 0; _hRS_->f.RX_Continue = 0;
+#define RS_Reset_RX_Flags(_hRS_)        RS_Reset_RX_Active_Flags(_hRS_); _hRS_->f.RX_Busy = 0; _hRS_->f.RX_Done = 0;
 #define RS_Reset_TX_Flags(_hRS_)        _hRS_->f.TX_Busy = 0; _hRS_->f.TX_Done = 0

 #define RS_Set_RX_End_Flag(_hRS_)   _hRS_->f.RX_Done = 1;
@@ -79,15 +75,16 @@
 #define RS_Is_RX_Busy(_hRS_)        (_hRS_->f.RX_Busy == 1)
 #define RS_Is_TX_Busy(_hRS_)        (_hRS_->f.TX_Busy == 1)

-// направление передачи rs485
-#ifndef RS_EnableReceive
-#define RS_EnableReceive()
-#endif
-#ifndef RS_EnableTransmit
-#define RS_EnableTransmit()
+
+#ifndef printf_rs_err
+#define printf_rs_err(...)
 #endif

-#ifndef __MYLIBS_INCLUDE_H_
+#ifndef printf_rs
+#define printf_rs(...)
+#endif
+
+#ifndef __MYLIBS_CONFIG_H_
 // дефайны из mylibs include
 static int dummy;
 #define TrackerTypeDef(num_user_vars) void *
@@ -110,20 +107,24 @@ static int dummy;
 #define TrackerClear_Warn(_cntstruct_)                       
 #define TrackerClear_User(_cntstruct_)                       
 #define TrackerClear_UserAll(_cntstruct_)  
-
-#ifndef printf_rs_err
-#define printf_rs_err(...)
+#else
+#include "mylibs_include.h"
 #endif

-#ifndef printf_rs
-#define printf_rs(...)
-#endif
-#endif

 #ifndef RS_USER_VARS_NUMB
 #define RS_USER_VARS_NUMB 0
 #endif
 /** @endcond */
+
+
+// направление передачи rs485
+#ifndef RS_EnableReceive
+#define RS_EnableReceive()  ///< Функция изменения направления передачи на ПРИЕМ для RS-485
+#endif
+#ifndef RS_EnableTransmit
+#define RS_EnableTransmit() ///< Функция изменения направления передачи на ПЕРЕДАЧУ для RS-485
+#endif
 ////////////////////////////---DEFINES---////////////////////////////


@@ -149,61 +150,44 @@ typedef enum    // RS_StatusTypeDef
 }RS_StatusTypeDef;


-#define RS_MASTER_START   0x3
+#define RS_MASTER_MODE_START   0x3 ///< Начало режимов мастера (до него - режим слейв)
 /** @brief Enums for RS Modes */
 typedef enum  // RS_ModeTypeDef
 {
-  RS_SLAVE_ALWAYS_WAIT =       0x01,   ///< Slave mode with infinity waiting
-  RS_SLAVE_TIMEOUT_WAIT =      0x02,   ///< Slave mode with waiting with timeout
-//  RS_MASTER =                  0x03,   ///< Master mode
+  RS_SLAVE_ALWAYS_WAIT    = 0x01,   ///< Слейв в постоянном ожидании
+  RS_RESERVED             = 0x02,   ///< резерв
+  RS_MASTER_REQUEST       = 0x03,   ///< Мастер с ручным запросом
+  //RS_MASTER_POLLING       = 0x04,   ///< Мастер с опросом в фоновом режиме
 }RS_ModeTypeDef;

-/** @brief Enums for RS UART Modes */
-typedef enum  // RS_ITModeTypeDef
-{
-  BLCK_MODE =     0x00,   ///< Blocking mode
-  IT_MODE =       0x01,   ///< Interrupt mode
-}RS_ITModeTypeDef;
-
 /** @brief Enums for Abort modes */
 typedef enum  // RS_AbortTypeDef
 {
-  ABORT_TX =      0x01,   ///< Abort transmit
-  ABORT_RX =      0x02,   ///< Abort receive
-  ABORT_RX_TX =   0x03,   ///< Abort receive and transmit
-  ABORT_RS =      0x04,   ///< Abort uart and reset RS structure
+  ABORT_TX =      0x01,   ///< Отменить передачу
+  ABORT_RX =      0x02,   ///< Отменить прием
+  ABORT_RX_TX =   0x03,   ///< Отменить прием и передачу
+  ABORT_RS =      0x04,   ///< Отменить любую работу UART в целом
 }RS_AbortTypeDef;

-/** @brief Enums for RX Size modes */
-typedef enum  // RS_RXSizeTypeDef
-{
-  RS_RX_Size_Const =      0x01,   ///< size of receiving message is constant
-  RS_RX_Size_NotConst =   0x02,   ///< size of receiving message isnt constant
-}RS_RXSizeTypeDef;
-
-
 //-----------STRUCTURE FOR HANDLE RS------------
 /** @brief Struct for flags RS */
 typedef struct
 {
-  unsigned                  RX_Half:1;            ///< flag: 0 - receiving msg before ByteCnt,  0 - receiving msg after ByteCnt
+  unsigned                  RS_Busy:1;            ///< 1 - RS занят, 0 - RS свободен
+  unsigned                  RX_Ongoing:1;         ///< 1 - Прием данных в активном состоянии,  0 - Ожидаем начало приема данных
  
-  unsigned                  RS_Busy:1;            ///< flag: 1 - RS is busy, 0 - RS isnt busy   
-  unsigned                  RX_Ongoing:1;         ///< flag: 1 - receiving data right now,  0 - waiting for receiving data
+  unsigned                  RX_Busy:1;            ///< 1 - Режим приема активен,    0 - Прием не активен
+  unsigned                  TX_Busy:1;            ///< 1 - Режим передачи активен,  0 - Прием не активен       
  
-  unsigned                  RX_Busy:1;            ///< flag: 1 - receiving is active,   0 - receiving isnt active
-  unsigned                  TX_Busy:1;            ///< flag: 1 - transmiting is active, 0 - transmiting isnt active       
-  
-  unsigned                  RX_Done:1;            ///< flag: 1 - receiving is done,   0 - receiving isnt done 
-  unsigned                  TX_Done:1;            ///< flag: 1 - transmiting is done, 0 - transmiting isnt done 
+  unsigned                  RX_Done:1;            ///< 1 - Прием закончен,          0 - Прием еще в процессе или не инициализирован
+  unsigned                  TX_Done:1;            ///< 1 - Передача закончена,      0 - Передача еще в процессе или не инициализирована 
    
-  // setted by user
-  unsigned                  RX_Continue:1;        ///< flag: 0 - continue receiving,  0 - start receiving from ind = 0
-  unsigned                  MessageHandled:1;     ///< flag: 1 - RS command is handled,         0 - RS command isnt handled yet
-  unsigned                  EchoResponse:1;       ///< flag: 1 - response with received msg,    0 - response with own msg
-  unsigned                  DeferredResponse:1;   ///< flag: 1 - response not in interrupt,     0 - response in interrupt
-	unsigned 								  DataUpdated:1;		    ///< flag: 1 - Received command to write colis/resg
-  unsigned                  ReInit_UART:1;        ///< flag: 1 - need to reinitialize uart,     0 - nothing 
+  // Выставление следующие флагов определяет пользователь
+  unsigned                  RX_Continue:1;        ///< 0 - Продолжить принимать,        0 - Начать прием сначала
+  unsigned                  MessageHandled:1;     ///< 1 - Обработка запроса успешна,   0 - Обработка запроса в процессе или ошибка
+  unsigned                  EchoResponse:1;       ///< 1 - Ответить эхом,               0 - Ответить своим сообщением
+  unsigned                  DeferredResponse:1;   ///< 1 - Не начинать передачу в IT,   0 - Ответить в прерывании
+  unsigned                  DataUpdated:1;        ///< 1 - Данные были обновлены
 }RS_FlagsTypeDef;


@@ -215,25 +199,24 @@ typedef struct
 typedef struct  // RS_HandleTypeDef
 {   
  /* MESSAGE */
-  uint8_t                   ID;                   ///< ID of RS "channel"
-  RS_MsgTypeDef             *pMessagePtr;         ///< pointer to message struct
-  uint8_t                   *pBufferPtr;          ///< pointer to message buffer
+  uint8_t                   ID;                   ///< ID хендла
+  RS_MsgTypeDef             *pMessagePtr;         ///< Указатель на структуру протокола
+  uint8_t                   *pBufferPtr;          ///< Указатеь на буфер UART
  int32_t                   RS_Message_Size;      ///< size of whole message, not only data
  
  /* HANDLERS and SETTINGS */
-  UART_HandleTypeDef        *huart;               ///< handler for used uart
-  TIM_HandleTypeDef         *htim;                ///< handler for used tim
-  RS_ModeTypeDef            sRS_Mode;             ///< setting: slave or master @ref RS_ModeTypeDef
-  RS_ITModeTypeDef          sRS_IT_Mode;          ///< setting: 1 - IT mode,  0 - Blocking mode 
-  uint16_t                  sRS_Timeout;          ///< setting: timeout in ms
-  RS_RXSizeTypeDef          sRS_RX_Size_Mode;     ///< setting: 1 - not const, 0 - const 
+  UART_HandleTypeDef        *huart;               ///< Хендл UART
+  TIM_HandleTypeDef         *htim;                ///< Хендл TIM
+  RS_ModeTypeDef            sRS_Mode;             ///< Настройка: слейв/мастер @ref RS_ModeTypeDef
+  uint16_t                  sRS_Timeout;          ///< Настройка: Таймаут в тиках таймера
+  void                      (*pCallback)(void*, void*);   ///< Указатель на коллбек: принят ответ в режиме мастер
  
  /* FLAGS */   
-  RS_FlagsTypeDef           f;                    ///< These flags for controling receive/transmit
+  RS_FlagsTypeDef           f;                    ///< Флаги для контроля приема/передачи
  
  /* RS STATUS */
-  uint32_t                  lastPacketTick;
-  RS_StatusTypeDef          RS_STATUS;            ///< RS status
+  uint32_t                  lastPacketTick;       ///< Время последнего принятого пакета
+  RS_StatusTypeDef          RS_STATUS;            ///< Статус RS
  
  TrackerTypeDef(RS_USER_VARS_NUMB) rs_err;
 }RS_HandleTypeDef;
@@ -247,47 +230,53 @@ extern RS_HandleTypeDef hmodbus1;
 ///////////////////////////---FUNCTIONS---///////////////////////////
 //----------------FUNCTIONS FOR PROCESSING MESSAGE-------------------
 /*--------------------Defined by users purposes--------------------*/
-/* Respond accord to received message */
+/* Пользовательская функция для ответа на запрос по UART */
 RS_StatusTypeDef RS_Response(RS_HandleTypeDef *hRS, RS_MsgTypeDef *RS_msg);

-/* Collect message in buffer to transmit it */
+/* Пользовательская функция для обработки принятого ответа по UART */
+__weak RS_StatusTypeDef RS_Response_Callback(RS_HandleTypeDef *hRS, RS_MsgTypeDef *RS_msg);
+
+/* Пользовательская функция для сбора сообщения в буфер UART */
 RS_StatusTypeDef RS_Collect_Message(RS_HandleTypeDef *hRS, RS_MsgTypeDef *RS_msg, uint8_t *msg_uart_buff);

-/* Parse message from buffer to process it */
+/* Пользовательская функция для парса сообщения из буфера UART */
 RS_StatusTypeDef RS_Parse_Message(RS_HandleTypeDef *hRS, RS_MsgTypeDef *RS_msg, uint8_t *msg_uart_buff);


 //-------------------------GENERAL FUNCTIONS-------------------------
 /*-----------------Should be called from main code-----------------*/
-/* Start receive IT */
+/* Начать прием по прерываниям */
 RS_StatusTypeDef RS_Receive_IT(RS_HandleTypeDef *hRS, RS_MsgTypeDef *RS_msg);

-/* Start transmit IT */
+/* Начать передачу по прерываниям */
 RS_StatusTypeDef RS_Transmit_IT(RS_HandleTypeDef *hRS, RS_MsgTypeDef *RS_msg);

-/* Initialize UART and handle RS stucture */
+/* Инициалазация структуры @ref RS_HandleTypeDef */
 RS_StatusTypeDef RS_Init(RS_HandleTypeDef *hRS, UART_HandleTypeDef *huart, TIM_HandleTypeDef *htim, uint8_t *pRS_BufferPtr);

-/* ReInitialize UART and RS receive */
-HAL_StatusTypeDef RS_ReInit_UART(RS_HandleTypeDef *hRS, UART_HandleTypeDef *suart);
-
-/* Abort RS/UART */
+/* Отменить прием/передачу RS/UART */
 RS_StatusTypeDef RS_Abort(RS_HandleTypeDef *hRS, RS_AbortTypeDef AbortMode);
 //-------------------------GENERAL FUNCTIONS-------------------------


 //-------------------------------------------------------------------
 //--------------------CALLBACK/HANDLER FUNCTIONS---------------------
-/* Handle for starting receive */
+/* Обработчик для начала приема */
 RS_StatusTypeDef RS_Handle_Receive_Start(RS_HandleTypeDef *hRS, RS_MsgTypeDef *RS_msg);
-/* Handle for starting transmit */
+/* Обработчик для начала передачи */
 RS_StatusTypeDef RS_Handle_Transmit_Start(RS_HandleTypeDef *hRS, RS_MsgTypeDef *RS_msg);
-/* UART TX Callback: define behaviour after transmiting message */
+/* UART TX Callback: коллбек после окончания передачи */
 RS_StatusTypeDef RS_UART_TxCpltCallback(RS_HandleTypeDef *hRS);
-/* Handler for UART */
+/* Обработчик прерывания UART */
 void RS_UART_Handler(RS_HandleTypeDef *hRS);
-/* Handler for TIM */
+/* Обработчик прерывания TIM */
 void RS_TIM_Handler(RS_HandleTypeDef *hRS);
+/* Запуск таймаута приема. */
+RS_StatusTypeDef RS_Timeout_Start(RS_HandleTypeDef *hRS);
+/* Остановка таймаута приема. */
+RS_StatusTypeDef RS_Timeout_Stop(RS_HandleTypeDef *hRS);
+/* Обновление (сброс) таймаута приема. */
+RS_StatusTypeDef RS_Timeout_Update(RS_HandleTypeDef *hRS);
 //--------------------CALLBACK/HANDLER FUNCTIONS---------------------
 ///////////////////////////---FUNCTIONS---///////////////////////////