API ПОМЕНЯЛОС - Реструктуризация модбас

- Переработана архитектура: * modbus_core.h - базовые определения и структуры * modbus_coils.[h/c] - работа с коилами * modbus_holdregs.[h/c] - работа с регистрами хранения (R/W) * modbus_inputregs.[h/c] -работа с входными регистрами (R/O) * modbus_devid.[h/c] - идентификаторы устройства * modbus_data.[h/c] - карта регистров и коилов и валидация адресов - Улучшена документация: * Обновлены Doxygen-комментарии к функциям * Обновлены шапки файлов с подробным описанием * Обновлена инструкция по подключению и использованию
2025-11-03 19:32:53 +03:00
parent 52de3f9c08
commit 7e21fc7f28
36 changed files with 6269 additions and 2259 deletions
--- a/Modbus/Inc/__crc_algs.h
+++ b/Modbus/Inc/__crc_algs.h
--- a/Modbus/Inc/modbus.h
+++ b/Modbus/Inc/modbus.h
@@ -0,0 +1,101 @@
+/**
+******************************************************************************
+* @file modbus.h
+* @brief Главный заголовочный файл Modbus библиотеки
+******************************************************************************
+@addtogroup MODBUS Modbus tools
+******************************************************************************
+@addtogroup MODBUS_FUNCTIONS Modbus library funtions
+@ingroup    MODBUS
+@{
+******************************************************************************
+* @details
+Объединяющий файл для подключения всей функциональности Modbus.
+Подключает все необходимые модули:
+
+
+@section Инструкция по подключению
+Для корректной работы надо:
+- Подключить обработчики RS_UART_Handler(), RS_TIM_Handler(), в соответствубщие 
+  низкоуровневые прерывания UART_IRQHandler, TIM_IRQHandler. Вместо HAL'овского обработчика
+ 
+В modbus_config.h настроить дефайны для нужной работы UART
+
+- Инициализировать хендл мобдас. По умолчанию глобально создается hmodbus1, но можно сделать свой
+После для запуска Modbus:
+@verbatim
+//----------------Прием модбас----------------//
+#include "modbus.h"
+
+MODBUS_SetupHardware(&hmodbus1, &huart1, &htim3);
+MODBUS_SlaveStart(&hmodbus1, NULL);
+// или если нужно переключится на другой 
+@endverbatim
+
+
+@section Подключаемые модули:
+- 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()
+
+
+@section Структура данных Modbus
+
+#### Holding/Input Registers:
+- Регистры — 16-битные слова. Доступ к регистрам осуществляется через указатель.  
+Таким образом, сами регистры могут представлять собой как массив так и структуру.
+
+#### Coils:
+- Coils — это биты, упакованные в 16-битные слова. Доступ к коилам осуществляется через указатель.  
+Таким образом, сами коилы могут представлять собой как массив так и структуру.
+
+******************************************************************************/
+#ifndef __MODBUS_H_
+#define __MODBUS_H_
+ 
+#include "__crc_algs.h"
+#include "rs_message.h"
+#include "modbus_coils.h"
+#include "modbus_holdregs.h"
+#include "modbus_inputregs.h"
+#include "modbus_devid.h"
+
+  
+
+/////////////////////////////////////////////////////////////////////
+/////////////////////////---FUNCTIONS---/////////////////////////////
+
+  
+//----------------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
+  * @} 
+  */
+  
+//---------PROCESS MODBUS COMMAND FUNCTIONS---------
+/////////////////////////---FUNCTIONS---/////////////////////////////
+
+#endif //__MODBUS_H_
+
+/** MODBUS_FUNCTIONS
+  * @} 
+  */
--- a/Modbus/Inc/modbus_coils.h
+++ b/Modbus/Inc/modbus_coils.h
@@ -0,0 +1,152 @@
+/**
+******************************************************************************
+* @file modbus_coils.h
+* @brief Работа с коилами Modbus
+******************************************************************************
+@addtogroup MODBUS_COILS Coils Tools
+@ingroup MODBUS_INTERNAL
+@{
+******************************************************************************
+* @details
+Модуль предоставляет функции и макросы для работы с битовыми данными:
+- Чтение coils (0x01) Упаковка битов в байты
+- Запись одиночного coil (0x05) Установка/сброс бита
+- Запись множественных coils (0x0F) - распаковка байтов в биты
+- Макросы для локального доступа к coils
+
+@section Организация битовых данных:
+Coils упакованы в 16-битные слова для эффективного использования памяти.
+Биты нумеруются от младшего к старшему внутри каждого слова.
+
+@section Адресация:
+- Глобальная - абсолютный адрес в пространстве Modbus
+- Локальная - относительный адрес внутри массива coils
+- Макросы автоматически вычисляют смещения и маски
+
+******************************************************************************/
+#ifndef __MODBUS_COILS_H_
+#define __MODBUS_COILS_H_
+#include "modbus_core.h"
+
+/////////////////////////////////////////////////////////////////////
+////////////////////---MODBUS FUNCTION DEFINES---////////////////////
+
+/** @brief Structure for coils operation */
+typedef enum
+{
+  SET_COIL,
+  RESET_COIL,
+  TOOGLE_COIL,
+}MB_CoilsOpTypeDef;
+
+//--------------------------------------------------
+
+/** 
+  * @brief  Macros to set pointer to a certain register that contains certain coil
+  * @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
+  xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxCx
+  |register[0]----| |register[1]----|
+  |skip this------| |get this-------|
+                    |shift to 14 bit|
+  @endverbatim
+  */
+#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_.
+  * @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)
+  
+  Visual explanation: 30th coil in coils registers array
+  xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxCx
+  |register[0]----| |register[1]----|
+  |skip this------| |get this-------|
+                    |shift to 14 bit|
+  @endverbatim
+  */
+#define MB_Set_Coil_Mask(_coil_)                      (1 << ( _coil_ - (16*((_coil_)/16)) ))
+  
+
+/////////////////////////////////////////////////////////////////////
+/////////////////////////---FUNCTIONS---/////////////////////////////
+  
+/** 
+* @addtogroup MODBUS_DATA_ACCESS_FUNCTIONS Modbus Data Access
+* @ingroup    MODBUS_FUNCTIONS
+* @brief      Функции для доступа к данным модбас (коилы)
+@{
+*/
+  
+/** 
+  * @brief  Read Coil at its local address.
+  * @param  _parr_        - массив коилов.
+  * @param  _coil_        - Номер коила от начала массива _arr_.
+  * @return uint16_t      Возвращает запрошенный коил на 0м бите.
+  *
+  * @details  Позволяет обратиться к коилу по адресу относительно _arr_.
+  */
+#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.
+  * @param  _parr_        Указатель на массив коилов.
+  * @param  _coil_        - Номер коила от начала массива _arr_.
+  * 
+  * @details  Позволяет обратиться к коилу по адресу относительно _arr_.
+  */
+#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.
+  * @param  _parr_        Указатель на массив коилов.
+  * @param  _coil_        - Номер коила от начала массива _arr_.
+  *
+  * @details  Позволяет обратиться к коилу по адресу относительно _arr_.
+  */
+#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.
+  * @param  _parr_        Указатель на массив коилов.
+  * @param  _coil_        - Номер коила от начала массива _arr_.
+  * 
+  * @details  Позволяет обратиться к коилу по адресу относительно _arr_.
+  */
+#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
+  * @} 
+  */
+  
+//---------PROCESS MODBUS COMMAND FUNCTIONS---------
+/** 
+  * @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) */
+uint8_t MB_Write_Miltuple_Coils(RS_MsgTypeDef *modbus_msg);
+
+/** MODBUS_CMD_PROCESS_FUNCTIONS
+  * @} 
+  */
+/////////////////////////---FUNCTIONS---/////////////////////////////
+  
+#endif //__MODBUS_COILS_H_
+
+/** MODBUS_COILS
+  * @} 
+  */
--- a/Modbus/Inc/modbus_config.h
+++ b/Modbus/Inc/modbus_config.h
@@ -1,17 +1,28 @@
 /**
-**************************************************************************
-* @file interface_config.h
-* @brief Конфигурация для модбаса
-*************************************************************************/
+******************************************************************************
+* @file modbus_config.h
+* @brief Конфигурационные параметры Modbus устройства
+******************************************************************************
+@addtogroup MODBUS_CONFIGS Modbus configs
+@ingroup    MODBUS
+@{
+******************************************************************************
+* @details
+Файл содержит настройки для работы Modbus:
+- Идентификатор устройства и таймауты
+- Строковые идентификаторы (Vendor, Product, Revision)
+- Настройки периферии (UART, TIMER)
+- Опциональные функции (переключение команд 0x03/0x04)
+******************************************************************************/
 #ifndef _MODBUS_CONFIG_H_
 #define _MODBUS_CONFIG_H_
 #include "stm32f1xx_hal.h"

-// MODBUS PARAMS
+// Общие параметры
 #define MODBUS_DEVICE_ID              1     ///< девайс текущего устройства
 #define MODBUS_TIMEOUT                5000  ///< максимальнйы тайтаут MB в тиках таймера

-// STRING OBJECTS MODBUS
+// Строковые идентификаторы устройства
 #define MODBUS_VENDOR_NAME            "NIO-12"
 #define MODBUS_PRODUCT_CODE           ""
 #define MODBUS_REVISION               "Ver. 1.0"
@@ -21,14 +32,10 @@
 #define MODBUS_USER_APPLICATION_NAME  ""
 #define MODBUS_NUMB_OF_USEROBJECTS    0

-// PERIPH FUNCTIONS AND HANDLERS
-#define RS_UART_Init                  MX_USART1_UART_Init   //инициализация uart
-#define RS_UART_DeInit                HAL_UART_MspDeInit  //деинициализация uart
-#define RS_TIM_Init                   MX_TIM3_Init      //инициализация таймера
-#define RS_TIM_DeInit                 HAL_TIM_Base_MspDeInit//деинициализация таймера
-#define rs_huart                      huart1        //используемый uart
-#define rs_htim                       htim3         //используемый таймера
-
+// Периферия (опционально)
+#define mb_huart                      huart1        ///< Удобный дефайн для модбасовского uart
+#define mb_htim                       htim3         ///< Удобный дефайн для модбасовского таймера
+///< 

 /**
  * @brief    Поменять комманды 0x03 и 0x04 местами (для LabView терминалки от двигателей)
--- a/Modbus/Inc/modbus_core.h
+++ b/Modbus/Inc/modbus_core.h
@@ -1,38 +1,39 @@
-/** 
-  **************************************************************************
-  * @file   modbus.h
-  * @brief  Заголовочный файл модуля MODBUS.
-  * @details  Данный файл необходимо подключить в rs_message.h. После подключать 
-  * rs_message.h к основному проекту.
-  * 
-  * @defgroup MODBUS
-  * @brief    Modbus stuff
-  *
-  *************************************************************************/
-#ifndef __MODBUS_H_
-#define __MODBUS_H_
+/**
+******************************************************************************
+* @file modbus_core.h
+* @brief Ядро Modbus протокола - определения и структуры
+******************************************************************************
+@addtogroup MODBUS_INTERNAL Modbus Internal Tools
+@ingroup MODBUS
+@{
+******************************************************************************
+* @details
+Базовые определения для реализации Modbus RTU устройства:
+- Структуры сообщений Modbus
+Коды функций и исключений
+Константы размеров полей
+Вспомогательные макросы
+
+@section Структура сообщения:
+[ADDR][FUNC][DATA...][CRC]
+- Адрес: 1 байт
+- Функция: 1 байт  
+- Данные: переменной длины
+- CRC: 2 байта
+
+******************************************************************************/
+#ifndef __MODBUS_CORE_H_
+#define __MODBUS_CORE_H_
 
 #include "modbus_config.h"
 #include "modbus_data.h"
-#include "__crc_algs.h"

 /** 
-  * @addtogroup MODBUS_SETTINGS
+  * @addtogroup MODBUS_MESSAGE_DEFINES Modbus Message Tools
  * @ingroup    MODBUS
-  * @brief      Some defines for modbus
+  * @brief      Определения протокола модбас
  @{
  */
-/////////////////////////////////////////////////////////////////////
-//////////////////////////---SETTINGS---/////////////////////////////
-// USER SETTINGS FOR MODBUS IN interface_config.h
-/**
-  * @brief    Поменять комманды 0x03 и 0x04 местами (для LabView терминалки от двигателей)
-  * @details  Терминалка от двигателей использует для чтения регистров комманду R_HOLD_REGS вместо R_IN_REGS
-  *           Поэтому чтобы считывать Input Regs - надо поменять их местами.
-  */
-//#define MODBUS_SWITCH_COMMAND_R_IN_REGS_AND_R_HOLD_REGS
-//////////////////////////---SETTINGS---/////////////////////////////
-

 /////////////////////////////////////////////////////////////////////
 ////////////////////---MODBUS MESSAGE DEFINES---/////////////////////
@@ -112,28 +113,6 @@ typedef enum //MB_FunctonTypeDef
  MB_ERR_R_DEVICE_INFO  = MB_R_DEVICE_INFO  + ERR_VALUES_START,   ///< Ошибка чтения информации об устройстве
 }MB_FunctonTypeDef;

-
-/** @brief Structure for modbus diagnostics sub-functions codes */
-typedef enum
-{
-  RETURN_QUERRY_DATA            = 0x0,
-  RESTART_COMM_OPTIONS          = 0x1,
-  RETURN_DIAG_REG               = 0x2,
-  CHANGE_ASCII_INPUT_DELIMITER  = 0x3,
-  FORCE_LISTEN_ONLY_MODE        = 0x4,
-  CLEAR_CNT_AND_DIAG_REG        = 0xA,
-  RETURN_BUS_MSG_CNT            = 0xB,
-  RETURN_BUS_COMM_ERR_CNT       = 0xC,
-  RETURN_BUS_EXCEPT_ERR_CNT     = 0xD,
-  RETURN_SLAVE_MSG_CNT          = 0xE,
-  RETURN_SLAVE_NO_RESP_CNT      = 0xF,
-  RETURN_SLAVE_NAK_CNT          = 0x10,
-  RETURN_SLAVE_BUSY_CNT         = 0x11,
-  RETURN_BUS_CHAR_OVERRUN       = 0x12,
-  CLEAR_OVR_CNT_AND_FLAG        = 0x12,
-}MB_DiagnosticsSubFunctionTypeDef;
-
-
 /** @brief Structure for MEI func codes */
 typedef enum //MB_FunctonTypeDef
 {
@@ -199,80 +178,8 @@ extern RS_MsgTypeDef MODBUS_MSG;



-/////////////////////////////////////////////////////////////////////
-///////////////---DEVICE IDENTIVICATIONS DEFINES---//////////////////
-
-/** @brief Структура для объекта (идентификатора устройства модбас) */
-typedef struct
-{
-  unsigned  length;
-  char      *name;
-}MB_DeviceObjectTypeDef;
-
-/** @brief Структура со идентификаторами устройства модбас */
-typedef struct
-{
-  MB_DeviceObjectTypeDef  VendorName;
-  MB_DeviceObjectTypeDef  ProductCode;
-  MB_DeviceObjectTypeDef  Revision;
-  MB_DeviceObjectTypeDef  VendorUrl;
-  MB_DeviceObjectTypeDef  ProductName;
-  MB_DeviceObjectTypeDef  ModelName;
-  MB_DeviceObjectTypeDef  UserApplicationName;
-  
-  MB_DeviceObjectTypeDef  Reserved[0x79];
-  
-  MB_DeviceObjectTypeDef  User[MODBUS_NUMB_OF_USEROBJECTS];
-}MB_DeviceIdentificationTypeDef;
-extern MB_DeviceIdentificationTypeDef 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_SETTINGS
-  * @} 
-  */
-
-
 /////////////////////////////////////////////////////////////////////
 ////////////////////---MODBUS FUNCTION DEFINES---////////////////////
-/** 
-  * @addtogroup MODBUS_MESSAGE_DEFINES
-  * @ingroup    MODBUS
-  * @brief      Some defines for modbus
-  @{
-  */
-/** @brief Structure for coils operation */
-typedef enum
-{
-  SET_COIL,
-  RESET_COIL,
-  TOOGLE_COIL,
-}MB_CoilsOpTypeDef;
-
-//--------------------------------------------------

 /** 
  * @brief  Macros to set pointer to 16-bit array
@@ -286,86 +193,9 @@ typedef enum
  */
 #define MB_Set_Register_Ptr(_parr_, _addr_)           ((uint16_t *)(_parr_)+(_addr_))

-/** 
-  * @brief  Macros to set pointer to a certain register that contains certain coil
-  * @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
-  xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxCx
-  |register[0]----| |register[1]----|
-  |skip this------| |get this-------|
-                    |shift to 14 bit|
-  @endverbatim
+/** GENERAL_MODBUS_STUFF
+  * @} 
  */
-#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_.
-  * @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)
-  
-  Visual explanation: 30th coil in coils registers array
-  xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxCx
-  |register[0]----| |register[1]----|
-  |skip this------| |get this-------|
-                    |shift to 14 bit|
-  @endverbatim
-  */
-#define MB_Set_Coil_Mask(_coil_)                      (1 << ( _coil_ - (16*((_coil_)/16)) ))
-  
-/** 
-  * @brief  Read Coil at its local address.
-  * @param  _parr_        - массив коилов.
-  * @param  _coil_        - Номер коила от начала массива _arr_.
-  * @return uint16_t      - Возвращает запрошенный коил на 0м бите.
-  *
-  * @details  Позволяет обратиться к коилу по адресу относительно _arr_.
-  */
-#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.
-  * @param  _parr_        - указатель на массив коилов.
-  * @param  _coil_        - Номер коила от начала массива _arr_.
-  * 
-  * @details  Позволяет обратиться к коилу по адресу относительно _arr_.
-  */
-#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.
-  * @param  _parr_        - указатель на массив коилов.
-  * @param  _coil_        - Номер коила от начала массива _arr_.
-  *
-  * @details  Позволяет обратиться к коилу по адресу относительно _arr_.
-  */
-#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.
-  * @param  _parr_        - указатель на массив коилов.
-  * @param  _coil_        - Номер коила от начала массива _arr_.
-  * 
-  * @details  Позволяет обратиться к коилу по адресу относительно _arr_.
-  */
-#define MB_Toogle_Coil_Local(_parr_, _coil_)          *MB_Set_Coil_Reg_Ptr(_parr_, _coil_)  ^=  MB_Set_Coil_Mask(_coil_)
-
-
-/**
-  * @brief    Инициализация объектов
-  * @details  С помозью этого дефайна инициализируются объекты в @ref MB_DeviceInentificationInit
-  */
-#define MB_ObjectInit(_p_obj_, _userstring_)    (_p_obj_)->length  = sizeof(_userstring_);\
-                                                (_p_obj_)->name    = _userstring_;
-                                                        /**
-  * @brief    Инициализация пользовательских объектов
-  * @details  С помозью этого дефайна инициализируются пользовательские объекты в MB_DeviceInentificationInit
-  */
-#define MB_UserObjectInit(_pinfostruct_, _user_numb_)   MB_ObjectInit(&(_pinfostruct_)->User[_user_numb_], MODBUS_USEROBJECT##_user_numb_##_NAME)
-//--------------------------------------------------


 //------------------OTHER DEFINES-------------------
@@ -396,93 +226,31 @@ typedef enum
  */
 #define ByteSwap16(v)                                 (((v&0xFF00) >> (8)) | ((v&0x00FF) << (8)))
 #endif
-/** GENERAL_MODBUS_STUFF
-  * @} 
-  */
 ////////////////////---MODBUS MESSAGE DEFINES---/////////////////////


-
 /////////////////////////////////////////////////////////////////////
 /////////////////////////---FUNCTIONS---/////////////////////////////
-/** 
-  * @addtogroup MODBUS_FUNCTIONS
-  * @ingroup    MODBUS
-  * @brief      Function for controling modbus communication
-  */
-  
-//----------------FUNCTIONS FOR USER----------------
-/** 
-  * @addtogroup MODBUS_DATA_ACCESS_FUNCTIONS
-  * @ingroup    MODBUS_FUNCTIONS
-  * @brief      Function for user use
-  @{
-  */
-/* First set up of MODBUS */
-void MODBUS_FirstInit(void);
-/* 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
-  * @} 
-  */
  
 //---------PROCESS MODBUS COMMAND FUNCTIONS---------
 /** 
  * @addtogroup MODBUS_CMD_PROCESS_FUNCTIONS
-  * @ingroup    MODBUS_FUNCTIONS
-  * @brief      Function process commands
  @{
  */
+  
+/* Реализация этих функций лежит в modbus_data.c */
+
 /* Check is address valid for certain array */
 MB_ExceptionTypeDef MB_Check_Address_For_Arr(uint16_t Addr, uint16_t Qnt, uint16_t R_ARR_ADDR, uint16_t R_ARR_NUMB);
 /* Define Address Origin for Input/Holding Registers */
 MB_ExceptionTypeDef MB_DefineRegistersAddress(uint16_t **pRegs, uint16_t Addr, uint16_t Qnt, uint8_t RegisterType);
 /* Define Address Origin for coils */
 MB_ExceptionTypeDef MB_DefineCoilsAddress(uint16_t **pCoils, uint16_t Addr, uint16_t Qnt, uint16_t *start_shift, uint8_t WriteFlag);
-/* Proccess command Read Coils (01 - 0x01) */
-uint8_t MB_Proccess_Read_Coils(RS_MsgTypeDef *modbus_msg);
-/* Proccess command Read Holding Registers (03 - 0x03) */
-uint8_t MB_Proccess_Read_Hold_Regs(RS_MsgTypeDef *modbus_msg);
-/* Proccess command Read Input Registers (04 - 0x04) */
-uint8_t MB_Proccess_Read_Input_Regs(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 Single Coils (06 - 0x06) */
-uint8_t MB_Proccess_Write_Single_Reg(RS_MsgTypeDef *modbus_msg);
-/* Proccess command Write Multiple Coils (15 - 0x0F) */
-uint8_t MB_Write_Miltuple_Coils(RS_MsgTypeDef *modbus_msg);
-/* Proccess command Write Multiple Register (16 - 0x10) */
-uint8_t MB_Proccess_Write_Miltuple_Regs(RS_MsgTypeDef *modbus_msg);
-
-/** MODBUS_DATA_ACCESS_FUNCTIONS
+/** MODBUS_CMD_PROCESS_FUNCTIONS
  * @} 
  */
 /////////////////////////---FUNCTIONS---/////////////////////////////
-  
-  
-  
-/////////////////////////////////////////////////////////////////////
-/////////////////////////---CALC DEFINES---//////////////////////////
-
-
-// TRACES DEFINES
-#ifndef Trace_MB_UART_Enter
-#define Trace_MB_UART_Enter()
-#endif //Trace_MB_UART_Enter
-  
-#ifndef Trace_MB_UART_Exit
-#define Trace_MB_UART_Exit()
-#endif //Trace_MB_UART_Exit
-
-#ifndef Trace_MB_TIM_Enter
-#define Trace_MB_TIM_Enter()
-#endif //Trace_MB_TIM_Enter
-  
-#ifndef Trace_MB_TIM_Exit
-#define Trace_MB_TIM_Exit()
-#endif //Trace_MB_TIM_Exit
-
-#endif //__MODBUS_H_
+#endif //__MODBUS_CORE_H_
+/** MODBUS_INTERNAL
+  * @} 
+  */
--- a/Modbus/Inc/modbus_data.h
+++ b/Modbus/Inc/modbus_data.h
@@ -0,0 +1,159 @@
+/**
+******************************************************************************
+* @file modbus_data.h
+* @brief Определения структур данных Modbus устройства
+******************************************************************************
+@defgroup MODBUS_DATA Modbus Data Tools
+@ingroup MODBUS
+@brief Определение карты регистров и коилов
+******************************************************************************
+* @details
+Файл содержит объявления структур данных, доступных через Modbus:
+- Holding Registers (R/W) - регистры хранения
+- Input Registers (R/O) - входные регистры  
+- Coils (R/W) - дискретные выходы
+
+@section Базовая настройка под устройство:
+1. Настроить диапазоны адресов
+  - @ref R_INPUT_ADDR и @ref R_INPUT_QNT для входных регистров
+  - @ref R_HOLDING_ADDR и @ref R_HOLDING_QNT для регистров хранения
+  - @ref C_COILS_ADDR и @ref C_COILS_ADDR для коилов
+3. Настроить структуры данных:
+  - @ref MB_DataInRegsTypeDef
+  - @ref MB_DataHoldRegsTypeDef
+  - @ref MB_DataCoilsTypeDef
+    
+
+@section Расширенная настройка под устройство:
+1. Добавить новый массив с нужными данными.
+2. Добавить дефайны для определения его начального адреса и количества элементов
+3. Добавить проверку адресов в MB_DefineRegistersAddress/MB_DefineCoilsAddress. 
+
+   Пример:
+   @code
+    #define   R_USER_ADDR        555
+    #define   R_USER_QNT         16
+    uint16_t  user_regs[16];
+
+    //...
+    else if(MB_Check_Address_For_Arr(Addr, Qnt, R_USER_ADDR, R_USER_QNT) == NO_ERRORS)
+    {
+      *pRegs = MB_Set_Register_Ptr(&user_regs, Addr-R_USER_ADDR); // ВАЖНО!
+      // -R_USER_ADDR нужен чтобы взять адрес относительно начала массива
+    }
+    else  
+    {
+      return ILLEGAL_DATA_ADDRESS;
+    }
+   @endcode
+******************************************************************************/
+
+#ifndef _MODBUS_DATA_H_
+#define _MODBUS_DATA_H_
+  
+#include "stdint.h"
+
+
+
+//--------------SIZES OF DATA---------------
+
+// DEFINES FOR INPUT REGISTERS ARRAYS
+#define   R_INPUT_ADDR        0   ///< Начальный адрес входных регистров
+#define   R_INPUT_QNT         16  ///< Количество входных регистров
+
+// DEFINES FOR HOLDING REGISTERS ARRAYS
+#define   R_HOLDING_ADDR      0   ///< Начальный адрес регистров хранения
+#define   R_HOLDING_QNT       16  ///< Количество регистров хранения
+
+// DEFINES FOR COIL ARRAYS
+#define   C_COILS_ADDR        0   ///< Начальный адрес коилов
+#define   C_COILS_QNT         16  ///< Количество регистров коилов
+
+//--------------DEFINES FOR REGISTERS---------------
+// DEFINES FOR ARRAYS
+/** 
+  * @addtogroup MODBUS_DATA_RERISTERS_DEFINES Registers structures
+  * @ingroup    MODBUS_DATA
+  * @brief      Стуруктура регистров (входных и хранения)
+  @verbatim    
+  Для массивов регистров:
+    R_<NAME_ARRAY>_ADDR   -  модбас адресс первого регистра в массиве
+    R_<NAME_ARRAY>_QNT    -  количество регистров в массиве
+  @endverbatim
+  * @{
+  */
+  
+  
+/** 
+  * @brief Регистры хранения
+  */
+typedef struct //MB_DataInRegsTypeDef
+{
+  uint16_t in[16];
+}MB_DataInRegsTypeDef;
+
+
+/** 
+  * @brief Входные регистры 
+  */
+typedef struct //MB_DataInRegsTypeDef
+{
+  uint16_t out[16];
+}MB_DataHoldRegsTypeDef;
+
+
+/** MODBUS_DATA_RERISTERS_DEFINES
+  * @} 
+  */
+
+//----------------DEFINES FOR COILS-----------------
+/** 
+  * @addtogroup MODBUS_DATA_COILS_DEFINES Coils Structure
+  * @ingroup    MODBUS_DATA
+  * @brief      Структура коилов
+  @verbatim    
+  Структура дефайна
+  Для массивов коилов:
+    C_<NAME_ARRAY>_ADDR   - модбас адресс первого коила в массиве
+    C_<NAME_ARRAY>_QNT    - количество коилов в массиве (минимум 16)
+  @endverbatim
+  * @{
+  */
+  
+  
+  
+/** 
+  * @brief     Коилы
+  * @details   Желательно с помощью reserved делать стркутуру кратной 16-битам
+  */
+typedef struct //MB_DataCoilsTypeDef
+{
+  unsigned reserved:16;
+}MB_DataCoilsTypeDef;
+
+/** MODBUS_DATA_COILS_DEFINES
+  * @} 
+  */
+  
+  
+//-----------MODBUS DEVICE DATA SETTING-------------
+// MODBUS DATA STRUCTTURE
+/** 
+  * @brief Структура со всеми регистрами и коилами модбас 
+  * @ingroup  MODBUS_DATA
+  */
+typedef struct // tester modbus data
+{
+  MB_DataInRegsTypeDef      InRegs;     ///< Modbus input registers @ref MB_DataInRegsTypeDef
+
+  MB_DataCoilsTypeDef       Coils;      ///< Modbus coils @ref MB_DataCoilsTypeDef
+  
+  MB_DataHoldRegsTypeDef    HoldRegs;   ///< Modbus holding registers @ref MB_DataHoldRegsTypeDef
+}MB_DataStructureTypeDef;
+extern MB_DataStructureTypeDef MB_DATA;
+
+
+#endif //_MODBUS_DATA_H_
+
+/////////////////////////////////////////////////////////////
+///////////////////////TEMP/OUTDATE/OTHER////////////////////
--- a/Modbus/Inc/modbus_devid.h
+++ b/Modbus/Inc/modbus_devid.h
@@ -0,0 +1,125 @@
+/**
+******************************************************************************
+* @file modbus_devid.h
+* @brief Идентификация устройства Modbus
+******************************************************************************
+@addtogroup MODBUS_DEVID Device Identificators Tools
+@ingroup MODBUS_INTERNAL
+@{
+******************************************************************************
+* @details
+Модуль реализации функции Read Device Identification (0x2B):
+- Базовая идентификация (Vendor, Product, Revision)
+- Расширенная идентификация (URL, Model, User fields)
+- Поддержка потоковой передачи больших объектов
+
+@section Объекты идентификации:
+- VendorName, ProductCode, Revision - обязательные
+- VendorUrl, ProductName, ModelName - опциональные
+- User objects - пользовательские поля
+- Поддержка до 128 пользовательских объектов
+******************************************************************************/
+#ifndef __MODBUS_DEVID_H_
+#define __MODBUS_DEVID_H_ 
+#include "modbus_core.h"
+
+
+/////////////////////////////////////////////////////////////////////
+///////////////---DEVICE IDENTIVICATIONS DEFINES---//////////////////
+
+/** @brief Структура для объекта (идентификатора устройства модбас) */
+typedef struct
+{
+  unsigned  length;
+  char      *name;
+}MB_DeviceObjectTypeDef;
+
+/** @brief Структура со идентификаторами устройства модбас */
+typedef struct
+{
+  MB_DeviceObjectTypeDef  VendorName;
+  MB_DeviceObjectTypeDef  ProductCode;
+  MB_DeviceObjectTypeDef  Revision;
+  MB_DeviceObjectTypeDef  VendorUrl;
+  MB_DeviceObjectTypeDef  ProductName;
+  MB_DeviceObjectTypeDef  ModelName;
+  MB_DeviceObjectTypeDef  UserApplicationName;
+  
+  MB_DeviceObjectTypeDef  Reserved[0x79];
+  
+  MB_DeviceObjectTypeDef  User[MODBUS_NUMB_OF_USEROBJECTS];
+}MB_DeviceIdentificationTypeDef;
+extern MB_DeviceIdentificationTypeDef 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---////////////////////
+
+/**
+  * @brief    Инициализация объектов
+  * @details  С помозью этого дефайна инициализируются объекты в @ref MB_DeviceInentificationInit
+  */
+#define MB_ObjectInit(_p_obj_, _userstring_)    (_p_obj_)->length  = sizeof(_userstring_);\
+                                                (_p_obj_)->name    = _userstring_;
+                                                        /**
+  * @brief    Инициализация пользовательских объектов
+  * @details  С помозью этого дефайна инициализируются пользовательские объекты в MB_DeviceInentificationInit
+  */
+#define MB_UserObjectInit(_pinfostruct_, _user_numb_)   MB_ObjectInit(&(_pinfostruct_)->User[_user_numb_], MODBUS_USEROBJECT##_user_numb_##_NAME)
+
+
+////////////////////---MODBUS MESSAGE DEFINES---/////////////////////
+
+
+
+/////////////////////////////////////////////////////////////////////
+/////////////////////////---FUNCTIONS---/////////////////////////////
+  
+//---------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);
+/** MODBUS_CMD_PROCESS_FUNCTIONS
+  * @} 
+  */
+/////////////////////////---FUNCTIONS---/////////////////////////////
+
+#endif //__MODBUS_DEVID_H_
+
+/** MODBUS_DEVID
+  * @} 
+  */
--- a/Modbus/Inc/modbus_holdregs.h
+++ b/Modbus/Inc/modbus_holdregs.h
@@ -0,0 +1,48 @@
+/**
+******************************************************************************
+* @file modbus_holdregs.h
+* @brief Работа с регистрами хранения Modbus
+******************************************************************************
+@addtogroup MODBUS_INS Input Register Tools
+@ingroup MODBUS_INTERNAL
+@{
+******************************************************************************
+* @details
+Модуль обработки команд для регистров хранения (Holding Registers):
+- Чтение множества регистров (0x03)
+- Запись одиночного регистра (0x06) 
+- Запись множества регистров (0x10)
+
+@section Регистры хранения:
+- Read/Write доступ
+- 16-битные значения (uint16_t)
+******************************************************************************/
+#ifndef __MODBUS_HOLDREGS_H_
+#define __MODBUS_HOLDREGS_H_
+#include "modbus_core.h"
+
+/////////////////////////////////////////////////////////////////////
+/////////////////////////---FUNCTIONS---/////////////////////////////
+
+//---------PROCESS MODBUS COMMAND FUNCTIONS---------
+/** 
+  * @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);
+
+/** MODBUS_CMD_PROCESS_FUNCTIONS
+  * @} 
+  */
+/////////////////////////---FUNCTIONS---/////////////////////////////
+
+#endif //__MODBUS_HOLDREGS_H_
+
+/** MODBUS_INS
+  * @} 
+  */
--- a/Modbus/Inc/modbus_inputregs.h
+++ b/Modbus/Inc/modbus_inputregs.h
@@ -0,0 +1,43 @@
+/**
+******************************************************************************
+* @file modbus_inputregs.h
+* @brief Работа с входными регистрами Modbus
+******************************************************************************
+@addtogroup MODBUS_HOLD Holding Registers Tools
+@ingroup MODBUS_INTERNAL
+@{
+******************************************************************************
+* @details
+Модуль обработки команд для входных регистров (Input Registers):
+- Чтение множества регистров (0x04)
+
+@section Входные регистры:
+- Read-Only доступ
+- 16-битные значения
+******************************************************************************/
+#ifndef __MODBUS_INPUTREGS_H_
+#define __MODBUS_INPUTREGS_H_
+#include "modbus_core.h"
+
+/////////////////////////////////////////////////////////////////////
+/////////////////////////---FUNCTIONS---/////////////////////////////
+
+//---------PROCESS MODBUS COMMAND FUNCTIONS---------
+/** 
+  * @addtogroup MODBUS_CMD_PROCESS_FUNCTIONS Proccess Functions
+  * @ingroup    MODBUS_FUNCTIONS
+  * @brief      Функции обработки запросов модбас
+  @{
+  */
+/* Proccess command Read Input Registers (04 - 0x04) */
+uint8_t MB_Proccess_Read_Input_Regs(RS_MsgTypeDef *modbus_msg);
+
+/** MODBUS_CMD_PROCESS_FUNCTIONS
+  * @} 
+  */
+/////////////////////////---FUNCTIONS---/////////////////////////////
+
+#endif //__MODBUS_INPUTREGS_H_
+/** MODBUS_HOLD
+  * @} 
+  */
--- a/Modbus/Inc/rs_message.h
+++ b/Modbus/Inc/rs_message.h
@@ -1,31 +1,37 @@
 /**
-**************************************************************************
+******************************************************************************
 * @file rs_message.h
-* @brief Заголовочный файл для модуля реализации протоколов по RS/UART.
-**************************************************************************
-* @defgroup RS_TOOLS
-* @brief    Всякое для работы по UART/RS
-**************************************************************************
-@details
-**************************************************************************
-Для настройки RS/UART под нужный протокол, необходимо:
-  - Определить структуру сообщения RS_MsgTypeDef и 
-  дефайны RX_FIRST_PART_SIZE и MSG_SIZE_MAX.
-  - Подключить этот файл в раздел rs_message.h.
-  - Определить функции для обработки сообщения: RS_Parse_Message(), 
-  RS_Collect_Message(), RS_Response(), RS_Define_Size_of_RX_Message()
-  - Добавить UART/TIM Handler в Хендлер используемых UART/TIM.
- 
-Так же данный модуль использует счетчики 
-**************************************************************************
-@verbatim
-Визуальное описание. Форматирование сохраняется как в коде.
-@endverbatim
-*************************************************************************/
+* @brief Библиотека обмена сообщениями по RS-интерфейсу
+******************************************************************************
+@defgroup RS_TOOLS RS Tools
+@brief    Всякое для работы по UART/RS
+@{
+******************************************************************************
+* @details
+Универсальная библиотека для работы с последовательными протоколами (Modbus, Custom)
+через UART в режиме прерываний с поддержкой таймаутов.
+
+@section Основные возможности:
+- Прием/передача в прерываниях
+- Обработка IDLE линии для определения конца фрейма
+- Таймауты приема через TIM
+- Гибкая настройка размера сообщений
+
+@section Использование:
+1. Определить структуру сообщения и размеры буфера
+2. Реализовать weak-функции обработки сообщений
+3. Добавить вызовы RS_UART_Handler/RS_TIM_Handler в прерывания
+4. Инициализировать через RS_Init() и запустить прием RS_Receive_IT()
+
+@section Особенности:
+- Буфер: RS_Buffer[MSG_SIZE_MAX] Общий для приема/передачи
+- Состояния: отслеживается через флаги в RS_HandleTypeDef
+- Таймауты: контролируют максимальное время ожидания фрейма
+******************************************************************************/
 #ifndef __RS_LIB_H_
 #define __RS_LIB_H_

-#include "modbus.h" 
+#include "modbus_core.h"

 /////////////////////////////////////////////////////////////////////
 ////////////////////////////---DEFINES---////////////////////////////
@@ -38,6 +44,9 @@
 #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 Заглушки и внутренний недокументированный стаф
+  */

 /* Clear message-uart buffer */
 #define RS_Clear_Buff(_buff_)       for(int i=0; i<MSG_SIZE_MAX;i++)  _buff_[i] = NULL
@@ -70,7 +79,6 @@
 #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()
@@ -115,6 +123,7 @@ static int dummy;
 #ifndef RS_USER_VARS_NUMB
 #define RS_USER_VARS_NUMB 0
 #endif
+/** @endcond */
 ////////////////////////////---DEFINES---////////////////////////////


@@ -140,12 +149,13 @@ typedef enum    // RS_StatusTypeDef
 }RS_StatusTypeDef;


+#define RS_MASTER_START   0x3
 /** @brief Enums for RS Modes */
 typedef enum  // RS_ModeTypeDef
 {
-  SLAVE_ALWAYS_WAIT =       0x01,   ///< Slave mode with infinity waiting
-  SLAVE_TIMEOUT_WAIT =      0x02,   ///< Slave mode with waiting with timeout
-//  MASTER =                  0x03,   ///< Master mode
+  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_ModeTypeDef;

 /** @brief Enums for RS UART Modes */
@@ -188,6 +198,7 @@ typedef struct
  unsigned                  TX_Done:1;            ///< flag: 1 - transmiting is done, 0 - transmiting isnt done 
    
  // 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
@@ -207,7 +218,7 @@ typedef struct  // RS_HandleTypeDef
  uint8_t                   ID;                   ///< ID of RS "channel"
  RS_MsgTypeDef             *pMessagePtr;         ///< pointer to message struct
  uint8_t                   *pBufferPtr;          ///< pointer to message buffer
-  uint32_t                  RS_Message_Size;      ///< size of whole message, not only data
+  int32_t                   RS_Message_Size;      ///< size of whole message, not only data
  
  /* HANDLERS and SETTINGS */
  UART_HandleTypeDef        *huart;               ///< handler for used uart
@@ -245,9 +256,6 @@ RS_StatusTypeDef RS_Collect_Message(RS_HandleTypeDef *hRS, RS_MsgTypeDef *RS_msg
 /* Parse message from buffer to process it */
 RS_StatusTypeDef RS_Parse_Message(RS_HandleTypeDef *hRS, RS_MsgTypeDef *RS_msg, uint8_t *msg_uart_buff);

-/* Define size of RX Message that need to be received */
-RS_StatusTypeDef RS_Define_Size_of_RX_Message(RS_HandleTypeDef *hRS, uint32_t *rx_data_size);
-

 //-------------------------GENERAL FUNCTIONS-------------------------
 /*-----------------Should be called from main code-----------------*/
@@ -274,8 +282,6 @@ RS_StatusTypeDef RS_Abort(RS_HandleTypeDef *hRS, RS_AbortTypeDef AbortMode);
 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 RX Callback: define behaviour after receiving parts of message */
-RS_StatusTypeDef RS_UART_RxCpltCallback(RS_HandleTypeDef *hRS);
 /* UART TX Callback: define behaviour after transmiting message */
 RS_StatusTypeDef RS_UART_TxCpltCallback(RS_HandleTypeDef *hRS);
 /* Handler for UART */
@@ -285,6 +291,8 @@ void RS_TIM_Handler(RS_HandleTypeDef *hRS);
 //--------------------CALLBACK/HANDLER FUNCTIONS---------------------
 ///////////////////////////---FUNCTIONS---///////////////////////////

-
+/** RS_TOOLS
+  * @}
+  */

 #endif // __RS_LIB_H_
--- a/Modbus/Src/__crc_algs.c
+++ b/Modbus/Src/__crc_algs.c
--- a/Modbus/Src/modbus.c
+++ b/Modbus/Src/modbus.c
@@ -0,0 +1,554 @@
+/** 
+**************************************************************************
+* @file   modbus.c
+* @brief  Модуль для реализации MODBUS.
+**************************************************************************  
+* @details 
+Файл содержит реализацию функций работы с Modbus.
+
+@section Функции и макросы
+
+### Инициализация:
+- MODBUS_SetupHardware()    — Инициализация модуля Modbus.
+- MODBUS_Config()           — Инициализация модуля Modbus.
+
+### Функции для Modbus
+- MB_Slave_Response()
+- MB_Slave_Collect_Message()
+- MB_Slave_Parse_Message()
+- MB_Master_Collect_Message()
+- MB_Master_Parse_Message()
+
+### Функции для работы с RS (UART):
+- RS_Parse_Message() / RS_Collect_Message() — Парсинг и сборка сообщения.
+- RS_Response()                             — Отправка ответа.
+
+******************************************************************************/
+
+#include "modbus.h"
+
+/* MODBUS HANDLES */
+RS_HandleTypeDef hmodbus1;
+RS_MsgTypeDef MODBUS_MSG;
+
+/* DEFINE REGISTERS/COILS */
+MB_DeviceIdentificationTypeDef MB_DEVID;
+MB_DataStructureTypeDef MB_DATA = {0};;
+
+//-------------------------------------------------------------------
+//-----------------------------FOR USER------------------------------
+/** 
+  * @brief    Инициализация периферии модбас.
+  * @param    hmodbus Указатель на хендлер RS
+  * @details  Подключает хендлы периферии к hmodbus
+  *           Конфигурация выставляется по умолчанию из modbus_config.h
+  */
+void MODBUS_SetupHardware(RS_HandleTypeDef *hmodbus, UART_HandleTypeDef *huart, TIM_HandleTypeDef *htim)
+{
+  if((hmodbus == NULL) || (huart == NULL))
+  {
+    return;
+  }
+  MB_DeviceInentificationInit();
+  //-----------SETUP MODBUS-------------
+  // set up modbus: MB_RX_Size_NotConst and Timeout enable
+  hmodbus1.ID = MODBUS_DEVICE_ID;
+  hmodbus1.sRS_Timeout = MODBUS_TIMEOUT;
+  hmodbus1.sRS_Mode = RS_SLAVE_ALWAYS_WAIT;
+  hmodbus1.sRS_RX_Size_Mode = RS_RX_Size_NotConst;
+  
+  // INIT
+  hmodbus1.RS_STATUS = RS_Init(hmodbus, huart, htim, 0);  
+
+  RS_EnableReceive();
+}
+/** 
+  * @brief    Программная конфигурация модбас.
+  * @param    hmodbus указатель на хендлер RS
+  * @param    Timeout Время тишины между двумя байтами после которых перезапускается прием
+  * @param    master  Режим мастер (пока не сделан)
+  * @details  Конфигурирует ID, таймаут и режим hmodbus
+  */
+void MODBUS_Config(RS_HandleTypeDef *hmodbus, uint8_t ID, uint16_t Timeout, uint8_t master)
+{
+  if(hmodbus == NULL)
+  {
+    return;
+  }
+  //-----------SETUP MODBUS-------------
+  // set up modbus: MB_RX_Size_NotConst and Timeout enable
+  hmodbus->ID = ID;
+  hmodbus->sRS_Timeout = Timeout;
+  if(master)
+    hmodbus->sRS_Mode = RS_SLAVE_ALWAYS_WAIT;
+  else
+    hmodbus->sRS_Mode = RS_SLAVE_ALWAYS_WAIT;
+  hmodbus->sRS_RX_Size_Mode = RS_RX_Size_NotConst;
+}
+
+/** 
+  * @brief    Запуск слейв модбас.
+  * @param    hmodbus     Указатель на хендлер RS.
+  * @param    modbus_msg  Указатель на структуру сообщения.
+  * @details  Конфигурирует ID, таймаут и режим hmodbus
+  */
+void MODBUS_SlaveStart(RS_HandleTypeDef *hmodbus, RS_MsgTypeDef *modbus_msg)
+{
+  if(hmodbus == NULL)
+  {
+    return;
+  }
+  
+  if(modbus_msg)
+    RS_Receive_IT(hmodbus, modbus_msg);
+  else
+    RS_Receive_IT(hmodbus, &MODBUS_MSG);
+}
+
+
+
+
+/** 
+  * @brief    Ответ на сообщение в режиме слейва.
+  * @param    hmodbus     Указатель на хендлер RS.
+  * @param    modbus_msg  Указатель на структуру сообщения.
+  * @return   RS_RES  Статус о результате ответа на комманду.
+  */
+static RS_StatusTypeDef MB_Slave_Response(RS_HandleTypeDef *hmodbus, RS_MsgTypeDef *modbus_msg)
+{
+  RS_StatusTypeDef MB_RES = 0;
+  hmodbus->f.MessageHandled = 0;
+  hmodbus->f.EchoResponse = 0;
+  RS_Reset_TX_Flags(hmodbus);     // reset flag for correct transmit
+  
+  if(hmodbus->ID == 0)
+  {
+    hmodbus->RS_STATUS = RS_SKIP;
+    return MB_RES;
+  }
+
+  if(modbus_msg->Func_Code < ERR_VALUES_START)// if no errors after parsing
+  {
+    switch (modbus_msg->Func_Code)
+    {
+      // Read Coils
+      case MB_R_COILS: 
+        hmodbus->f.MessageHandled =   MB_Proccess_Read_Coils(hmodbus->pMessagePtr);
+        break;
+      
+      // Read Hodling Registers
+      case MB_R_HOLD_REGS:
+        hmodbus->f.MessageHandled =   MB_Proccess_Read_Hold_Regs(hmodbus->pMessagePtr);
+        break;
+      case MB_R_IN_REGS: 
+        hmodbus->f.MessageHandled =   MB_Proccess_Read_Input_Regs(hmodbus->pMessagePtr);
+        break;
+      
+      
+      // Write Single Coils
+      case MB_W_COIL: 
+        hmodbus->f.MessageHandled = MB_Proccess_Write_Single_Coil(hmodbus->pMessagePtr); 
+        if(hmodbus->f.MessageHandled) 
+        {
+          hmodbus->f.DataUpdated = 1;
+          hmodbus->f.EchoResponse = 1; 
+          hmodbus->RS_Message_Size -= 2; // echo response if write ok (minus 2 cause of two CRC bytes)
+        }
+        break;
+      
+      case MB_W_HOLD_REG:   
+        hmodbus->f.MessageHandled = MB_Proccess_Write_Single_Reg(hmodbus->pMessagePtr);  
+        if(hmodbus->f.MessageHandled) 
+        {
+          hmodbus->f.DataUpdated = 1;
+          hmodbus->f.EchoResponse = 1;
+          hmodbus->RS_Message_Size -= 2; // echo response if write ok (minus 2 cause of two CRC bytes)
+        }
+        break;
+      
+      // Write Multiple Coils
+      case MB_W_COILS: 
+        hmodbus->f.MessageHandled =   MB_Write_Miltuple_Coils(hmodbus->pMessagePtr);
+        if(hmodbus->f.MessageHandled) 
+        {
+          hmodbus->f.DataUpdated = 1;
+          hmodbus->f.EchoResponse = 1; 
+          hmodbus->RS_Message_Size = 6; // echo response if write ok (withous data bytes)
+        }
+        break;
+      
+      // Write Multiple Registers
+      case MB_W_HOLD_REGS:
+        hmodbus->f.MessageHandled =   MB_Proccess_Write_Miltuple_Regs(hmodbus->pMessagePtr);
+        if(hmodbus->f.MessageHandled) 
+        {
+          hmodbus->f.DataUpdated = 1;
+          hmodbus->f.EchoResponse = 1; 
+          hmodbus->RS_Message_Size = 6; // echo response if write ok (withous data bytes)
+        }
+        break;
+      
+      case MB_R_DEVICE_INFO:
+        hmodbus->f.MessageHandled =   MB_Proccess_Read_Device_Identification(hmodbus->pMessagePtr);
+        break;
+        
+      /* unknown func code */
+      default: modbus_msg->Except_Code = 0x01; /* set exception code: illegal function */
+    }   
+        
+    if(hmodbus->f.MessageHandled == 0)
+    {
+      TrackerCnt_Warn(hmodbus->rs_err);
+			modbus_msg->Func_Code |= ERR_VALUES_START;
+    }
+    else
+    {
+      TrackerCnt_Ok(hmodbus->rs_err);
+    }
+    
+      
+  }
+  
+  // if we need response - check that transmit isnt busy
+  if( RS_Is_TX_Busy(hmodbus) ) 
+    RS_Abort(hmodbus, ABORT_TX);    // if tx busy - set it free
+  
+  // Transmit right there, or sets (fDeferredResponse) to transmit response in main code  
+  if(hmodbus->f.DeferredResponse == 0)
+  {
+    MB_RES = RS_Handle_Transmit_Start(hmodbus, modbus_msg);
+  }
+  else
+  {
+    RS_Handle_Receive_Start(hmodbus, modbus_msg);
+    hmodbus->f.DeferredResponse = 0;
+  }
+  
+  hmodbus->RS_STATUS = MB_RES;
+  return MB_RES;
+}
+
+
+
+/** 
+  * @brief    Сбор сообщения в буфер UART в режиме слейв.
+  * @param    hmodbus           Указатель на хендлер RS.
+  * @param    modbus_msg        Указатель на структуру сообщения.
+  * @param    modbus_uart_buff  Указатель на буффер UART.
+  * @return   RS_RES        Статус о результате заполнения буфера.
+  */
+static RS_StatusTypeDef MB_Slave_Collect_Message(RS_HandleTypeDef *hmodbus, RS_MsgTypeDef *modbus_msg, uint8_t *modbus_uart_buff)
+{
+  int ind = 0; // ind for modbus-uart buffer
+  
+  if(hmodbus->f.EchoResponse && hmodbus->f.MessageHandled)  // if echo response need
+    ind = hmodbus->RS_Message_Size;
+  else
+  {
+    //------INFO ABOUT DATA/MESSAGE------
+    //-----------[first bytes]-----------
+    // set ID of message/user
+    modbus_uart_buff[ind++] = modbus_msg->MbAddr; 
+
+    // set dat or err response
+    modbus_uart_buff[ind++] = modbus_msg->Func_Code;  
+
+    if (modbus_msg->Func_Code < ERR_VALUES_START) // if no error occur
+    {
+      // fill modbus header
+      if(modbus_msg->Func_Code == MB_R_DEVICE_INFO) // devide identification header
+      {
+        modbus_uart_buff[ind++] = modbus_msg->DevId.MEI_Type;
+        modbus_uart_buff[ind++] = modbus_msg->DevId.ReadDevId;
+        modbus_uart_buff[ind++] = modbus_msg->DevId.Conformity;
+        modbus_uart_buff[ind++] = modbus_msg->DevId.MoreFollows;
+        modbus_uart_buff[ind++] = modbus_msg->DevId.NextObjId;
+        modbus_uart_buff[ind++] = modbus_msg->DevId.NumbOfObj;
+        
+        if (modbus_msg->ByteCnt > DATA_SIZE*2) // if ByteCnt less than DATA_SIZE
+        {
+          TrackerCnt_Err(hmodbus->rs_err);
+          return RS_COLLECT_MSG_ERR;
+        }
+        
+        
+        //---------------DATA----------------
+        //-----------[data bytes]------------
+        uint8_t *tmp_data_addr = (uint8_t *)modbus_msg->DATA;
+        for(int i = 0; i < modbus_msg->ByteCnt; i++) // filling buffer with data
+        { // set data
+          modbus_uart_buff[ind++] = *tmp_data_addr;
+          tmp_data_addr++;
+        }
+        
+      }
+      else // modbus data header
+      {
+        // set size of received data
+        if (modbus_msg->ByteCnt <= DATA_SIZE*2) // if ByteCnt less than DATA_SIZE
+          modbus_uart_buff[ind++] = modbus_msg->ByteCnt;
+        else                                        // otherwise return data_size err
+        {
+          TrackerCnt_Err(hmodbus->rs_err);
+          return RS_COLLECT_MSG_ERR;
+        }        
+        
+        //---------------DATA----------------
+        //-----------[data bytes]------------
+        uint16_t *tmp_data_addr = (uint16_t *)modbus_msg->DATA;
+        for(int i = 0; i < modbus_msg->ByteCnt; i++) // filling buffer with data
+        { // set data
+          if (i%2 == 0)   // HI byte
+            modbus_uart_buff[ind++] = (*tmp_data_addr)>>8;
+          else            // LO byte
+          {
+            modbus_uart_buff[ind++] = *tmp_data_addr;
+            tmp_data_addr++;
+          }
+        }
+
+      }
+      
+    }
+    else  // if some error occur
+    {     // send expection code
+      modbus_uart_buff[ind++] = modbus_msg->Except_Code;
+    }
+  }
+  if(ind < 0)
+    return RS_COLLECT_MSG_ERR;
+  
+  //---------------CRC----------------
+  //---------[last 16 bytes]----------
+  // calc crc of received data
+  uint16_t CRC_VALUE = crc16(modbus_uart_buff, ind);
+  // write crc to message structure and modbus-uart buffer
+  modbus_msg->MB_CRC = CRC_VALUE;
+  modbus_uart_buff[ind++] = CRC_VALUE;
+  modbus_uart_buff[ind++] = CRC_VALUE >> 8;
+  
+  hmodbus->RS_Message_Size = ind;
+  
+  return RS_OK; // returns ok
+}
+
+/** 
+  * @brief    Определить размер модбас запроса.
+  * @param    hRS           Указатель на хендлер RS.
+  * @param    rx_data_size  Указатель на переменную для записи кол-ва байт для принятия.
+  * @return   RS_RES        Статус о корректности рассчета кол-ва байт для принятия.
+  * @details  Определение сколько байтов надо принять по протоколу.
+  */
+static int MB_Define_Size_of_Function(RS_HandleTypeDef *hmodbus, RS_MsgTypeDef *modbus_msg)
+{   
+  RS_StatusTypeDef MB_RES = 0;
+  int mb_func_size = 0;
+  
+  if ((modbus_msg->Func_Code & ~ERR_VALUES_START) < 0x0F)
+  {
+    modbus_msg->ByteCnt = 0;
+    mb_func_size = 1;
+    
+  }
+  else
+  {
+    modbus_msg->ByteCnt = hmodbus->pBufferPtr[RX_FIRST_PART_SIZE-1]; // get numb of data in command
+  // +1 because that defines is size, not ind.
+    mb_func_size = modbus_msg->ByteCnt + 2;
+  }
+  
+  
+  if(modbus_msg->Func_Code == MB_R_DEVICE_INFO)
+  {
+    mb_func_size = 0;
+  }
+  
+  mb_func_size = RX_FIRST_PART_SIZE + mb_func_size; // size of whole message
+  return mb_func_size;
+}
+
+
+/** 
+  * @brief    Парс сообщения в режиме слейв.
+  * @param    hmodbus           Указатель на хендлер RS.
+  * @param    modbus_msg        Указатель на структуру сообщения.
+  * @param    modbus_uart_buff  Указатель на буффер UART.
+  * @return   RS_RES        Статус о результате заполнения структуры.
+  * @details    Заполнение структуры сообщения из буффера UART.
+  */
+static RS_StatusTypeDef MB_Slave_Parse_Message(RS_HandleTypeDef *hmodbus, RS_MsgTypeDef *modbus_msg, uint8_t *modbus_uart_buff)
+{
+  uint32_t check_empty_buff;
+  int ind = 0; // ind for modbus-uart buffer
+  hmodbus->f.RX_Continue = 0;
+  //-----INFO ABOUT DATA/MESSAGE-------
+  //-----------[first bits]------------
+  // get ID of message/user
+  if(modbus_uart_buff[ind] != hmodbus->ID)
+  {
+    modbus_msg->MbAddr = 0;
+    return RS_SKIP;
+  }
+	modbus_msg->MbAddr = modbus_uart_buff[ind++];
+  
+  // get func code
+  modbus_msg->Func_Code = modbus_uart_buff[ind++];
+  if(modbus_msg->Func_Code & ERR_VALUES_START) // явная херня
+  {
+    modbus_msg->MbAddr = 0;
+    return RS_SKIP;
+  }
+  
+  if(modbus_msg->Func_Code == MB_R_DEVICE_INFO) // if it device identification request
+  {
+    modbus_msg->DevId.MEI_Type = modbus_uart_buff[ind++];
+    modbus_msg->DevId.ReadDevId = modbus_uart_buff[ind++];
+    modbus_msg->DevId.NextObjId = modbus_uart_buff[ind++];
+    modbus_msg->ByteCnt = 0;
+  }
+  else // if its classic modbus request
+  {
+    // get address from CMD
+    modbus_msg->Addr = modbus_uart_buff[ind++] << 8;
+    modbus_msg->Addr |= modbus_uart_buff[ind++];
+    
+    // get address from CMD
+    modbus_msg->Qnt = modbus_uart_buff[ind++] << 8;
+    modbus_msg->Qnt |= modbus_uart_buff[ind++];
+  }
+  
+  if((hmodbus->pMessagePtr->Func_Code == 0x0F) || (hmodbus->pMessagePtr->Func_Code == 0x10))
+		hmodbus->pMessagePtr->ByteCnt = modbus_uart_buff[ind++];
+	else
+		hmodbus->pMessagePtr->ByteCnt = 0;
+  
+  //---------------DATA----------------
+  //            (optional)
+  if (modbus_msg->ByteCnt != 0)
+  {
+    //check that data size is correct
+    if (modbus_msg->ByteCnt > DATA_SIZE*2)
+    {
+      TrackerCnt_Err(hmodbus->rs_err);
+      modbus_msg->Func_Code |= ERR_VALUES_START;
+      return RS_PARSE_MSG_ERR;
+    }
+    uint16_t *tmp_data_addr = (uint16_t *)modbus_msg->DATA;
+    for(int i = 0; i < modbus_msg->ByteCnt; i++)
+    { // set data
+      if (i%2 == 0)
+        *tmp_data_addr = ((uint16_t)modbus_uart_buff[ind++] << 8);
+      else
+      {
+        *tmp_data_addr |= modbus_uart_buff[ind++];
+        tmp_data_addr++;
+      }
+    }
+  }
+  
+  //---------------CRC----------------
+  //----------[last 16 bits]----------
+  // calc crc of received data
+  uint16_t CRC_VALUE = crc16(modbus_uart_buff, ind);
+  // get crc of received data
+  modbus_msg->MB_CRC = modbus_uart_buff[ind++];
+  modbus_msg->MB_CRC |= modbus_uart_buff[ind++] << 8;
+  // compare crc
+  if (modbus_msg->MB_CRC != CRC_VALUE)
+  {
+    TrackerCnt_Err(hmodbus->rs_err);
+    modbus_msg->Func_Code |= ERR_VALUES_START;
+  }
+//		hmodbus->MB_RESPONSE = MB_CRC_ERR; // set func code - error about wrong crc
+  
+  // check is buffer empty
+  check_empty_buff = 0;
+  for(int i=0; i<ind;i++)
+    check_empty_buff += modbus_uart_buff[i];
+//	if(check_empty_buff == 0) 
+//		hmodbus->MB_RESPONSE = MB_EMPTY_MSG; // 
+  
+  // если размер меньше ожидаемого - продолжаем принимать
+  if(hmodbus->RS_Message_Size < MB_Define_Size_of_Function(hmodbus, modbus_msg))
+  {
+    hmodbus->f.RX_Continue = 1;
+    return RS_SKIP;
+  }
+  // если больше Ошибка
+  else if (hmodbus->RS_Message_Size > MB_Define_Size_of_Function(hmodbus, modbus_msg))
+  {
+    return RS_PARSE_MSG_ERR;
+  }
+  
+  return RS_OK;
+}
+
+
+
+
+
+
+
+
+/** 
+  * @brief    Сбор сообщения в буфер UART в режиме мастер.
+  * @param    hmodbus           Указатель на хендлер RS.
+  * @param    modbus_msg        Указатель на структуру сообщения.
+  * @param    modbus_uart_buff  Указатель на буффер UART.
+  * @return   RS_RES        Статус о результате заполнения буфера.
+  */
+static RS_StatusTypeDef MB_Master_Collect_Message(RS_HandleTypeDef *hmodbus, RS_MsgTypeDef *modbus_msg, uint8_t *modbus_uart_buff)
+{
+  return RS_PARSE_MSG_ERR;
+}
+
+
+/** 
+  * @brief    Парс сообщения в режиме мастер.
+  * @param    hmodbus           Указатель на хендлер RS.
+  * @param    modbus_msg        Указатель на структуру сообщения.
+  * @param    modbus_uart_buff  Указатель на буффер UART.
+  * @return   RS_RES        Статус о результате заполнения структуры.
+  */
+static RS_StatusTypeDef MB_Master_Parse_Message(RS_HandleTypeDef *hmodbus, RS_MsgTypeDef *modbus_msg, uint8_t *modbus_uart_buff)
+{
+  return RS_PARSE_MSG_ERR;
+}
+
+
+
+
+
+/* Реализация функций из rs_message.c для протокола */
+RS_StatusTypeDef RS_Response(RS_HandleTypeDef *hmodbus, RS_MsgTypeDef *modbus_msg)
+{
+  if(hmodbus->sRS_Mode >= RS_MASTER_START)
+  {
+    return RS_ERR;
+  }
+  return MB_Slave_Response(hmodbus, modbus_msg);
+}
+
+RS_StatusTypeDef RS_Collect_Message(RS_HandleTypeDef *hmodbus, RS_MsgTypeDef *modbus_msg, uint8_t *modbus_uart_buff)
+{
+  if(hmodbus->sRS_Mode < RS_MASTER_START)
+  {
+    return MB_Slave_Collect_Message(hmodbus, modbus_msg, modbus_uart_buff);
+  }
+  else
+  {
+    return MB_Master_Collect_Message(hmodbus, modbus_msg, modbus_uart_buff);
+  }
+}
+
+RS_StatusTypeDef RS_Parse_Message(RS_HandleTypeDef *hmodbus, RS_MsgTypeDef *modbus_msg, uint8_t *modbus_uart_buff)
+{
+  if(hmodbus->sRS_Mode < RS_MASTER_START)
+  {
+    return MB_Slave_Parse_Message(hmodbus, modbus_msg, modbus_uart_buff);
+  }
+  else
+  {
+    return MB_Master_Parse_Message(hmodbus, modbus_msg, modbus_uart_buff);
+  }
+}
--- a/Modbus/Src/modbus_coils.c
+++ b/Modbus/Src/modbus_coils.c
@@ -0,0 +1,238 @@
+/**
+******************************************************************************
+* @file modbus_coils.c
+* @brief Реализация работы с коилами Modbus
+******************************************************************************
+* @details
+Модуль обработки команд для coils (битовых данных):
+- Чтение coils (0x01) - упаковка битов в байты для передачи
+- Запись одиночного coil (0x05) - установка/сброс бита
+- Запись множественных coils (0x0F) - распаковка битов из байтов
+
+******************************************************************************/
+#include "modbus_coils.h"
+
+
+
+/** 
+  * @brief    Set or Reset Coil at its global address.
+  * @param    Addr          Адрес коила.
+  * @param    WriteVal      Что записать в коил: 0 или 1.
+  * @return   ExceptionCode Код исключения если коила по адресу не существует, и NO_ERRORS если все ок.
+  *
+  * @details  Позволяет обратиться к любому коилу по его глобальному адрессу.
+              Вне зависимости от того как коилы размещены в памяти.
+  */
+MB_ExceptionTypeDef MB_Write_Coil_Global(uint16_t Addr, MB_CoilsOpTypeDef WriteVal)
+{
+  //---------CHECK FOR ERRORS----------
+  MB_ExceptionTypeDef Exception = NO_ERRORS;
+  uint16_t *coils;
+  uint16_t start_shift = 0; // shift in coils register
+  
+  //------------WRITE COIL-------------
+  Exception = MB_DefineCoilsAddress(&coils, Addr, 1, &start_shift, 1);
+  if(Exception == NO_ERRORS)
+  {
+    switch(WriteVal)
+    {
+      case SET_COIL:
+        *coils |= (1<<start_shift);       
+        break;
+        
+      case RESET_COIL:
+        *coils &= ~(1<<start_shift);          
+        break;
+        
+      case TOOGLE_COIL:
+        *coils ^= (1<<start_shift);           
+        break;
+      
+    }   
+  }
+  return Exception;
+}
+
+
+/** 
+  * @brief    Read Coil at its global address.
+  * @param    Addr          Адрес коила.
+  * @param    Exception     Указатель на переменную для кода исключения, в случа неудачи при чтении.
+  * @return   uint16_t      Возвращает весь регистр с маской на запрошенном коиле.
+  *
+  * @details  Позволяет обратиться к любому коилу по его глобальному адрессу.
+              Вне зависимости от того как коилы размещены в памяти.
+  */
+uint16_t MB_Read_Coil_Global(uint16_t Addr, MB_ExceptionTypeDef *Exception)
+{
+  //---------CHECK FOR ERRORS----------
+  MB_ExceptionTypeDef Exception_tmp;
+  if(Exception == NULL)             // if exception is not given to func fill it
+    Exception = &Exception_tmp;
+    
+  uint16_t *coils;
+  uint16_t start_shift = 0; // shift in coils register
+  
+  //------------READ COIL--------------
+  *Exception = MB_DefineCoilsAddress(&coils, Addr, 1, &start_shift, 0); 
+  if(*Exception == NO_ERRORS)
+  {
+    return ((*coils)&(1<<start_shift));
+  }
+  else
+  {
+    return 0;
+  }
+}
+
+
+/** 
+  * @brief    Proccess command Read Coils (01 - 0x01).
+  * @param    modbus_msg        Указатель на структуру собщения modbus.
+  * @return   fMessageHandled   Статус о результате обработки комманды.
+  * @details  Обработка команды Read Coils.
+  */
+uint8_t MB_Proccess_Read_Coils(RS_MsgTypeDef *modbus_msg)
+{
+  //---------CHECK FOR ERRORS----------
+  uint16_t *coils;
+  uint16_t start_shift = 0; // shift in coils register
+  
+  modbus_msg->Except_Code = MB_DefineCoilsAddress(&coils, modbus_msg->Addr, modbus_msg->Qnt, &start_shift, 0);
+  if(modbus_msg->Except_Code != NO_ERRORS)
+    return 0;
+  
+  //-----------READING COIL------------
+  // setup output message data size 
+  modbus_msg->ByteCnt = Divide_Up(modbus_msg->Qnt, 8);
+  // create mask for coils
+  uint16_t mask_for_coils = 0;  // mask for coils that've been chosen
+  uint16_t setted_coils = 0;    // value of setted coils
+  uint16_t temp_reg = 0;        // temp register for saving coils that hasnt been chosen
+  uint16_t coil_cnt = 0;        // counter for processed coils
+
+  // cycle until all registers with requered coils would be processed
+  int shift = start_shift;  // set shift to first coil in first register
+  int ind = 0;              // index for coils registers and data
+  for(; ind <= Divide_Up(start_shift + modbus_msg->Qnt, 16); ind++)
+  { 
+    //----SET MASK FOR COILS REGISTER----
+    mask_for_coils = 0;
+    for(; shift < 0x10; shift++)
+    {
+      mask_for_coils |= 1<<(shift); // choose certain coil
+      if(++coil_cnt >= modbus_msg->Qnt)
+        break;
+    }
+    shift = 0; // set shift to zero for the next step
+  
+    //-----------READ COILS--------------
+    modbus_msg->DATA[ind] = (*(coils+ind)&mask_for_coils) >> start_shift;
+    if(ind > 0)
+      modbus_msg->DATA[ind-1] |= ((*(coils+ind)&mask_for_coils) << 16) >> start_shift;
+      
+  }
+  // т.к. DATA 16-битная, для 8-битной передачи, надо поменять местами верхний и нижний байты
+  for(; ind >= 0; --ind)  
+    modbus_msg->DATA[ind] = ByteSwap16(modbus_msg->DATA[ind]);
+  
+  return 1;
+}
+
+/**
+  * @brief    Proccess command Write Single Coils (05 - 0x05).
+  * @param    modbus_msg        Указатель на структуру собщения modbus.
+  * @return   fMessageHandled   Статус о результате обработки комманды.
+  * @details  Обработка команды Write Single Coils.
+  */
+uint8_t MB_Proccess_Write_Single_Coil(RS_MsgTypeDef *modbus_msg)
+{
+  //---------CHECK FOR ERRORS----------
+  if ((modbus_msg->Qnt != 0x0000) && (modbus_msg->Qnt != 0xFF00))
+  {
+    modbus_msg->Except_Code = ILLEGAL_DATA_VALUE;
+    return 0;
+  }   
+  // define position of coil
+  uint16_t *coils;
+  uint16_t start_shift = 0; // shift in coils register
+  modbus_msg->Except_Code = MB_DefineCoilsAddress(&coils, modbus_msg->Addr, 0, &start_shift, 1);
+  if(modbus_msg->Except_Code != NO_ERRORS)
+    return 0;
+  
+
+  //----------WRITTING COIL------------
+  if(modbus_msg->Qnt == 0xFF00)
+    *(coils) |= 1<<start_shift; // write flags corresponding to received data
+  else
+    *(coils) &= ~(1<<start_shift); // write flags corresponding to received data
+  
+  return 1;
+}
+
+/**
+  * @brief    Proccess command Write Multiple Coils (15 - 0x0F).
+  * @param    modbus_msg      Указатель на структуру собщения modbus.
+  * @return   fMessageHandled Статус о результате обработки комманды.
+  * @details  Обработка команды Write Multiple Coils.
+  */
+uint8_t MB_Write_Miltuple_Coils(RS_MsgTypeDef *modbus_msg)
+{
+  //---------CHECK FOR ERRORS----------
+  if (modbus_msg->ByteCnt != Divide_Up(modbus_msg->Qnt, 8))
+  { // if quantity too large OR if quantity and bytes count arent match
+    modbus_msg->Except_Code = ILLEGAL_DATA_VALUE;
+    return 0;
+  } 
+  // define position of coil
+  uint16_t *coils;          // pointer to coils
+  uint16_t start_shift = 0; // shift in coils register
+  modbus_msg->Except_Code = MB_DefineCoilsAddress(&coils, modbus_msg->Addr, modbus_msg->Qnt, &start_shift, 1);
+  if(modbus_msg->Except_Code != NO_ERRORS)
+    return 0;
+  
+  //----------WRITTING COILS-----------
+  // create mask for coils
+  uint16_t mask_for_coils = 0;  // mask for coils that've been chosen
+  uint32_t setted_coils = 0;    // value of setted coils
+  uint16_t temp_reg = 0;        // temp register for saving coils that hasnt been chosen
+  uint16_t coil_cnt = 0;        // counter for processed coils
+
+  // cycle until all registers with requered coils would be processed
+  int shift = start_shift; // set shift to first coil in first register
+  for(int ind = 0; ind <= Divide_Up(start_shift + modbus_msg->Qnt, 16); ind++)
+  { 
+    //----SET MASK FOR COILS REGISTER----
+    mask_for_coils = 0;
+    for(; shift < 0x10; shift++)
+    {
+      mask_for_coils |= 1<<(shift); // choose certain coil
+      if(++coil_cnt >= modbus_msg->Qnt)
+        break;
+    }
+    shift = 0; // set shift to zero for the next step
+    
+    
+    
+    //-----------WRITE COILS-------------
+    // get current coils
+    temp_reg = *(coils+ind);
+    // set coils
+    setted_coils = ByteSwap16(modbus_msg->DATA[ind]) << start_shift;
+    if(ind > 0)
+    {
+      setted_coils |= ((ByteSwap16(modbus_msg->DATA[ind-1]) << start_shift) >> 16);
+    }
+    // write coils
+      
+    *(coils+ind) = setted_coils & mask_for_coils;   
+     // restore untouched coils
+    *(coils+ind) |= temp_reg&(~mask_for_coils);
+    
+    
+    if(coil_cnt >= modbus_msg->Qnt) // if all coils written - break cycle
+      break;                        // *kind of unnecessary
+  }
+  
+  return 1;
+}
--- a/Modbus/Src/modbus_core.c
+++ b/Modbus/Src/modbus_core.c
@@ -0,0 +1,10 @@
+/**
+******************************************************************************
+* @file modbus_core.c
+* @brief Базовая реализация ядра Modbus (заглушка)
+******************************************************************************
+* @details
+В текущей реализации этот файл служит заглушкой для будущего расширения
+функциональности ядра Modbus протокола.
+******************************************************************************/
+#include "modbus_core.h"
--- a/Modbus/Src/modbus_data.c
+++ b/Modbus/Src/modbus_data.c
@@ -0,0 +1,142 @@
+/**
+******************************************************************************
+* @file modbus_data.c
+* @brief Функции доступа к данным Modbus
+******************************************************************************
+* @details
+Модуль реализует функции валидации адресов и доступа к данным:
+- Проверка корректности запрашиваемых адресов
+- Определение указателей на реальные данные в памяти
+- Поддержка пользовательских массивов регистров и coils
+
+@section Валидация адресов:
+- MB_Check_Address_For_Arr() - проверка принадлежности адреса массиву
+- MB_DefineRegistersAddress() - получение указателя на регистры
+- MB_DefineCoilsAddress() - получение указателя на coils
+
+******************************************************************************/
+
+#include "modbus_core.h"
+#include "modbus_coils.h"
+#include "modbus_holdregs.h"
+#include "modbus_inputregs.h"
+#include "modbus_devid.h"
+
+
+
+/** 
+  * @brief    Check is address valid for certain array.
+  * @param    Addr          Начальный адресс.
+  * @param    Qnt           Количество запрашиваемых элементов.
+  * @param    R_ARR_ADDR    Начальный адресс массива R_ARR.
+  * @param    R_ARR_NUMB    Количество элементов в массиве R_ARR.
+  * @return   ExceptionCode - ILLEGAL DATA ADRESS если адресс недействителен, и NO_ERRORS если все ок.
+  *
+  * @details  Позволяет определить, принадлежит ли адресс Addr массиву R_ARR:
+  *           Если адресс Addr находится в диапазоне адрессов массива R_ARR, то возвращаем NO_ERROR.
+  *           Если адресс Addr находится за пределами адрессов массива R_ARR - ILLEGAL_DATA_ADDRESSю.
+  */
+MB_ExceptionTypeDef MB_Check_Address_For_Arr(uint16_t Addr, uint16_t Qnt, uint16_t R_ARR_ADDR, uint16_t R_ARR_NUMB)
+{
+  // if address from this array
+  if(Addr >= R_ARR_ADDR) 
+  {   
+    // if quantity too big return error
+    if ((Addr - R_ARR_ADDR) + Qnt > R_ARR_NUMB) 
+    {
+      return ILLEGAL_DATA_ADDRESS;  // return exception code
+    }
+    // if all ok - return no errors
+    return NO_ERRORS;
+  }
+  // if address isnt from this array return error
+  else 
+    return ILLEGAL_DATA_ADDRESS;  // return exception code    
+}
+/** 
+  * @brief    Define Address Origin for Input/Holding Registers
+  * @param    pRegs         Указатель на указатель регистров.
+  * @param    Addr          Адрес начального регистра.
+  * @param    Qnt           Количество запрашиваемых регистров.
+  * @param    WriteFlag     Флаг регистр нужны для чтения или записи.
+  * @return   ExceptionCode Код исключения если есть, и NO_ERRORS если нет.
+  *
+  * @details  Определение адреса начального регистра.
+  * @note     WriteFlag пока не используется.
+  */
+MB_ExceptionTypeDef MB_DefineRegistersAddress(uint16_t **pRegs, uint16_t Addr, uint16_t Qnt, uint8_t RegisterType)
+{ 
+  /* check quantity error */
+  if (Qnt > DATA_SIZE)  
+  {   
+      return ILLEGAL_DATA_VALUE;  // return exception code
+  }
+  
+  if(RegisterType == RegisterType_Holding)
+  {
+    // Default holding registers
+    if(MB_Check_Address_For_Arr(Addr, Qnt, R_HOLDING_ADDR, R_HOLDING_QNT) == NO_ERRORS)
+    {
+      *pRegs = MB_Set_Register_Ptr(&MB_DATA.HoldRegs, Addr);  // указатель на выбранный по Addr регистр
+    }
+    // if address doesnt match any array - return illegal data address response
+    else  
+    {
+      return ILLEGAL_DATA_ADDRESS;
+    }
+  }
+  else if(RegisterType == RegisterType_Input)
+  {
+    // Default input registers
+    if(MB_Check_Address_For_Arr(Addr, Qnt, R_INPUT_ADDR, R_INPUT_QNT) == NO_ERRORS)
+    {
+      *pRegs = MB_Set_Register_Ptr(&MB_DATA.InRegs, Addr);  // указатель на выбранный по Addr регистр
+    }
+    // if address doesnt match any array - return illegal data address response
+    else  
+    {
+      return ILLEGAL_DATA_ADDRESS;
+    }
+  }
+  else
+  {
+      return ILLEGAL_FUNCTION;
+  }
+  // if found requeried array return no err
+  return NO_ERRORS; // return no errors
+}
+/** 
+  * @brief    Define Address Origin for coils
+  * @param    pCoils        Указатель на указатель коилов.
+  * @param    Addr          Адресс начального коила.
+  * @param    Qnt           Количество запрашиваемых коилов.
+  * @param    start_shift   Указатель на переменную содержащую сдвиг внутри регистра для начального коила.
+  * @param    WriteFlag     Флаг коилы нужны для чтения или записи.
+  * @return   ExceptionCode Код исключения если есть, и NO_ERRORS если нет.
+  *
+  * @details  Определение адреса начального регистра запрашиваемых коилов.
+  * @note     WriteFlag используется для определния регистров GPIO: ODR или IDR.
+  */
+MB_ExceptionTypeDef MB_DefineCoilsAddress(uint16_t **pCoils, uint16_t Addr, uint16_t Qnt, uint16_t *start_shift, uint8_t WriteFlag)
+{ 
+  /* check quantity error */
+  if (Qnt > 2000) 
+  {
+    return ILLEGAL_DATA_VALUE;  // return exception code
+  }
+    
+  // Default coils
+  if(MB_Check_Address_For_Arr(Addr, Qnt, C_COILS_ADDR, C_COILS_QNT) == NO_ERRORS)
+  {
+    *pCoils = MB_Set_Coil_Reg_Ptr(&MB_DATA.Coils, Addr);  // указатель на выбранный по Addr массив коилов
+  }
+  // if address doesnt match any array - return illegal data address response
+  else  
+  {
+    return ILLEGAL_DATA_ADDRESS;
+  }
+  
+  *start_shift = Addr % 16; // set shift to requested coil
+  // if found requeried array return no err
+  return NO_ERRORS; // return no errors
+}
--- a/Modbus/Src/modbus_devid.c
+++ b/Modbus/Src/modbus_devid.c
@@ -0,0 +1,535 @@
+/**
+******************************************************************************
+* @file modbus_devid.c
+* @brief Реализация идентификации устройства Modbus
+******************************************************************************
+* @details
+Модуль обработки запросов идентификации устройства через MEI-тип 0x0E:
+- Формирование иерархии объектов идентификации
+- Поддержка потоковой передачи при большом количестве объектов
+- Автоматический расчет MoreFollows флагов
+
+@section Потоковая передача:
+При большом количестве объектов идентификация разбивается на несколько
+сообщений с установкой флага MoreFollows и указанием NextObjId для
+продолжения чтения в следующем запросе.
+******************************************************************************/
+
+#include "modbus_devid.h"
+
+  
+/**
+	* @brief 		Write Object of Device Identification to MessageData
+	* @param 		mbdata  Указатель на массив данных в структуре RS_MsgTypeDef.
+	* @return 	obj		  Объект для записи.
+	*/
+void MB_WriteSingleObjectToMessage(char *mbdata, unsigned *ind, MB_DeviceObjectTypeDef *obj)
+{
+  mbdata[(*ind)++] = obj->length;
+  for (int i = 0; i < obj->length; i++)
+  {
+    mbdata[(*ind)++] = obj->name[i];
+  }
+}
+
+
+/**
+	* @brief 		Write Object of Device Identification to MessageData
+	* @param 		mbdata  Указатель на массив данных в структуре RS_MsgTypeDef.
+	* @return 	obj		  Объект для записи.
+	*/
+void MB_WriteObjectsToMessage(RS_MsgTypeDef *modbus_msg, unsigned maxidofobj)
+{
+  MB_DeviceObjectTypeDef *obj = (MB_DeviceObjectTypeDef *)&MB_DEVID;
+  unsigned objidtmp = modbus_msg->DevId.NextObjId;
+  
+  /* Define number of object in one message */
+  unsigned lastobjid = 0;
+  for(int i = 0; i < DATA_SIZE*2;)
+  {
+    i += 2;
+    i += obj[objidtmp].length;
+    /* Если все еще помещается в массив переходим на следующий объект */
+    if(i < DATA_SIZE*2)
+    {
+      objidtmp++;
+    }
+    /* Если объекты для записи закончились - выходим из цикла*/
+    if(objidtmp > maxidofobj)
+      break;
+  }
+  lastobjid = objidtmp-1;
+  
+  
+  /* Fill message with objects data */
+  char *mbdata = (char *)&modbus_msg->DATA;
+  unsigned ind = 0;
+  unsigned objid = modbus_msg->DevId.NextObjId;
+  for(; objid <= lastobjid; objid++)
+  {
+    mbdata[ind++] = objid;
+    MB_WriteSingleObjectToMessage(mbdata, &ind, &obj[objid]);
+  }
+  objid--;
+  modbus_msg->ByteCnt = ind;
+  modbus_msg->DevId.NextObjId = lastobjid+1;
+  if(objid == maxidofobj)
+  {
+    modbus_msg->DevId.MoreFollows = 0;
+  }
+  else
+  {
+    modbus_msg->DevId.MoreFollows = 0xFF;
+  }
+}
+
+
+/**
+  * @brief    Proccess command Read Device Identification (43/14 - 0x2B/0E).
+  * @param    modbus_msg        Указатель на структуру собщения modbus.
+  * @return   fMessageHandled   Статус о результате обработки комманды.
+  * @details  Обработка команды Write Single Register.
+  */
+uint8_t MB_Proccess_Read_Device_Identification(RS_MsgTypeDef *modbus_msg)
+{  
+  switch(modbus_msg->DevId.ReadDevId)
+  { 
+    case MB_BASIC_IDENTIFICATION:
+      if (modbus_msg->DevId.NextObjId == 0)
+      {
+        modbus_msg->DevId.NextObjId = 0;
+      }
+      
+      MB_WriteObjectsToMessage(modbus_msg, 2);
+      modbus_msg->DevId.NumbOfObj = 3;
+      break;
+      
+    case MB_REGULAR_IDENTIFICATION:
+      if (modbus_msg->DevId.NextObjId == 0)
+      {
+        modbus_msg->DevId.NextObjId = 3;
+      }
+      
+      MB_WriteObjectsToMessage(modbus_msg, 6);
+      modbus_msg->DevId.NumbOfObj = 4;
+      break;
+      
+    case MB_EXTENDED_IDENTIFICATION:
+      if (modbus_msg->DevId.NextObjId == 0)
+      {
+        modbus_msg->DevId.NextObjId = 0x80;
+      }
+      
+      MB_WriteObjectsToMessage(modbus_msg, 0x80+MODBUS_NUMB_OF_USEROBJECTS);
+      modbus_msg->DevId.NumbOfObj = MODBUS_NUMB_OF_USEROBJECTS;
+      break;
+      
+    case MB_SPEDIFIC_IDENTIFICATION:      
+      MB_WriteObjectsToMessage(modbus_msg, modbus_msg->DevId.NextObjId);
+      modbus_msg->DevId.NumbOfObj = 1;
+      break;
+    default:
+      return 0;
+  }  
+  return 1;
+}
+
+
+
+
+
+void MB_DeviceInentificationInit(void)
+{
+  MB_ObjectInit(&MB_DEVID.VendorName,          MODBUS_VENDOR_NAME);
+  MB_ObjectInit(&MB_DEVID.ProductCode,         MODBUS_PRODUCT_CODE);
+  MB_ObjectInit(&MB_DEVID.Revision,            MODBUS_REVISION);
+  MB_ObjectInit(&MB_DEVID.VendorUrl,           MODBUS_VENDOR_URL);
+  MB_ObjectInit(&MB_DEVID.ProductName,         MODBUS_PRODUCT_NAME);
+  MB_ObjectInit(&MB_DEVID.ModelName,           MODBUS_MODEL_NAME);
+  
+#ifdef MODBUS_USEROBJECT_0_NAME
+  MB_ObjectInit(&MB_DEVID.User[0],   MODBUS_USEROBJECT_0_NAME);      
+#endif
+#ifdef MODBUS_USEROBJECT_1_NAME
+  MB_ObjectInit(&MB_DEVID.User[1],   MODBUS_USEROBJECT_1_NAME);      
+#endif
+#ifdef MODBUS_USEROBJECT_2_NAME
+  MB_ObjectInit(&MB_DEVID.User[2],   MODBUS_USEROBJECT_2_NAME);      
+#endif
+#ifdef MODBUS_USEROBJECT_3_NAME
+  MB_ObjectInit(&MB_DEVID.User[3],   MODBUS_USEROBJECT_3_NAME);      
+#endif
+#ifdef MODBUS_USEROBJECT_4_NAME
+  MB_ObjectInit(&MB_DEVID.User[4],   MODBUS_USEROBJECT_4_NAME);      
+#endif
+#ifdef MODBUS_USEROBJECT_5_NAME
+  MB_ObjectInit(&MB_DEVID.User[5],   MODBUS_USEROBJECT_5_NAME);      
+#endif
+#ifdef MODBUS_USEROBJECT_6_NAME
+  MB_ObjectInit(&MB_DEVID.User[6],   MODBUS_USEROBJECT_6_NAME);      
+#endif
+#ifdef MODBUS_USEROBJECT_7_NAME
+  MB_ObjectInit(&MB_DEVID.User[7],   MODBUS_USEROBJECT_7_NAME);      
+#endif
+#ifdef MODBUS_USEROBJECT_8_NAME
+  MB_ObjectInit(&MB_DEVID.User[8],   MODBUS_USEROBJECT_8_NAME);      
+#endif
+#ifdef MODBUS_USEROBJECT_9_NAME
+  MB_ObjectInit(&MB_DEVID.User[9],   MODBUS_USEROBJECT_9_NAME);      
+#endif
+#ifdef MODBUS_USEROBJECT_10_NAME
+  MB_ObjectInit(&MB_DEVID.User[10],   MODBUS_USEROBJECT_10_NAME);    
+#endif
+#ifdef MODBUS_USEROBJECT_11_NAME
+  MB_ObjectInit(&MB_DEVID.User[11],   MODBUS_USEROBJECT_11_NAME);    
+#endif
+#ifdef MODBUS_USEROBJECT_12_NAME
+  MB_ObjectInit(&MB_DEVID.User[12],   MODBUS_USEROBJECT_12_NAME);    
+#endif
+#ifdef MODBUS_USEROBJECT_13_NAME
+  MB_ObjectInit(&MB_DEVID.User[13],   MODBUS_USEROBJECT_13_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_14_NAME
+  MB_ObjectInit(&MB_DEVID.User[14],   MODBUS_USEROBJECT_14_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_15_NAME
+  MB_ObjectInit(&MB_DEVID.User[15],   MODBUS_USEROBJECT_15_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_16_NAME
+  MB_ObjectInit(&MB_DEVID.User[16],   MODBUS_USEROBJECT_16_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_17_NAME
+  MB_ObjectInit(&MB_DEVID.User[17],   MODBUS_USEROBJECT_17_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_18_NAME
+  MB_ObjectInit(&MB_DEVID.User[18],   MODBUS_USEROBJECT_18_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_19_NAME
+  MB_ObjectInit(&MB_DEVID.User[19],   MODBUS_USEROBJECT_19_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_20_NAME
+  MB_ObjectInit(&MB_DEVID.User[20],   MODBUS_USEROBJECT_20_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_21_NAME
+  MB_ObjectInit(&MB_DEVID.User[21],   MODBUS_USEROBJECT_21_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_22_NAME
+  MB_ObjectInit(&MB_DEVID.User[22],   MODBUS_USEROBJECT_22_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_23_NAME
+  MB_ObjectInit(&MB_DEVID.User[23],   MODBUS_USEROBJECT_23_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_24_NAME
+  MB_ObjectInit(&MB_DEVID.User[24],   MODBUS_USEROBJECT_24_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_25_NAME
+  MB_ObjectInit(&MB_DEVID.User[25],   MODBUS_USEROBJECT_25_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_26_NAME
+  MB_ObjectInit(&MB_DEVID.User[26],   MODBUS_USEROBJECT_26_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_27_NAME
+  MB_ObjectInit(&MB_DEVID.User[27],   MODBUS_USEROBJECT_27_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_28_NAME
+  MB_ObjectInit(&MB_DEVID.User[28],   MODBUS_USEROBJECT_28_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_29_NAME
+  MB_ObjectInit(&MB_DEVID.User[29],   MODBUS_USEROBJECT_29_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_30_NAME
+  MB_ObjectInit(&MB_DEVID.User[30],   MODBUS_USEROBJECT_30_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_31_NAME
+  MB_ObjectInit(&MB_DEVID.User[31],   MODBUS_USEROBJECT_31_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_32_NAME
+  MB_ObjectInit(&MB_DEVID.User[32],   MODBUS_USEROBJECT_32_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_33_NAME
+  MB_ObjectInit(&MB_DEVID.User[33],   MODBUS_USEROBJECT_33_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_34_NAME
+  MB_ObjectInit(&MB_DEVID.User[34],   MODBUS_USEROBJECT_34_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_35_NAME
+  MB_ObjectInit(&MB_DEVID.User[35],   MODBUS_USEROBJECT_35_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_36_NAME
+  MB_ObjectInit(&MB_DEVID.User[36],   MODBUS_USEROBJECT_36_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_37_NAME
+  MB_ObjectInit(&MB_DEVID.User[37],   MODBUS_USEROBJECT_37_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_38_NAME
+  MB_ObjectInit(&MB_DEVID.User[38],   MODBUS_USEROBJECT_38_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_39_NAME
+  MB_ObjectInit(&MB_DEVID.User[39],   MODBUS_USEROBJECT_39_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_40_NAME
+  MB_ObjectInit(&MB_DEVID.User[40],   MODBUS_USEROBJECT_40_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_41_NAME
+  MB_ObjectInit(&MB_DEVID.User[41],   MODBUS_USEROBJECT_41_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_42_NAME
+  MB_ObjectInit(&MB_DEVID.User[42],   MODBUS_USEROBJECT_42_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_43_NAME
+  MB_ObjectInit(&MB_DEVID.User[43],   MODBUS_USEROBJECT_43_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_44_NAME
+  MB_ObjectInit(&MB_DEVID.User[44],   MODBUS_USEROBJECT_44_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_45_NAME
+  MB_ObjectInit(&MB_DEVID.User[45],   MODBUS_USEROBJECT_45_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_46_NAME
+  MB_ObjectInit(&MB_DEVID.User[46],   MODBUS_USEROBJECT_46_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_47_NAME
+  MB_ObjectInit(&MB_DEVID.User[47],   MODBUS_USEROBJECT_47_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_48_NAME
+  MB_ObjectInit(&MB_DEVID.User[48],   MODBUS_USEROBJECT_48_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_49_NAME
+  MB_ObjectInit(&MB_DEVID.User[49],   MODBUS_USEROBJECT_49_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_50_NAME
+  MB_ObjectInit(&MB_DEVID.User[50],   MODBUS_USEROBJECT_50_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_51_NAME
+  MB_ObjectInit(&MB_DEVID.User[51],   MODBUS_USEROBJECT_51_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_52_NAME
+  MB_ObjectInit(&MB_DEVID.User[52],   MODBUS_USEROBJECT_52_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_53_NAME
+  MB_ObjectInit(&MB_DEVID.User[53],   MODBUS_USEROBJECT_53_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_54_NAME
+  MB_ObjectInit(&MB_DEVID.User[54],   MODBUS_USEROBJECT_54_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_55_NAME
+  MB_ObjectInit(&MB_DEVID.User[55],   MODBUS_USEROBJECT_55_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_56_NAME
+  MB_ObjectInit(&MB_DEVID.User[56],   MODBUS_USEROBJECT_56_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_57_NAME
+  MB_ObjectInit(&MB_DEVID.User[57],   MODBUS_USEROBJECT_57_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_58_NAME
+  MB_ObjectInit(&MB_DEVID.User[58],   MODBUS_USEROBJECT_58_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_59_NAME
+  MB_ObjectInit(&MB_DEVID.User[59],   MODBUS_USEROBJECT_59_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_60_NAME
+  MB_ObjectInit(&MB_DEVID.User[60],   MODBUS_USEROBJECT_60_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_61_NAME
+  MB_ObjectInit(&MB_DEVID.User[61],   MODBUS_USEROBJECT_61_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_62_NAME
+  MB_ObjectInit(&MB_DEVID.User[62],   MODBUS_USEROBJECT_62_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_63_NAME
+  MB_ObjectInit(&MB_DEVID.User[63],   MODBUS_USEROBJECT_63_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_64_NAME
+  MB_ObjectInit(&MB_DEVID.User[64],   MODBUS_USEROBJECT_64_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_65_NAME
+  MB_ObjectInit(&MB_DEVID.User[65],   MODBUS_USEROBJECT_65_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_66_NAME
+  MB_ObjectInit(&MB_DEVID.User[66],   MODBUS_USEROBJECT_66_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_67_NAME
+  MB_ObjectInit(&MB_DEVID.User[67],   MODBUS_USEROBJECT_67_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_68_NAME
+  MB_ObjectInit(&MB_DEVID.User[68],   MODBUS_USEROBJECT_68_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_69_NAME
+  MB_ObjectInit(&MB_DEVID.User[69],   MODBUS_USEROBJECT_69_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_70_NAME
+  MB_ObjectInit(&MB_DEVID.User[70],   MODBUS_USEROBJECT_70_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_71_NAME
+  MB_ObjectInit(&MB_DEVID.User[71],   MODBUS_USEROBJECT_71_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_72_NAME
+  MB_ObjectInit(&MB_DEVID.User[72],   MODBUS_USEROBJECT_72_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_73_NAME
+  MB_ObjectInit(&MB_DEVID.User[73],   MODBUS_USEROBJECT_73_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_74_NAME
+  MB_ObjectInit(&MB_DEVID.User[74],   MODBUS_USEROBJECT_74_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_75_NAME
+  MB_ObjectInit(&MB_DEVID.User[75],   MODBUS_USEROBJECT_75_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_76_NAME
+  MB_ObjectInit(&MB_DEVID.User[76],   MODBUS_USEROBJECT_76_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_77_NAME
+  MB_ObjectInit(&MB_DEVID.User[77],   MODBUS_USEROBJECT_77_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_78_NAME
+  MB_ObjectInit(&MB_DEVID.User[78],   MODBUS_USEROBJECT_78_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_79_NAME
+  MB_ObjectInit(&MB_DEVID.User[79],   MODBUS_USEROBJECT_79_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_80_NAME
+  MB_ObjectInit(&MB_DEVID.User[80],   MODBUS_USEROBJECT_80_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_81_NAME
+  MB_ObjectInit(&MB_DEVID.User[81],   MODBUS_USEROBJECT_81_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_82_NAME
+  MB_ObjectInit(&MB_DEVID.User[82],   MODBUS_USEROBJECT_82_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_83_NAME
+  MB_ObjectInit(&MB_DEVID.User[83],   MODBUS_USEROBJECT_83_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_84_NAME
+  MB_ObjectInit(&MB_DEVID.User[84],   MODBUS_USEROBJECT_84_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_85_NAME
+  MB_ObjectInit(&MB_DEVID.User[85],   MODBUS_USEROBJECT_85_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_86_NAME
+  MB_ObjectInit(&MB_DEVID.User[86],   MODBUS_USEROBJECT_86_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_87_NAME
+  MB_ObjectInit(&MB_DEVID.User[87],   MODBUS_USEROBJECT_87_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_88_NAME
+  MB_ObjectInit(&MB_DEVID.User[88],   MODBUS_USEROBJECT_88_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_89_NAME
+  MB_ObjectInit(&MB_DEVID.User[89],   MODBUS_USEROBJECT_89_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_90_NAME
+  MB_ObjectInit(&MB_DEVID.User[90],   MODBUS_USEROBJECT_90_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_91_NAME
+  MB_ObjectInit(&MB_DEVID.User[91],   MODBUS_USEROBJECT_91_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_92_NAME
+  MB_ObjectInit(&MB_DEVID.User[92],   MODBUS_USEROBJECT_92_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_93_NAME
+  MB_ObjectInit(&MB_DEVID.User[93],   MODBUS_USEROBJECT_93_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_94_NAME
+  MB_ObjectInit(&MB_DEVID.User[94],   MODBUS_USEROBJECT_94_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_95_NAME
+  MB_ObjectInit(&MB_DEVID.User[95],   MODBUS_USEROBJECT_95_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_96_NAME
+  MB_ObjectInit(&MB_DEVID.User[96],   MODBUS_USEROBJECT_96_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_97_NAME
+  MB_ObjectInit(&MB_DEVID.User[97],   MODBUS_USEROBJECT_97_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_98_NAME
+  MB_ObjectInit(&MB_DEVID.User[98],   MODBUS_USEROBJECT_98_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_99_NAME
+  MB_ObjectInit(&MB_DEVID.User[99],   MODBUS_USEROBJECT_99_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_100_NAME
+  MB_ObjectInit(&MB_DEVID.User[100],   MODBUS_USEROBJECT_100_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_101_NAME
+  MB_ObjectInit(&MB_DEVID.User[101],   MODBUS_USEROBJECT_101_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_102_NAME
+  MB_ObjectInit(&MB_DEVID.User[102],   MODBUS_USEROBJECT_102_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_103_NAME
+  MB_ObjectInit(&MB_DEVID.User[103],   MODBUS_USEROBJECT_103_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_104_NAME
+  MB_ObjectInit(&MB_DEVID.User[104],   MODBUS_USEROBJECT_104_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_105_NAME
+  MB_ObjectInit(&MB_DEVID.User[105],   MODBUS_USEROBJECT_105_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_106_NAME
+  MB_ObjectInit(&MB_DEVID.User[106],   MODBUS_USEROBJECT_106_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_107_NAME
+  MB_ObjectInit(&MB_DEVID.User[107],   MODBUS_USEROBJECT_107_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_108_NAME
+  MB_ObjectInit(&MB_DEVID.User[108],   MODBUS_USEROBJECT_108_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_109_NAME
+  MB_ObjectInit(&MB_DEVID.User[109],   MODBUS_USEROBJECT_109_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_110_NAME
+  MB_ObjectInit(&MB_DEVID.User[110],   MODBUS_USEROBJECT_110_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_111_NAME
+  MB_ObjectInit(&MB_DEVID.User[111],   MODBUS_USEROBJECT_111_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_112_NAME
+  MB_ObjectInit(&MB_DEVID.User[112],   MODBUS_USEROBJECT_112_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_113_NAME
+  MB_ObjectInit(&MB_DEVID.User[113],   MODBUS_USEROBJECT_113_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_114_NAME
+  MB_ObjectInit(&MB_DEVID.User[114],   MODBUS_USEROBJECT_114_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_115_NAME
+  MB_ObjectInit(&MB_DEVID.User[115],   MODBUS_USEROBJECT_115_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_116_NAME
+  MB_ObjectInit(&MB_DEVID.User[116],   MODBUS_USEROBJECT_116_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_117_NAME
+  MB_ObjectInit(&MB_DEVID.User[117],   MODBUS_USEROBJECT_117_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_118_NAME
+  MB_ObjectInit(&MB_DEVID.User[118],   MODBUS_USEROBJECT_118_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_119_NAME
+  MB_ObjectInit(&MB_DEVID.User[119],   MODBUS_USEROBJECT_119_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_120_NAME
+  MB_ObjectInit(&MB_DEVID.User[120],   MODBUS_USEROBJECT_120_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_121_NAME
+  MB_ObjectInit(&MB_DEVID.User[121],   MODBUS_USEROBJECT_121_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_122_NAME
+  MB_ObjectInit(&MB_DEVID.User[122],   MODBUS_USEROBJECT_122_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_123_NAME
+  MB_ObjectInit(&MB_DEVID.User[123],   MODBUS_USEROBJECT_123_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_124_NAME
+  MB_ObjectInit(&MB_DEVID.User[124],   MODBUS_USEROBJECT_124_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_125_NAME
+  MB_ObjectInit(&MB_DEVID.User[125],   MODBUS_USEROBJECT_125_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_126_NAME
+  MB_ObjectInit(&MB_DEVID.User[126],   MODBUS_USEROBJECT_126_NAME);
+#endif
+#ifdef MODBUS_USEROBJECT_127_NAME
+  MB_ObjectInit(&MB_DEVID.User[127],   MODBUS_USEROBJECT_127_NAME);
+#endif
+}
+
--- a/Modbus/Src/modbus_holdregs.c
+++ b/Modbus/Src/modbus_holdregs.c
@@ -0,0 +1,97 @@
+/**
+******************************************************************************
+* @file modbus_holdregs.c
+* @brief Реализация работы с регистрами хранения Modbus
+******************************************************************************
+* @details
+Модуль обработки команд для holding registers (регистров хранения):
+- Чтение множественных регистров (0x03) - копирование данных в буфер ответа
+- Запись одиночного регистра (0x06) - прямая запись значения
+- Запись множественных регистров (0x10) - пакетная запись из буфера
+
+@section Валидация данных:
+- Проверка соответствия количества байт и регистров
+Валидация адресов через MB_DefineRegistersAddress()
+- Обработка исключений при некорректных запросах
+
+@section Echo-ответы:
+При успешной записи формируется echo-ответ с теми же данными,
+что были в запросе (для функций 0x05, 0x06, 0x0F, 0x10).
+******************************************************************************/
+#include "modbus_inputregs.h"
+
+
+/**
+  * @brief    Proccess command Read Holding Registers (03 - 0x03).
+  * @param    modbus_msg        Указатель на структуру собщения modbus.
+  * @return   fMessageHandled   Статус о результате обработки комманды.
+  * @details  Обработка команды Read Holding Registers.
+  */
+uint8_t MB_Proccess_Read_Hold_Regs(RS_MsgTypeDef *modbus_msg)
+{
+  //---------CHECK FOR ERRORS---------- 
+  // get origin address for data
+  uint16_t *pHoldRegs;      
+  modbus_msg->Except_Code = MB_DefineRegistersAddress(&pHoldRegs, modbus_msg->Addr, modbus_msg->Qnt, RegisterType_Holding); // определение адреса регистров
+  if(modbus_msg->Except_Code != NO_ERRORS)
+    return 0;
+  
+
+  //-----------READING REGS------------
+  // setup output message data size 
+  modbus_msg->ByteCnt = modbus_msg->Qnt*2; // *2 because we transmit 8 bits, not 16 bits
+  // read data
+  int i;
+  for (i = 0; i<modbus_msg->Qnt; i++)
+  {
+    modbus_msg->DATA[i] = *(pHoldRegs++);
+  } 
+  return 1;
+}
+
+/**
+  * @brief    Proccess command Write Single Register (06 - 0x06).
+  * @param    modbus_msg        Указатель на структуру собщения modbus.
+  * @return   fMessageHandled   Статус о результате обработки комманды.
+  * @details  Обработка команды Write Single Register.
+  */
+uint8_t MB_Proccess_Write_Single_Reg(RS_MsgTypeDef *modbus_msg)
+{ 
+  // get origin address for data
+  uint16_t *pHoldRegs;      
+  modbus_msg->Except_Code = MB_DefineRegistersAddress(&pHoldRegs, modbus_msg->Addr, 1, RegisterType_Holding); // определение адреса регистров
+  if(modbus_msg->Except_Code != NO_ERRORS)
+    return 0;
+  
+  //-----------WRITTING REG------------ 
+  *(pHoldRegs) = modbus_msg->Qnt;
+  return 1;
+}
+
+/**
+  * @brief    Proccess command Write Multiple Registers (16 - 0x10).
+  * @param    modbus_msg        Указатель на структуру собщения modbus.
+  * @return   fMessageHandled   Статус о результате обработки комманды.
+  * @details  Обработка команды Write Multiple Registers.
+  */
+uint8_t MB_Proccess_Write_Miltuple_Regs(RS_MsgTypeDef *modbus_msg)
+{
+  //---------CHECK FOR ERRORS----------
+  if (modbus_msg->Qnt*2 != modbus_msg->ByteCnt)
+  { // if quantity and bytes count arent match
+    modbus_msg->Except_Code = 3;
+    return 0;
+  } 
+  // get origin address for data
+  uint16_t *pHoldRegs;      
+  modbus_msg->Except_Code = MB_DefineRegistersAddress(&pHoldRegs, modbus_msg->Addr, modbus_msg->Qnt, RegisterType_Holding); // определение адреса регистров
+  if(modbus_msg->Except_Code != NO_ERRORS)
+    return 0;
+  
+  //-----------WRITTING REGS----------- 
+  for (int i = 0; i<modbus_msg->Qnt; i++)
+  {
+    *(pHoldRegs++) = modbus_msg->DATA[i];
+  }
+  return 1;
+}
--- a/Modbus/Src/modbus_inputregs.c
+++ b/Modbus/Src/modbus_inputregs.c
@@ -0,0 +1,45 @@
+/**
+******************************************************************************
+* @file modbus_inputregs.c
+* @brief Реализация работы с входными регистрами Modbus
+******************************************************************************
+* @details
+Модуль обработки команды чтения input registers (0x04):
+- Чтение множественных входных регистров
+Копирование данных из структур устройства в буфер ответа
+- Поддержка знаковых и беззнаковых значений
+******************************************************************************/
+
+#include "modbus_inputregs.h"
+
+
+/**
+  * @brief    Proccess command Read Input Registers (04 - 0x04).
+  * @param    modbus_msg        Указатель на структуру собщения modbus.
+  * @return   fMessageHandled   Статус о результате обработки комманды.
+  * @details  Обработка команды Read Input Registers.
+  */
+uint8_t MB_Proccess_Read_Input_Regs(RS_MsgTypeDef *modbus_msg)
+{
+  //---------CHECK FOR ERRORS---------- 
+  // get origin address for data
+  uint16_t *pInRegs;      
+  modbus_msg->Except_Code = MB_DefineRegistersAddress(&pInRegs, modbus_msg->Addr, modbus_msg->Qnt, RegisterType_Input); // определение адреса регистров
+  if(modbus_msg->Except_Code != NO_ERRORS)
+    return 0;
+  
+
+  //-----------READING REGS------------
+  // setup output message data size 
+  modbus_msg->ByteCnt = modbus_msg->Qnt*2; // *2 because we transmit 8 bits, not 16 bits
+  // read data
+  int i;
+  for (i = 0; i<modbus_msg->Qnt; i++)
+  {
+    if(*((int16_t *)pInRegs) > 0)
+      modbus_msg->DATA[i] = (*pInRegs++);
+    else
+      modbus_msg->DATA[i] = (*pInRegs++);
+  } 
+  return 1;
+}
--- a/Modbus/Src/rs_message.c
+++ b/Modbus/Src/rs_message.c
@@ -0,0 +1,507 @@
+/**
+******************************************************************************
+* @file rs_message.c
+* @brief Реализация протоколов обмена по RS/UART
+******************************************************************************
+* @details
+Модуль реализует асинхронный обмен сообщениями через UART с использованием:
+- Прерываний по приему/передаче
+- Детектирования конца фрейма по IDLE линии
+- Таймаутов через таймер
+- Двухстадийного приема (заголовок + данные)
+
+@section Архитектура:
+В режиме слейв:
+  - Инициализация приема с сообщения с максимальным размером MSG_SIZE_MAX
+  - При срабатывании прерывания IDLE - обработка полученного сообщения
+В режиме мастер (пока не реализовано):
+  - Отправка запроса и переход в режим приема сообщения с максимальным размером MSG_SIZE_MAX
+  - При срабатывании прерывания IDLE - обработка полученного ответа
+  
+@section Необходимые обработчики:
+- RS_UART_Handler() в UARTx_IRQHandler вместо HAL_UART_IRQHandler()
+- RS_TIM_Handler() в TIMx_IRQHandler вместо HAL_TIM_IRQHandler()
+******************************************************************************/
+#include "rs_message.h"
+
+uint8_t RS_Buffer[MSG_SIZE_MAX]; // uart buffer
+
+extern void RS_UART_Init(void);
+extern void RS_UART_DeInit(UART_HandleTypeDef *huart);
+extern void RS_TIM_Init(void);
+extern void RS_TIM_DeInit(TIM_HandleTypeDef *htim);
+
+//-------------------------------------------------------------------
+//-------------------------GENERAL FUNCTIONS-------------------------
+/**
+  * @brief  Start receive IT.
+  * @param  hRS     Указатель на хендлер RS.
+  * @param  RS_msg  Указатель на структуру сообщения.
+  * @return RS_RES  Статус о состоянии RS после инициализации приема.
+  */
+RS_StatusTypeDef RS_Receive_IT(RS_HandleTypeDef *hRS, RS_MsgTypeDef *RS_msg)
+{
+  RS_StatusTypeDef RS_RES = 0;
+  HAL_StatusTypeDef uart_res = 0;
+  
+  //-------------CHECK RS LINE----------------
+  // check that receive isnt busy
+  if( RS_Is_RX_Busy(hRS) ) // if tx busy - return busy status
+    return RS_BUSY; 
+  
+  //-----------INITIALIZE RECEIVE-------------
+  // if all OK: start receiving
+  RS_EnableReceive();
+  RS_Set_Busy(hRS);             // set RS busy  
+  RS_Set_RX_Flags(hRS);         // initialize flags for receive
+  hRS->pMessagePtr = RS_msg;    // set pointer to message structire for filling it from UARTHandler fucntions
+  if(!hRS->f.RX_Continue)       // if not continue receiving
+    hRS->RS_Message_Size = 0;   // set ptr to start buffer
+  
+  // start receiving
+  __HAL_UART_ENABLE_IT(hRS->huart, UART_IT_IDLE);
+	uart_res = HAL_UART_Receive_IT(hRS->huart, &hRS->pBufferPtr[hRS->RS_Message_Size], MSG_SIZE_MAX); // receive until ByteCnt+1 byte, 
+  // then in Callback restart receive for rest bytes  
+  
+  // if receive isnt started - abort RS
+  if(uart_res != HAL_OK)
+  {
+    RS_RES = RS_Abort(hRS, ABORT_RS);
+    printf_rs_err("Failed to start RS receiving...");
+    TrackerCnt_Err(hRS->rs_err);
+  }
+  else
+  {
+    RS_RES = RS_OK;
+    printf_rs("Start Receiving...");
+    TrackerCnt_Ok(hRS->rs_err);
+  }
+  
+  hRS->RS_STATUS = RS_RES;
+  return RS_RES; // returns result of receive init  
+}
+
+/**
+  * @brief  Start transmit IT.
+  * @param  hRS     Указатель на хендлер RS.
+  * @param  RS_msg  Указатель на структуру сообщения.
+  * @return RS_RES  Статус о состоянии RS после инициализации передачи.
+  */
+RS_StatusTypeDef RS_Transmit_IT(RS_HandleTypeDef *hRS, RS_MsgTypeDef *RS_msg)
+{ 
+  RS_StatusTypeDef RS_RES = 0;
+  HAL_StatusTypeDef uart_res = 0;
+  
+  //-------------CHECK RS LINE----------------
+  // check that transmit isnt busy
+  if( RS_Is_TX_Busy(hRS) ) // if tx busy - return busy status
+    return RS_BUSY;
+    // check receive line
+
+  
+  //------------COLLECT MESSAGE---------------
+  RS_RES = RS_Collect_Message(hRS, RS_msg, hRS->pBufferPtr);
+  if (RS_RES != RS_OK) // if message isnt collect - stop RS and return error in RS_RES
+  {// need collect message status, so doesnt write abort to RS_RES
+    RS_Abort(hRS, ABORT_RS);
+    RS_Handle_Receive_Start(hRS, hRS->pMessagePtr); // restart receive
+  }
+  else // if collect successful
+  {
+    
+    //----------INITIALIZE TRANSMIT-------------
+    RS_EnableTransmit();
+//    for(int i = 0; i < hRS->sRS_Timeout; i++);
+    
+    RS_Set_Busy(hRS);             // set RS busy
+    RS_Set_TX_Flags(hRS);         // initialize flags for transmit IT
+    hRS->pMessagePtr = RS_msg;    // set pointer for filling given structure from UARTHandler fucntion
+    if(hRS->RS_Message_Size <= 0)
+    {
+      RS_RES = RS_Abort(hRS, ABORT_RS);
+      TrackerCnt_Err(hRS->rs_err);
+      return RS_ERR;
+    }      
+    // if all OK: start transmitting
+    uart_res = HAL_UART_Transmit_IT(hRS->huart, hRS->pBufferPtr, hRS->RS_Message_Size); 
+    // if transmit isnt started - abort RS
+    if(uart_res != HAL_OK)
+    {
+      RS_RES = RS_Abort(hRS, ABORT_RS);
+      printf_rs_err("Failed to start RS transmitting...");
+      TrackerCnt_Err(hRS->rs_err);
+    }
+    else
+    {
+      RS_RES = RS_OK;
+      printf_rs("Start Transmitting...");
+      TrackerCnt_Ok(hRS->rs_err);
+    }
+  }
+  
+  
+  hRS->RS_STATUS = RS_RES;
+  return RS_RES; // returns result of transmit init   
+}
+
+/** 
+  * @brief  Initialize UART and handle RS stucture.
+  * @param  hRS           Указатель на хендлер RS.
+  * @param  suart         Указатель на структуру с настройками UART.
+  * @param  stim          Указатель на структуру с настройками таймера.
+  * @param  pRS_BufferPtr Указатель на буффер для приема-передачи по UART. Если он NULL, то поставиться библиотечный буфер.
+  * @return RS_RES        Статус о состоянии RS после инициализации.
+  * @note   Инициализация перефирии и структуры для приема-передачи по RS.
+  */
+RS_StatusTypeDef RS_Init(RS_HandleTypeDef *hRS, UART_HandleTypeDef *huart, TIM_HandleTypeDef *htim, uint8_t *pRS_BufferPtr)
+{
+  // check that hRS is defined
+  if (hRS == NULL)
+    return RS_ERR;
+  // check that huart is defined
+  if (huart == NULL) 
+    return RS_ERR;
+  
+  hRS->huart = huart;
+  
+  hRS->htim = htim;
+  
+  if (hRS->sRS_RX_Size_Mode == NULL)
+    return RS_ERR;
+  
+  // check that buffer is defined
+  if (hRS->pBufferPtr == NULL)
+  {
+    hRS->pBufferPtr = RS_Buffer;    // if no - set default
+  }
+  else
+    hRS->pBufferPtr = pRS_BufferPtr; // if yes - set by user
+    
+  return RS_OK;
+}
+
+
+/**
+  * @brief  Abort RS/UART.
+  * @param  hRS         Указатель на хендлер RS.
+  * @param  AbortMode   Выбор, что надо отменить.
+              - ABORT_TX:    Отмена передачи по ЮАРТ, с очищением флагов TX,
+              - ABORT_RX:    Отмена приема по ЮАРТ, с очищением флагов RX,
+              - ABORT_RX_TX: Отмена приема и передачи по ЮАРТ,
+              - ABORT_RS:    Отмена приема-передачи RS, с очищением всей структуры.
+  * @return RS_RES      Статус о состоянии RS после аборта.
+  * @note   Отмена работы UART в целом или отмена приема/передачи RS. 
+            Также очищается хендл hRS.
+  */
+RS_StatusTypeDef RS_Abort(RS_HandleTypeDef *hRS, RS_AbortTypeDef AbortMode)
+{
+  HAL_StatusTypeDef uart_res = 0;
+  
+  if(hRS->htim)
+  {
+    if(hRS->sRS_Timeout)                // if timeout setted
+      HAL_TIM_Base_Stop_IT(hRS->htim);  // stop timeout
+    hRS->htim->Instance->CNT = 0;
+    __HAL_TIM_CLEAR_IT(hRS->htim, TIM_IT_UPDATE);
+  }
+  
+  if((AbortMode&ABORT_RS) == 0x00)
+  { 
+    if((AbortMode&ABORT_RX) == ABORT_RX)
+    {
+      uart_res = HAL_UART_AbortReceive(hRS->huart);   // abort receive
+      RS_Reset_RX_Flags(hRS);
+    }
+    
+    if((AbortMode&ABORT_TX) == ABORT_TX)
+    {
+      uart_res = HAL_UART_AbortTransmit(hRS->huart);  // abort transmit
+      RS_Reset_TX_Flags(hRS);
+    }
+  }
+  else
+  {
+    uart_res = HAL_UART_Abort(hRS->huart);
+    RS_Clear_All(hRS);
+  }
+  hRS->RS_STATUS = RS_ABORTED;
+  return RS_ABORTED;
+}
+
+
+//-------------------------GENERAL FUNCTIONS-------------------------
+//-------------------------------------------------------------------
+
+
+
+//-------------------------------------------------------------------
+//--------------------CALLBACK/HANDLER FUNCTIONS---------------------
+/**
+  * @brief  Handle for starting receive.
+  * @param  hRS     Указатель на хендлер RS.
+  * @param  RS_msg  Указатель на структуру сообщения.
+  * @return RS_RES  Статус о состоянии RS после инициализации приема или окончания общения.
+  * @note   Определяет начинать прием команды/ответа или нет.
+  */
+RS_StatusTypeDef RS_Handle_Receive_Start(RS_HandleTypeDef *hRS, RS_MsgTypeDef *RS_msg)
+{ 
+  RS_StatusTypeDef RS_RES = 0;
+  
+  switch(hRS->sRS_Mode)
+  {
+    case RS_SLAVE_ALWAYS_WAIT:                       // in slave mode with permanent waiting
+      RS_RES = RS_Receive_IT(hRS, RS_msg); break; // start receiving again
+    case RS_SLAVE_TIMEOUT_WAIT:                      // in slave mode with timeout waiting (start receiving cmd by request)
+      RS_Set_Free(hRS);  RS_RES = RS_OK; break;   // end RS communication (set RS unbusy)
+  }
+  
+  if(RS_RES != RS_OK)
+  {
+    TrackerCnt_Err(hRS->rs_err);
+  }
+  
+  return RS_RES;
+}
+/**  
+  * @brief  Handle for starting transmit.
+  * @param  hRS     Указатель на хендлер RS.
+  * @param  RS_msg  Указатель на структуру сообщения.
+  * @return RS_RES  Статус о состоянии RS после инициализации передачи.
+  * @note   Определяет отвечать ли на команду или нет.
+  */
+RS_StatusTypeDef RS_Handle_Transmit_Start(RS_HandleTypeDef *hRS, RS_MsgTypeDef *RS_msg)
+{ 
+  RS_StatusTypeDef RS_RES = 0;
+  
+  switch(hRS->sRS_Mode)
+  {
+    case RS_SLAVE_ALWAYS_WAIT:   // in slave mode always response
+    case RS_SLAVE_TIMEOUT_WAIT:  // transmit response
+      RS_RES = RS_Transmit_IT(hRS, RS_msg); break; 
+  }
+  
+  if(RS_RES != RS_OK)
+  {
+    if(hRS->sRS_Mode < RS_MASTER_START)
+    {
+      RS_Handle_Receive_Start(hRS, RS_msg);
+    }
+    
+    TrackerCnt_Err(hRS->rs_err);
+  }
+  
+  return RS_RES;
+}
+
+/**  
+  * @brief  UART TX Callback: define behaviour after transmiting message.
+  * @param  hRS     Указатель на хендлер RS.
+  * @return RS_RES  Статус о состоянии RS после обработки приема.
+  * @note   Определяет поведение RS после передачи сообщения.
+  */
+RS_StatusTypeDef RS_UART_TxCpltCallback(RS_HandleTypeDef *hRS)
+{
+  RS_StatusTypeDef RS_RES = RS_OK;
+  HAL_StatusTypeDef uart_res = 0;
+  
+  //--------------ENDING TRANSMITTING-------------
+  RS_Set_TX_End(hRS);
+  RS_EnableReceive();
+//  for(int i = 0; i < hRS->sRS_Timeout; i++);
+  
+  //-----------START RECEIVING or END RS----------
+  RS_RES = RS_Handle_Receive_Start(hRS, hRS->pMessagePtr);
+  
+//  if(RS_RES != RS_OK)
+//  {
+//    __NOP();
+//  }
+  return RS_RES;
+}
+
+/**  
+  * @brief  Handler for UART.
+  * @param  hRS     Указатель на хендлер RS.
+  * @note   Обрабатывает ошибки если есть и вызывает RS Коллбеки.
+  *         Добавить вызов этой функции в UARTx_IRQHandler() после HAL_UART_IRQHandler().
+  */
+void RS_UART_Handler(RS_HandleTypeDef *hRS)
+{
+  if(hRS->huart == NULL)
+  {
+    return;
+  }  
+  //-------------CHECK IDLE FLAG FIRST-------------	
+  /* Проверяем флаг IDLE в первую очередь - это гарантирует обработку только после idle */
+  if(__HAL_UART_GET_FLAG(hRS->huart, UART_FLAG_IDLE) && __HAL_UART_GET_IT_SOURCE(hRS->huart, UART_IT_IDLE))
+  {
+    __HAL_UART_CLEAR_IDLEFLAG(hRS->huart); // Важно: очистить флаг IDLE
+    //-------------STANDARD UART HANDLING-------------
+    HAL_UART_IRQHandler(hRS->huart);
+    
+    // Если прием активен и мы получили IDLE - это конец фрейма
+    if(RS_Is_RX_Busy(hRS) && hRS->f.RX_Ongoing)
+    {
+      // Получаем количество фактически принятых байтов
+      hRS->RS_Message_Size += hRS->huart->RxXferSize - hRS->huart->RxXferCount;
+      
+      
+      if(hRS->RS_Message_Size > 0)
+      {        
+        // Принудительно завершаем прием (получили сообщение)
+        HAL_UART_AbortReceive(hRS->huart);   // abort receive      
+        
+        // Завершаем прием в нашей структуре
+        RS_Set_RX_End(hRS);
+        
+        // Парсим наше сообщение
+        RS_StatusTypeDef parse_res = RS_Parse_Message(hRS, hRS->pMessagePtr, hRS->pBufferPtr);
+
+        // Проверяем адрес Modbus перед обработкой
+        if(hRS->pMessagePtr->MbAddr != hRS->ID) 
+        {
+          // Чужое сообщение - игнорируем и начинаем новый прием
+          RS_Abort(hRS, ABORT_RX);
+          RS_Handle_Receive_Start(hRS, hRS->pMessagePtr);
+          return;
+        }
+        
+        
+        
+        // Если сообещине принято корректно - отвечаем на него
+        if(parse_res != RS_SKIP) 
+        {
+          if(hRS->htim)
+          {
+            // Останавливаем таймаут
+            if(hRS->sRS_Timeout)								
+              HAL_TIM_Base_Stop_IT(hRS->htim);
+          }
+          hRS->lastPacketTick = uwTick;
+          RS_Response(hRS, hRS->pMessagePtr);
+        }
+        else
+        {
+          RS_Handle_Receive_Start(hRS, hRS->pMessagePtr); // если сообщение пришло не полностью - продолжаем прием до таймаута
+        }
+      }
+    }
+    return; // Выходим после обработки IDLE
+  }
+  else
+  {
+    //-------------STANDARD UART HANDLING-------------
+    HAL_UART_IRQHandler(hRS->huart);
+  }
+  
+  
+  //-------------CALL RS CALLBACKS------------  
+  /* IF NO ERROR OCCURS */
+  if(hRS->huart->ErrorCode == 0) 
+  {
+   
+    if(hRS->htim)
+    {
+      hRS->htim->Instance->CNT = 0; // reset cnt;
+      /* Start timeout при получении первого байта */
+      if(hRS->sRS_Timeout)                // if timeout setted
+        if((hRS->huart->RxXferCount+1 == hRS->huart->RxXferSize) && RS_Is_RX_Busy(hRS)) // if first byte is received and receive is active
+        {
+          hRS->htim->Instance->ARR = hRS->sRS_Timeout;
+          HAL_TIM_Base_Start_IT(hRS->htim);
+          RS_Set_RX_Active_Flags(hRS);
+        }
+    }
+    
+    /* RX Callback - теперь НЕ вызываем здесь, ждем IDLE */
+    
+    /* TX Callback */
+    if ((hRS->huart->TxXferCount == 0U) && RS_Is_TX_Busy(hRS) &&  // if all bytes are transmited and transmit is active
+          hRS->huart->gState != HAL_UART_STATE_BUSY_TX)           // also check that receive "REALLY" isnt busy
+      RS_UART_TxCpltCallback(hRS);
+      
+    /* NOTE: RX Callback больше не вызывается здесь - ждем IDLE для гарантии конца фрейма */
+  }
+  //----------------ERRORS HANDLER----------------
+  else
+  {
+    //TrackerCnt_Err(hRS->rs_err);
+    /* de-init uart transfer */
+    RS_Abort(hRS, ABORT_RS);
+    RS_Handle_Receive_Start(hRS, hRS->pMessagePtr);
+        
+    // later, maybe, will be added specific handlers for err  
+  }
+}
+
+
+/**
+  * @brief  Handler for TIM.
+  * @param  hRS     Указатель на хендлер RS.
+  * @note   Попадание сюда = таймаут и перезапуск RS приема
+  *         Добавить вызов этой функции в TIMx_IRQHandler() после HAL_TIM_IRQHandler().
+  */
+void RS_TIM_Handler(RS_HandleTypeDef *hRS)
+{
+  if(hRS->htim == NULL)
+  {
+    return;
+  }
+  HAL_TIM_IRQHandler(hRS->htim);
+  
+	RS_Abort(hRS, ABORT_RS);
+  
+	if(hRS->pMessagePtr->MbAddr == hRS->ID) // ошибка если таймаут по нашему сообщению
+		TrackerCnt_Err(hRS->rs_err);
+  
+  RS_Handle_Receive_Start(hRS, hRS->pMessagePtr);
+}
+//--------------------CALLBACK/HANDLER FUNCTIONS---------------------
+//-------------------------------------------------------------------
+
+
+
+//-------------------------------------------------------------------
+//--------------WEAK PROTOTYPES FOR PROCESSING MESSAGE---------------
+/** 
+  * @brief  Пользовательская функция для ответа на запрос по UART.
+  * @param  hRS     Указатель на хендлер RS.
+  * @param  RS_msg  Указатель на структуру сообщения.
+  * @return RS_RES  Статус о результате ответа на комманду.
+  * @note   Обработка принятой комманды и ответ на неё.
+  */
+__weak RS_StatusTypeDef RS_Response(RS_HandleTypeDef *hRS, RS_MsgTypeDef *RS_msg)
+{
+  /* Redefine function for user purposes */
+  return RS_ERR;
+}
+
+/** 
+  * @brief  Собрать сообщение в буфер UART.
+  * @param  hRS           Указатель на хендлер RS.
+  * @param  RS_msg        Указатель на структуру сообщения.
+  * @param  msg_uart_buff Указатель на буффер UART.
+  * @return RS_RES        Статус о результате заполнения буфера.
+  * @note   Заполнение буффера UART из структуры сообщения.
+  */
+__weak RS_StatusTypeDef RS_Collect_Message(RS_HandleTypeDef *hRS, RS_MsgTypeDef *RS_msg, uint8_t *msg_uart_buff)
+{
+  /* Redefine function for user purposes */
+  return RS_ERR;
+}
+
+/** 
+  * @brief  Разпарсить сообщение из буфера UART.
+  * @param  hRS           Указатель на хендлер RS.
+  * @param  RS_msg        Указатель на структуру сообщения.
+  * @param  msg_uart_buff Указатель на буффер UART.
+  * @return RS_RES        Статус о результате заполнения структуры.
+  * @note   Заполнение структуры сообщения из буффера UART.
+  */
+__weak RS_StatusTypeDef RS_Parse_Message(RS_HandleTypeDef *hRS, RS_MsgTypeDef *RS_msg, uint8_t *msg_uart_buff)
+{
+  /* Redefine function for user purposes */
+  return RS_ERR;
+}
+//--------------WEAK PROTOTYPES FOR PROCESSING MESSAGE---------------
+//-------------------------------------------------------------------
--- a/Modbus/modbus.c
+++ b/Modbus/modbus.c
@@ -1,1041 +0,0 @@
-/** 
-**************************************************************************
-* @file   modbus.c
-* @brief  Модуль для реализации MODBUS.
-**************************************************************************  
-* @details Файл содержит реализацию функций работы с Modbus, включая:
-*          - доступ к coils и registers;
-*          - обработку команд протокола;
-*          - взаимодействие с RS (UART);
-*          - инициализацию.
-*
-* @section Функции и макросы
-*
-* ### Доступ к coils:
-* - MB_Set_Coil_Local()        — Установить coil по локальному адресу.
-* - MB_Reset_Coil_Local()      — Сбросить coil по локальному адресу.
-* - MB_Toogle_Coil_Local()     — Инвертировать coil по локальному адресу.
-* - MB_Read_Coil_Local()       — Прочитать coil по локальному адресу.
-* - MB_Write_Coil_Global()     — Установить/сбросить coil по глобальному адресу.
-* - MB_Read_Coil_Global()      — Прочитать coil по глобальному адресу.
-*
-* ### Обработка команд Modbus:
-* - MB_DefineRegistersAddress() — Определить начальный адрес регистра.
-* - MB_DefineCoilsAddress()     — Определить начальный адрес coils.
-* - MB_Check_Address_For_Arr()  — Проверить, принадлежит ли адрес массиву.
-* - Основные команды Modbus:
-*    - MB_Proccess_Read_Coils()
-*    - MB_Proccess_Read_Hold_Regs()
-*    - MB_Proccess_Write_Single_Coil()
-*    - MB_Proccess_Write_Single_Reg()
-*    - MB_Write_Miltuple_Coils()
-*    - MB_Proccess_Write_Miltuple_Regs()
-*
-* ### Функции для работы с RS (UART):
-* - RS_Parse_Message() / RS_Collect_Message() — Парсинг и сборка сообщения.
-* - RS_Response()                             — Отправка ответа.
-* - RS_Define_Size_of_RX_Message()            — Определение размера принимаемого сообщения.
-* - RS_Init()                                 — Инициализация UART.
-*
-* ### Инициализация:
-* - MODBUS_FirstInit()                        — Инициализация модуля Modbus.
-*
-* @section Структура данных Modbus
-*
-* #### Holding/Input Registers:
-* - Регистры — 16-битные слова. Доступ к регистрам осуществляется через указатель.  
-* Таким образом, сами регистры могут представлять собой как массив так и структуру.
-*
-* #### Coils:
-* - Coils — это биты, упакованные в 16-битные слова. Доступ к коилам осуществляется через указатель.  
-* Таким образом, сами коилы могут представлять собой как массив так и структуру.
-*
-* @section Инструкция по подключению
-* Для корректной работы надо подключить обработчики RS_UART_Handler(), RS_TIM_Handler(),
-* в соответствубщие низкоуровневые прерывания UART_IRQHandler, TIM_IRQHandler. После HAL'овского обработчика
-* 
-* Также необходимо в modbus_config.h настроить дефайны для нужной работы UART
-* После для запуска Modbus:
-* @verbatim
-  //----------------Прием модбас----------------//
-  #include "rs_message.h"
-  MODBUS_FirstInit();
-  RS_Receive_IT(&hmodbus1, &MODBUS_MSG);
-* @endverbatim
-*
-******************************************************************************/
-
-#include "rs_message.h"
-uint32_t dbg_temp, dbg_temp2, dbg_temp3; // for debug
-/* MODBUS HANDLES */
-extern UART_HandleTypeDef rs_huart;
-extern TIM_HandleTypeDef rs_htim;
-RS_HandleTypeDef hmodbus1;
-
-/* DEFINE REGISTERS/COILS */
-MB_DeviceIdentificationTypeDef MB_DEVID;
-MB_DataStructureTypeDef MB_DATA = {0};;
-RS_MsgTypeDef MODBUS_MSG;
-
-//-------------------------------------------------------------------
-//-----------------------------FOR USER------------------------------
-/** 
-  * @brief    First set up of MODBUS.
-  * @details  Первый инит модбас. Заполняет структуры и инициализирует таймер и юарт для общения по модбас.
-  * @note     This called from main
-  */
-void MODBUS_FirstInit(void)
-{
-  MB_DeviceInentificationInit();
-  //-----------SETUP MODBUS-------------
-  // set up modbus: MB_RX_Size_NotConst and Timeout enable
-  hmodbus1.ID = MODBUS_DEVICE_ID;
-  hmodbus1.sRS_Timeout = MODBUS_TIMEOUT;
-  hmodbus1.sRS_Mode = SLAVE_ALWAYS_WAIT;
-  hmodbus1.sRS_RX_Size_Mode = RS_RX_Size_NotConst;
-  
-  // INIT
-  hmodbus1.RS_STATUS = RS_Init(&hmodbus1, &rs_huart, &rs_htim, 0);  
-
-  RS_EnableReceive();
-}
-/** 
-  * @brief    Set or Reset Coil at its global address.
-  * @param    Addr          - адрес коила.
-  * @param    WriteVal      - Что записать в коил: 0 или 1.
-  * @return   ExceptionCode - Код исключения если коила по адресу не существует, и NO_ERRORS если все ок.
-  *
-  * @details  Позволяет обратиться к любому коилу по его глобальному адрессу.
-              Вне зависимости от того как коилы размещены в памяти.
-  */
-MB_ExceptionTypeDef MB_Write_Coil_Global(uint16_t Addr, MB_CoilsOpTypeDef WriteVal)
-{
-  //---------CHECK FOR ERRORS----------
-  MB_ExceptionTypeDef Exception = NO_ERRORS;
-  uint16_t *coils;
-  uint16_t start_shift = 0; // shift in coils register
-  
-  //------------WRITE COIL-------------
-  Exception = MB_DefineCoilsAddress(&coils, Addr, 1, &start_shift, 1);
-  if(Exception == NO_ERRORS)
-  {
-    switch(WriteVal)
-    {
-      case SET_COIL:
-        *coils |= (1<<start_shift);       
-        break;
-        
-      case RESET_COIL:
-        *coils &= ~(1<<start_shift);          
-        break;
-        
-      case TOOGLE_COIL:
-        *coils ^= (1<<start_shift);           
-        break;
-      
-    }   
-  }
-  return Exception;
-}
-
-
-/** 
-  * @brief    Read Coil at its global address.
-  * @param    Addr          - адрес коила.
-  * @param    Exception     - Указатель на переменную для кода исключения, в случа неудачи при чтении.
-  * @return   uint16_t      - Возвращает весь регистр с маской на запрошенном коиле.
-  *
-  * @details  Позволяет обратиться к любому коилу по его глобальному адрессу.
-              Вне зависимости от того как коилы размещены в памяти.
-  */
-uint16_t MB_Read_Coil_Global(uint16_t Addr, MB_ExceptionTypeDef *Exception)
-{
-  //---------CHECK FOR ERRORS----------
-  MB_ExceptionTypeDef Exception_tmp;
-  if(Exception == NULL)             // if exception is not given to func fill it
-    Exception = &Exception_tmp;
-    
-  uint16_t *coils;
-  uint16_t start_shift = 0; // shift in coils register
-  
-  //------------READ COIL--------------
-  *Exception = MB_DefineCoilsAddress(&coils, Addr, 1, &start_shift, 0); 
-  if(*Exception == NO_ERRORS)
-  {
-    return ((*coils)&(1<<start_shift));
-  }
-  else
-  {
-    return 0;
-  }
-}
-
-//-------------------------------------------------------------------
-//----------------FUNCTIONS FOR PROCESSING MESSAGE-------------------
-/** 
-  * @brief    Check is address valid for certain array.
-  * @param    Addr          - начальный адресс.
-  * @param    Qnt           - количество запрашиваемых элементов.
-  * @param    R_ARR_ADDR    - начальный адресс массива R_ARR.
-  * @param    R_ARR_NUMB    - количество элементов в массиве R_ARR.
-  * @return   ExceptionCode - ILLEGAL DATA ADRESS если адресс недействителен, и NO_ERRORS если все ок.
-  *
-  * @details  Позволяет определить, принадлежит ли адресс Addr массиву R_ARR:
-  *           Если адресс Addr находится в диапазоне адрессов массива R_ARR, то возвращаем NO_ERROR.
-  *           Если адресс Addr находится за пределами адрессов массива R_ARR - ILLEGAL_DATA_ADDRESSю.
-  */
-MB_ExceptionTypeDef MB_Check_Address_For_Arr(uint16_t Addr, uint16_t Qnt, uint16_t R_ARR_ADDR, uint16_t R_ARR_NUMB)
-{
-  // if address from this array
-  if(Addr >= R_ARR_ADDR) 
-  {   
-    // if quantity too big return error
-    if ((Addr - R_ARR_ADDR) + Qnt > R_ARR_NUMB) 
-    {
-      return ILLEGAL_DATA_ADDRESS;  // return exception code
-    }
-    // if all ok - return no errors
-    return NO_ERRORS;
-  }
-  // if address isnt from this array return error
-  else 
-    return ILLEGAL_DATA_ADDRESS;  // return exception code    
-}
-/** 
-  * @brief    Define Address Origin for Input/Holding Registers
-  * @param    pRegs         - указатель на указатель регистров.
-  * @param    Addr          - адрес начального регистра.
-  * @param    Qnt           - количество запрашиваемых регистров.
-  * @param    WriteFlag     - флаг регистр нужны для чтения или записи.
-  * @return   ExceptionCode - Код исключения если есть, и NO_ERRORS если нет.
-  *
-  * @details  Определение адреса начального регистра.
-  * @note     WriteFlag пока не используется.
-  */
-MB_ExceptionTypeDef MB_DefineRegistersAddress(uint16_t **pRegs, uint16_t Addr, uint16_t Qnt, uint8_t RegisterType)
-{ 
-  /* check quantity error */
-  if (Qnt > 125)  
-  {   
-      return ILLEGAL_DATA_VALUE;  // return exception code
-  }
-  
-  if(RegisterType == RegisterType_Holding)
-  {
-    // Default holding registers
-    if(MB_Check_Address_For_Arr(Addr, Qnt, R_HOLDING_ADDR, R_HOLDING_QNT) == NO_ERRORS)
-    {
-      *pRegs = MB_Set_Register_Ptr(&MB_DATA.HoldRegs, Addr);  // указатель на выбранный по Addr регистр
-    }
-    // if address doesnt match any array - return illegal data address response
-    else  
-    {
-      return ILLEGAL_DATA_ADDRESS;
-    }
-  }
-  else if(RegisterType == RegisterType_Input)
-  {
-    // Default input registers
-    if(MB_Check_Address_For_Arr(Addr, Qnt, R_INPUT_ADDR, R_INPUT_QNT) == NO_ERRORS)
-    {
-      *pRegs = MB_Set_Register_Ptr(&MB_DATA.InRegs, Addr);  // указатель на выбранный по Addr регистр
-    }
-    // if address doesnt match any array - return illegal data address response
-    else  
-    {
-      return ILLEGAL_DATA_ADDRESS;
-    }
-  }
-  else
-  {
-      return ILLEGAL_FUNCTION;
-  }
-  // if found requeried array return no err
-  return NO_ERRORS; // return no errors
-}
-/** 
-  * @brief    Define Address Origin for coils
-  * @param    pCoils        - указатель на указатель коилов.
-  * @param    Addr          - адресс начального коила.
-  * @param    Qnt           - количество запрашиваемых коилов.
-  * @param    start_shift   - указатель на переменную содержащую сдвиг внутри регистра для начального коила.
-  * @param    WriteFlag     - флаг коилы нужны для чтения или записи.
-  * @return   ExceptionCode - Код исключения если есть, и NO_ERRORS если нет.
-  *
-  * @details  Определение адреса начального регистра запрашиваемых коилов.
-  * @note     WriteFlag используется для определния регистров GPIO: ODR или IDR.
-  */
-MB_ExceptionTypeDef MB_DefineCoilsAddress(uint16_t **pCoils, uint16_t Addr, uint16_t Qnt, uint16_t *start_shift, uint8_t WriteFlag)
-{ 
-  /* check quantity error */
-  if (Qnt > 2000) 
-  {
-    return ILLEGAL_DATA_VALUE;  // return exception code
-  }
-    
-  // Default coils
-  if(MB_Check_Address_For_Arr(Addr, Qnt, C_CONTROL_ADDR, C_CONTROL_QNT) == NO_ERRORS)
-  {
-    *pCoils = MB_Set_Coil_Reg_Ptr(&MB_DATA.Coils, Addr);  // указатель на выбранный по Addr массив коилов
-  }
-  // if address doesnt match any array - return illegal data address response
-  else  
-  {
-    return ILLEGAL_DATA_ADDRESS;
-  }
-  
-  *start_shift = Addr % 16; // set shift to requested coil
-  // if found requeried array return no err
-  return NO_ERRORS; // return no errors
-}
-
-
-/** 
-  * @brief    Proccess command Read Coils (01 - 0x01).
-  * @param    modbus_msg        - указатель на структуру собщения modbus.
-  * @return   fMessageHandled   - статус о результате обработки комманды.
-  * @details  Обработка команды Read Coils.
-  */
-uint8_t MB_Proccess_Read_Coils(RS_MsgTypeDef *modbus_msg)
-{
-  //---------CHECK FOR ERRORS----------
-  uint16_t *coils;
-  uint16_t start_shift = 0; // shift in coils register
-  
-  modbus_msg->Except_Code = MB_DefineCoilsAddress(&coils, modbus_msg->Addr, modbus_msg->Qnt, &start_shift, 0);
-  if(modbus_msg->Except_Code != NO_ERRORS)
-    return 0;
-  
-  //-----------READING COIL------------
-  // setup output message data size 
-  modbus_msg->ByteCnt = Divide_Up(modbus_msg->Qnt, 8);
-  // create mask for coils
-  uint16_t mask_for_coils = 0;  // mask for coils that've been chosen
-  uint16_t setted_coils = 0;    // value of setted coils
-  uint16_t temp_reg = 0;        // temp register for saving coils that hasnt been chosen
-  uint16_t coil_cnt = 0;        // counter for processed coils
-
-  // cycle until all registers with requered coils would be processed
-  int shift = start_shift;  // set shift to first coil in first register
-  int ind = 0;              // index for coils registers and data
-  for(; ind <= Divide_Up(start_shift + modbus_msg->Qnt, 16); ind++)
-  { 
-    //----SET MASK FOR COILS REGISTER----
-    mask_for_coils = 0;
-    for(; shift < 0x10; shift++)
-    {
-      mask_for_coils |= 1<<(shift); // choose certain coil
-      if(++coil_cnt >= modbus_msg->Qnt)
-        break;
-    }
-    shift = 0; // set shift to zero for the next step
-  
-    //-----------READ COILS--------------
-    modbus_msg->DATA[ind] = (*(coils+ind)&mask_for_coils) >> start_shift;
-    if(ind > 0)
-      modbus_msg->DATA[ind-1] |= ((*(coils+ind)&mask_for_coils) << 16) >> start_shift;
-      
-  }
-  // т.к. DATA 16-битная, для 8-битной передачи, надо поменять местами верхний и нижний байты
-  for(; ind >= 0; --ind)  
-    modbus_msg->DATA[ind] = ByteSwap16(modbus_msg->DATA[ind]);
-  
-  return 1;
-}
-
-/**
-  * @brief    Proccess command Read Holding Registers (03 - 0x03).
-  * @param    modbus_msg        - указатель на структуру собщения modbus.
-  * @return   fMessageHandled   - статус о результате обработки комманды.
-  * @details  Обработка команды Read Holding Registers.
-  */
-uint8_t MB_Proccess_Read_Hold_Regs(RS_MsgTypeDef *modbus_msg)
-{
-  //---------CHECK FOR ERRORS---------- 
-  // get origin address for data
-  uint16_t *pHoldRegs;      
-  modbus_msg->Except_Code = MB_DefineRegistersAddress(&pHoldRegs, modbus_msg->Addr, modbus_msg->Qnt, RegisterType_Holding); // определение адреса регистров
-  if(modbus_msg->Except_Code != NO_ERRORS)
-    return 0;
-  
-
-  //-----------READING REGS------------
-  // setup output message data size 
-  modbus_msg->ByteCnt = modbus_msg->Qnt*2; // *2 because we transmit 8 bits, not 16 bits
-  // read data
-  int i;
-  for (i = 0; i<modbus_msg->Qnt; i++)
-  {
-    modbus_msg->DATA[i] = *(pHoldRegs++);
-  } 
-  return 1;
-}
-
-/**
-  * @brief    Proccess command Read Input Registers (04 - 0x04).
-  * @param    modbus_msg        - указатель на структуру собщения modbus.
-  * @return   fMessageHandled   - статус о результате обработки комманды.
-  * @details  Обработка команды Read Input Registers.
-  */
-uint8_t MB_Proccess_Read_Input_Regs(RS_MsgTypeDef *modbus_msg)
-{
-  //---------CHECK FOR ERRORS---------- 
-  // get origin address for data
-  uint16_t *pInRegs;      
-  modbus_msg->Except_Code = MB_DefineRegistersAddress(&pInRegs, modbus_msg->Addr, modbus_msg->Qnt, RegisterType_Input); // определение адреса регистров
-  if(modbus_msg->Except_Code != NO_ERRORS)
-    return 0;
-  
-
-  //-----------READING REGS------------
-  // setup output message data size 
-  modbus_msg->ByteCnt = modbus_msg->Qnt*2; // *2 because we transmit 8 bits, not 16 bits
-  // read data
-  int i;
-  for (i = 0; i<modbus_msg->Qnt; i++)
-  {
-    if(*((int16_t *)pInRegs) > 0)
-      modbus_msg->DATA[i] = (*pInRegs++);
-    else
-      modbus_msg->DATA[i] = (*pInRegs++);
-  } 
-  return 1;
-}
-/**
-  * @brief    Proccess command Write Single Coils (05 - 0x05).
-  * @param    modbus_msg        - указатель на структуру собщения modbus.
-  * @return   fMessageHandled   - статус о результате обработки комманды.
-  * @details  Обработка команды Write Single Coils.
-  */
-uint8_t MB_Proccess_Write_Single_Coil(RS_MsgTypeDef *modbus_msg)
-{
-  //---------CHECK FOR ERRORS----------
-  if ((modbus_msg->Qnt != 0x0000) && (modbus_msg->Qnt != 0xFF00))
-  {
-    modbus_msg->Except_Code = ILLEGAL_DATA_VALUE;
-    return 0;
-  }   
-  // define position of coil
-  uint16_t *coils;
-  uint16_t start_shift = 0; // shift in coils register
-  modbus_msg->Except_Code = MB_DefineCoilsAddress(&coils, modbus_msg->Addr, 0, &start_shift, 1);
-  if(modbus_msg->Except_Code != NO_ERRORS)
-    return 0;
-  
-
-  //----------WRITTING COIL------------
-  if(modbus_msg->Qnt == 0xFF00)
-    *(coils) |= 1<<start_shift; // write flags corresponding to received data
-  else
-    *(coils) &= ~(1<<start_shift); // write flags corresponding to received data
-  
-  return 1;
-}
-
-/**
-  * @brief    Proccess command Write Single Register (06 - 0x06).
-  * @param    modbus_msg        - указатель на структуру собщения modbus.
-  * @return   fMessageHandled   - статус о результате обработки комманды.
-  * @details  Обработка команды Write Single Register.
-  */
-uint8_t MB_Proccess_Write_Single_Reg(RS_MsgTypeDef *modbus_msg)
-{ 
-  // get origin address for data
-  uint16_t *pHoldRegs;      
-  modbus_msg->Except_Code = MB_DefineRegistersAddress(&pHoldRegs, modbus_msg->Addr, 1, RegisterType_Holding); // определение адреса регистров
-  if(modbus_msg->Except_Code != NO_ERRORS)
-    return 0;
-  
-  //-----------WRITTING REG------------ 
-  *(pHoldRegs) = modbus_msg->Qnt;
-  return 1;
-}
-
-/**
-  * @brief    Proccess command Write Multiple Coils (15 - 0x0F).
-  * @param    modbus_msg      - указатель на структуру собщения modbus.
-  * @return   fMessageHandled - статус о результате обработки комманды.
-  * @details  Обработка команды Write Multiple Coils.
-  */
-uint8_t MB_Write_Miltuple_Coils(RS_MsgTypeDef *modbus_msg)
-{
-  //---------CHECK FOR ERRORS----------
-  if (modbus_msg->ByteCnt != Divide_Up(modbus_msg->Qnt, 8))
-  { // if quantity too large OR if quantity and bytes count arent match
-    modbus_msg->Except_Code = ILLEGAL_DATA_VALUE;
-    return 0;
-  } 
-  // define position of coil
-  uint16_t *coils;          // pointer to coils
-  uint16_t start_shift = 0; // shift in coils register
-  modbus_msg->Except_Code = MB_DefineCoilsAddress(&coils, modbus_msg->Addr, modbus_msg->Qnt, &start_shift, 1);
-  if(modbus_msg->Except_Code != NO_ERRORS)
-    return 0;
-  
-  //----------WRITTING COILS-----------
-  // create mask for coils
-  uint16_t mask_for_coils = 0;  // mask for coils that've been chosen
-  uint32_t setted_coils = 0;    // value of setted coils
-  uint16_t temp_reg = 0;        // temp register for saving coils that hasnt been chosen
-  uint16_t coil_cnt = 0;        // counter for processed coils
-
-  // cycle until all registers with requered coils would be processed
-  int shift = start_shift; // set shift to first coil in first register
-  for(int ind = 0; ind <= Divide_Up(start_shift + modbus_msg->Qnt, 16); ind++)
-  { 
-    //----SET MASK FOR COILS REGISTER----
-    mask_for_coils = 0;
-    for(; shift < 0x10; shift++)
-    {
-      mask_for_coils |= 1<<(shift); // choose certain coil
-      if(++coil_cnt >= modbus_msg->Qnt)
-        break;
-    }
-    shift = 0; // set shift to zero for the next step
-    
-    
-    
-    //-----------WRITE COILS-------------
-    // get current coils
-    temp_reg = *(coils+ind);
-    // set coils
-    setted_coils = ByteSwap16(modbus_msg->DATA[ind]) << start_shift;
-    if(ind > 0)
-    {
-      setted_coils |= ((ByteSwap16(modbus_msg->DATA[ind-1]) << start_shift) >> 16);
-    }
-    // write coils
-      
-    *(coils+ind) = setted_coils & mask_for_coils;   
-     // restore untouched coils
-    *(coils+ind) |= temp_reg&(~mask_for_coils);
-    
-    
-    if(coil_cnt >= modbus_msg->Qnt) // if all coils written - break cycle
-      break;                        // *kind of unnecessary
-  }
-  
-  return 1;
-}
-
-/**
-  * @brief    Proccess command Write Multiple Registers (16 - 0x10).
-  * @param    modbus_msg        - указатель на структуру собщения modbus.
-  * @return   fMessageHandled   - статус о результате обработки комманды.
-  * @details  Обработка команды Write Multiple Registers.
-  */
-uint8_t MB_Proccess_Write_Miltuple_Regs(RS_MsgTypeDef *modbus_msg)
-{
-  //---------CHECK FOR ERRORS----------
-  if (modbus_msg->Qnt*2 != modbus_msg->ByteCnt)
-  { // if quantity and bytes count arent match
-    modbus_msg->Except_Code = 3;
-    return 0;
-  } 
-  // get origin address for data
-  uint16_t *pHoldRegs;      
-  modbus_msg->Except_Code = MB_DefineRegistersAddress(&pHoldRegs, modbus_msg->Addr, modbus_msg->Qnt, RegisterType_Holding); // определение адреса регистров
-  if(modbus_msg->Except_Code != NO_ERRORS)
-    return 0;
-  
-  //-----------WRITTING REGS----------- 
-  for (int i = 0; i<modbus_msg->Qnt; i++)
-  {
-    *(pHoldRegs++) = modbus_msg->DATA[i];
-  }
-  return 1;
-}
-
-  
-/**
-	* @brief 		Write Object of Device Identification to MessageData
-	* @param 		mbdata  - указатель на массив данных в структуре RS_MsgTypeDef.
-	* @return 	obj		  - объект для записи.
-	*/
-void MB_WriteSingleObjectToMessage(char *mbdata, unsigned *ind, MB_DeviceObjectTypeDef *obj)
-{
-  mbdata[(*ind)++] = obj->length;
-  for (int i = 0; i < obj->length; i++)
-  {
-    mbdata[(*ind)++] = obj->name[i];
-  }
-}
-
-
-/**
-	* @brief 		Write Object of Device Identification to MessageData
-	* @param 		mbdata  - указатель на массив данных в структуре RS_MsgTypeDef.
-	* @return 	obj		  - объект для записи.
-	*/
-void MB_WriteObjectsToMessage(RS_MsgTypeDef *modbus_msg, unsigned maxidofobj)
-{
-  MB_DeviceObjectTypeDef *obj = (MB_DeviceObjectTypeDef *)&MB_DEVID;
-  unsigned objidtmp = modbus_msg->DevId.NextObjId;
-  
-  /* Define number of object in one message */
-  unsigned lastobjid = 0;
-  for(int i = 0; i < DATA_SIZE*2;)
-  {
-    i += 2;
-    i += obj[objidtmp].length;
-    /* Если все еще помещается в массив переходим на следующий объект */
-    if(i < DATA_SIZE*2)
-    {
-      objidtmp++;
-    }
-    /* Если объекты для записи закончились - выходим из цикла*/
-    if(objidtmp > maxidofobj)
-      break;
-  }
-  lastobjid = objidtmp-1;
-  
-  
-  /* Fill message with objects data */
-  char *mbdata = (char *)&modbus_msg->DATA;
-  unsigned ind = 0;
-  unsigned objid = modbus_msg->DevId.NextObjId;
-  for(; objid <= lastobjid; objid++)
-  {
-    mbdata[ind++] = objid;
-    MB_WriteSingleObjectToMessage(mbdata, &ind, &obj[objid]);
-  }
-  objid--;
-  modbus_msg->ByteCnt = ind;
-  modbus_msg->DevId.NextObjId = lastobjid+1;
-  if(objid == maxidofobj)
-  {
-    modbus_msg->DevId.MoreFollows = 0;
-  }
-  else
-  {
-    modbus_msg->DevId.MoreFollows = 0xFF;
-  }
-}
-
-
-/**
-  * @brief    Proccess command Read Device Identification (43/14 - 0x2B/0E).
-  * @param    modbus_msg        - указатель на структуру собщения modbus.
-  * @return   fMessageHandled   - статус о результате обработки комманды.
-  * @details  Обработка команды Write Single Register.
-  */
-uint8_t MB_Proccess_Read_Device_Identification(RS_MsgTypeDef *modbus_msg)
-{  
-  switch(modbus_msg->DevId.ReadDevId)
-  { 
-    case MB_BASIC_IDENTIFICATION:
-      if (modbus_msg->DevId.NextObjId == 0)
-      {
-        modbus_msg->DevId.NextObjId = 0;
-      }
-      
-      MB_WriteObjectsToMessage(modbus_msg, 2);
-      modbus_msg->DevId.NumbOfObj = 3;
-      break;
-      
-    case MB_REGULAR_IDENTIFICATION:
-      if (modbus_msg->DevId.NextObjId == 0)
-      {
-        modbus_msg->DevId.NextObjId = 3;
-      }
-      
-      MB_WriteObjectsToMessage(modbus_msg, 6);
-      modbus_msg->DevId.NumbOfObj = 4;
-      break;
-      
-    case MB_EXTENDED_IDENTIFICATION:
-      if (modbus_msg->DevId.NextObjId == 0)
-      {
-        modbus_msg->DevId.NextObjId = 0x80;
-      }
-      
-      MB_WriteObjectsToMessage(modbus_msg, 0x80+MODBUS_NUMB_OF_USEROBJECTS);
-      modbus_msg->DevId.NumbOfObj = MODBUS_NUMB_OF_USEROBJECTS;
-      break;
-      
-    case MB_SPEDIFIC_IDENTIFICATION:      
-      MB_WriteObjectsToMessage(modbus_msg, modbus_msg->DevId.NextObjId);
-      modbus_msg->DevId.NumbOfObj = 1;
-      break;
-    default:
-      return 0;
-  }  
-  return 1;
-}
-
-
-/** 
-  * @brief    Respond accord to received message.
-  * @param    hRS     - указатель на хендлер RS.
-  * @param    RS_msg  - указатель на структуру сообщения.
-  * @return   RS_RES  - статус о результате ответа на комманду.
-  * @details    Обработка принятой комманды и ответ на неё.
-  */
-RS_StatusTypeDef RS_Response(RS_HandleTypeDef *hmodbus, RS_MsgTypeDef *modbus_msg)
-{
-  RS_StatusTypeDef MB_RES = 0;
-  hmodbus->f.MessageHandled = 0;
-  hmodbus->f.EchoResponse = 0;
-  RS_Reset_TX_Flags(hmodbus);     // reset flag for correct transmit
-  
-  if(hmodbus->ID == 0)
-  {
-    hmodbus->RS_STATUS = RS_SKIP;
-    return MB_RES;
-  }
-
-  if(modbus_msg->Func_Code < ERR_VALUES_START)// if no errors after parsing
-  {
-    switch (modbus_msg->Func_Code)
-    {
-      // Read Coils
-      case MB_R_COILS: 
-        hmodbus->f.MessageHandled =   MB_Proccess_Read_Coils(hmodbus->pMessagePtr);
-        break;
-      
-      // Read Hodling Registers
-      case MB_R_HOLD_REGS:
-        hmodbus->f.MessageHandled =   MB_Proccess_Read_Hold_Regs(hmodbus->pMessagePtr);
-        break;
-      case MB_R_IN_REGS: 
-        hmodbus->f.MessageHandled =   MB_Proccess_Read_Input_Regs(hmodbus->pMessagePtr);
-        break;
-      
-      
-      // Write Single Coils
-      case MB_W_COIL: 
-        hmodbus->f.MessageHandled = MB_Proccess_Write_Single_Coil(hmodbus->pMessagePtr); 
-        if(hmodbus->f.MessageHandled) 
-        {
-          hmodbus->f.DataUpdated = 1;
-          hmodbus->f.EchoResponse = 1; 
-          hmodbus->RS_Message_Size -= 2; // echo response if write ok (minus 2 cause of two CRC bytes)
-        }
-        break;
-      
-      case MB_W_HOLD_REG:   
-        hmodbus->f.MessageHandled = MB_Proccess_Write_Single_Reg(hmodbus->pMessagePtr);  
-        if(hmodbus->f.MessageHandled) 
-        {
-          hmodbus->f.DataUpdated = 1;
-          hmodbus->f.EchoResponse = 1;
-          hmodbus->RS_Message_Size -= 2; // echo response if write ok (minus 2 cause of two CRC bytes)
-        }
-        break;
-      
-      // Write Multiple Coils
-      case MB_W_COILS: 
-        hmodbus->f.MessageHandled =   MB_Write_Miltuple_Coils(hmodbus->pMessagePtr);
-        if(hmodbus->f.MessageHandled) 
-        {
-          hmodbus->f.DataUpdated = 1;
-          hmodbus->f.EchoResponse = 1; 
-          hmodbus->RS_Message_Size = 6; // echo response if write ok (withous data bytes)
-        }
-        break;
-      
-      // Write Multiple Registers
-      case MB_W_HOLD_REGS:
-        hmodbus->f.MessageHandled =   MB_Proccess_Write_Miltuple_Regs(hmodbus->pMessagePtr);
-        if(hmodbus->f.MessageHandled) 
-        {
-          hmodbus->f.DataUpdated = 1;
-          hmodbus->f.EchoResponse = 1; 
-          hmodbus->RS_Message_Size = 6; // echo response if write ok (withous data bytes)
-        }
-        break;
-      
-      case MB_R_DEVICE_INFO:
-        hmodbus->f.MessageHandled =   MB_Proccess_Read_Device_Identification(hmodbus->pMessagePtr);
-        break;
-        
-      /* unknown func code */
-      default: modbus_msg->Except_Code = 0x01; /* set exception code: illegal function */
-    }   
-        
-    if(hmodbus->f.MessageHandled == 0)
-    {
-      TrackerCnt_Warn(hmodbus->rs_err);
-			modbus_msg->Func_Code |= ERR_VALUES_START;
-    }
-    else
-    {
-      TrackerCnt_Ok(hmodbus->rs_err);
-    }
-    
-      
-  }
-  
-  // if we need response - check that transmit isnt busy
-  if( RS_Is_TX_Busy(hmodbus) ) 
-    RS_Abort(hmodbus, ABORT_TX);    // if tx busy - set it free
-  
-  // Transmit right there, or sets (fDeferredResponse) to transmit response in main code  
-  if(hmodbus->f.DeferredResponse == 0)
-  {
-  MB_RES = RS_Handle_Transmit_Start(hmodbus, modbus_msg);
-  }
-  else
-  {
-    RS_Handle_Receive_Start(hmodbus, modbus_msg);
-    hmodbus->f.DeferredResponse = 0;
-  }
-  
-  hmodbus->RS_STATUS = MB_RES;
-  return MB_RES;
-}
-
-/** 
-  * @brief    Collect message in buffer to transmit it.
-  * @param    hRS           - указатель на хендлер RS.
-  * @param    RS_msg        - указатель на структуру сообщения.
-  * @param    msg_uart_buff - указатель на буффер UART.
-  * @return   RS_RES        - статус о результате заполнения буфера.
-  * @details    Заполнение буффера UART из структуры сообщения.
-  */
-RS_StatusTypeDef RS_Collect_Message(RS_HandleTypeDef *hmodbus, RS_MsgTypeDef *modbus_msg, uint8_t *modbus_uart_buff)
-{
-  int ind = 0; // ind for modbus-uart buffer
-  
-  if(hmodbus->f.EchoResponse && hmodbus->f.MessageHandled)  // if echo response need
-    ind = hmodbus->RS_Message_Size;
-  else
-  {
-    //------INFO ABOUT DATA/MESSAGE------
-    //-----------[first bytes]-----------
-    // set ID of message/user
-    modbus_uart_buff[ind++] = modbus_msg->MbAddr; 
-
-    // set dat or err response
-    modbus_uart_buff[ind++] = modbus_msg->Func_Code;  
-
-    if (modbus_msg->Func_Code < ERR_VALUES_START) // if no error occur
-    {
-      // fill modbus header
-      if(modbus_msg->Func_Code == MB_R_DEVICE_INFO) // devide identification header
-      {
-        modbus_uart_buff[ind++] = modbus_msg->DevId.MEI_Type;
-        modbus_uart_buff[ind++] = modbus_msg->DevId.ReadDevId;
-        modbus_uart_buff[ind++] = modbus_msg->DevId.Conformity;
-        modbus_uart_buff[ind++] = modbus_msg->DevId.MoreFollows;
-        modbus_uart_buff[ind++] = modbus_msg->DevId.NextObjId;
-        modbus_uart_buff[ind++] = modbus_msg->DevId.NumbOfObj;
-        
-        if (modbus_msg->ByteCnt > DATA_SIZE*2) // if ByteCnt less than DATA_SIZE
-        {
-          TrackerCnt_Err(hmodbus->rs_err);
-          return RS_COLLECT_MSG_ERR;
-        }
-        
-        
-        //---------------DATA----------------
-        //-----------[data bytes]------------
-        uint8_t *tmp_data_addr = (uint8_t *)modbus_msg->DATA;
-        for(int i = 0; i < modbus_msg->ByteCnt; i++) // filling buffer with data
-        { // set data
-          modbus_uart_buff[ind++] = *tmp_data_addr;
-          tmp_data_addr++;
-        }
-        
-      }
-      else // modbus data header
-      {
-        // set size of received data
-        if (modbus_msg->ByteCnt <= DATA_SIZE*2) // if ByteCnt less than DATA_SIZE
-          modbus_uart_buff[ind++] = modbus_msg->ByteCnt;
-        else                                        // otherwise return data_size err
-        {
-          TrackerCnt_Err(hmodbus->rs_err);
-          return RS_COLLECT_MSG_ERR;
-        }        
-        
-        //---------------DATA----------------
-        //-----------[data bytes]------------
-        uint16_t *tmp_data_addr = (uint16_t *)modbus_msg->DATA;
-        for(int i = 0; i < modbus_msg->ByteCnt; i++) // filling buffer with data
-        { // set data
-          if (i%2 == 0)   // HI byte
-            modbus_uart_buff[ind++] = (*tmp_data_addr)>>8;
-          else            // LO byte
-          {
-            modbus_uart_buff[ind++] = *tmp_data_addr;
-            tmp_data_addr++;
-          }
-        }
-
-      }
-      
-    }
-    else  // if some error occur
-    {     // send expection code
-      modbus_uart_buff[ind++] = modbus_msg->Except_Code;
-    }
-  }
-  //---------------CRC----------------
-  //---------[last 16 bytes]----------
-  // calc crc of received data
-  uint16_t CRC_VALUE = crc16(modbus_uart_buff, ind);
-  // write crc to message structure and modbus-uart buffer
-  modbus_msg->MB_CRC = CRC_VALUE;
-  modbus_uart_buff[ind++] = CRC_VALUE;
-  modbus_uart_buff[ind++] = CRC_VALUE >> 8;
-  
-  hmodbus->RS_Message_Size = ind;
-  
-  return RS_OK; // returns ok
-}
-
-/** 
-  * @brief    Parse message from buffer to process it.
-  * @param    hRS           - указатель на хендлер RS.
-  * @param    RS_msg        - указатель на структуру сообщения.
-  * @param    msg_uart_buff - указатель на буффер UART.
-  * @return   RS_RES        - статус о результате заполнения структуры.
-  * @details    Заполнение структуры сообщения из буффера UART.
-  */
-RS_StatusTypeDef RS_Parse_Message(RS_HandleTypeDef *hmodbus, RS_MsgTypeDef *modbus_msg, uint8_t *modbus_uart_buff)
-{
-  uint32_t check_empty_buff;
-  int ind = 0; // ind for modbus-uart buffer
-  //-----INFO ABOUT DATA/MESSAGE-------
-  //-----------[first bits]------------
-  // get ID of message/user
-  if(modbus_uart_buff[ind] != hmodbus->ID)
-  {
-    modbus_msg->MbAddr = 0;
-    return RS_SKIP;
-  }
-	modbus_msg->MbAddr = modbus_uart_buff[ind++];
-  
-  // get func code
-  modbus_msg->Func_Code = modbus_uart_buff[ind++];
-  if(modbus_msg->Func_Code & ERR_VALUES_START) // явная херня
-  {
-    modbus_msg->MbAddr = 0;
-    return RS_SKIP;
-  }
-  
-  if(modbus_msg->Func_Code == MB_R_DEVICE_INFO) // if it device identification request
-  {
-    modbus_msg->DevId.MEI_Type = modbus_uart_buff[ind++];
-    modbus_msg->DevId.ReadDevId = modbus_uart_buff[ind++];
-    modbus_msg->DevId.NextObjId = modbus_uart_buff[ind++];
-    modbus_msg->ByteCnt = 0;
-  }
-  else // if its classic modbus request
-  {
-  // get address from CMD
-  modbus_msg->Addr = modbus_uart_buff[ind++] << 8;
-  modbus_msg->Addr |= modbus_uart_buff[ind++];
-  
-  // get address from CMD
-  modbus_msg->Qnt = modbus_uart_buff[ind++] << 8;
-  modbus_msg->Qnt |= modbus_uart_buff[ind++];
-  }
-  
-  if((hmodbus->pMessagePtr->Func_Code == 0x0F) || (hmodbus->pMessagePtr->Func_Code == 0x10))
-		hmodbus->pMessagePtr->ByteCnt = modbus_uart_buff[ind++];
-	else
-		hmodbus->pMessagePtr->ByteCnt = 0;
-    //---------------DATA----------------
-    //            (optional)
-    if (modbus_msg->ByteCnt != 0)
-    {
-      //check that data size is correct
-      if (modbus_msg->ByteCnt > DATA_SIZE*2)
-      {
-      TrackerCnt_Err(hmodbus->rs_err);
-      modbus_msg->Func_Code |= ERR_VALUES_START;
-        return RS_PARSE_MSG_ERR;
-      }
-      uint16_t *tmp_data_addr = (uint16_t *)modbus_msg->DATA;
-    for(int i = 0; i < modbus_msg->ByteCnt; i++)
-      { // set data
-        if (i%2 == 0)
-          *tmp_data_addr = ((uint16_t)modbus_uart_buff[ind++] << 8);
-        else
-        {
-          *tmp_data_addr |= modbus_uart_buff[ind++];
-          tmp_data_addr++;
-        }
-      }
-    }
-    
-    //---------------CRC----------------
-    //----------[last 16 bits]----------
-    // calc crc of received data
-    uint16_t CRC_VALUE = crc16(modbus_uart_buff, ind);
-    // get crc of received data
-    modbus_msg->MB_CRC = modbus_uart_buff[ind++];
-    modbus_msg->MB_CRC |= modbus_uart_buff[ind++] << 8;
-    // compare crc
-    if (modbus_msg->MB_CRC != CRC_VALUE)
-    {
-    TrackerCnt_Err(hmodbus->rs_err);
-    modbus_msg->Func_Code |= ERR_VALUES_START;
-    }
-//		hmodbus->MB_RESPONSE = MB_CRC_ERR; // set func code - error about wrong crc
-    
-    // check is buffer empty
-    check_empty_buff = 0;
-    for(int i=0; i<ind;i++)
-      check_empty_buff += modbus_uart_buff[i];
-//	if(check_empty_buff == 0) 
-//		hmodbus->MB_RESPONSE = MB_EMPTY_MSG; // 
-  
-  return RS_OK;
-}
-
-/** 
-  * @brief    Define size of RX Message that need to be received.
-  * @param    hRS           - указатель на хендлер RS.
-  * @param    rx_data_size  - указатель на переменную для записи кол-ва байт для принятия.
-  * @return   RS_RES        - статус о корректности рассчета кол-ва байт для принятия.
-  * @details  Определение сколько байтов надо принять по протоколу.
-  */
-RS_StatusTypeDef RS_Define_Size_of_RX_Message(RS_HandleTypeDef *hmodbus, uint32_t *rx_data_size)
-{   
-  RS_StatusTypeDef MB_RES = 0;
-  
-  MB_RES = RS_Parse_Message(hmodbus, hmodbus->pMessagePtr, hmodbus->pBufferPtr);
-//	if(MB_RES == RS_SKIP) // if message not for us
-//		return MB_RES;																// return 
-  
-  
-  if ((hmodbus->pMessagePtr->Func_Code & ~ERR_VALUES_START) < 0x0F)
-  {
-    hmodbus->pMessagePtr->ByteCnt = 0;
-    *rx_data_size = 1;
-    
-  }
-  else
-  {
-    hmodbus->pMessagePtr->ByteCnt = hmodbus->pBufferPtr[RX_FIRST_PART_SIZE-1]; // get numb of data in command
-  // +1 because that defines is size, not ind.
-    *rx_data_size = hmodbus->pMessagePtr->ByteCnt + 2;
-  }
-  
-  
-  if(hmodbus->pMessagePtr->Func_Code == MB_R_DEVICE_INFO)
-  {
-    *rx_data_size = 0;
-  }
-  
-  hmodbus->RS_Message_Size = RX_FIRST_PART_SIZE + *rx_data_size; // size of whole message
-  return RS_OK;
-}
-
-
-void MB_DeviceInentificationInit(void)
-{
-  MB_ObjectInit(&MB_DEVID.VendorName,          MODBUS_VENDOR_NAME);
-  MB_ObjectInit(&MB_DEVID.ProductCode,         MODBUS_PRODUCT_CODE);
-  MB_ObjectInit(&MB_DEVID.Revision,            MODBUS_REVISION);
-  MB_ObjectInit(&MB_DEVID.VendorUrl,           MODBUS_VENDOR_URL);
-  MB_ObjectInit(&MB_DEVID.ProductName,         MODBUS_PRODUCT_NAME);
-  MB_ObjectInit(&MB_DEVID.ModelName,           MODBUS_MODEL_NAME);
-
-}
-
-
-
--- a/Modbus/modbus_data.h
+++ b/Modbus/modbus_data.h
@@ -1,134 +0,0 @@
-/** 
-**************************************************************************
-* @file   modbus_data.h
-* @brief    Заголовочный файл с описанием даты MODBUS.
-* @details  Данный файл необходимо подключается в rs_message.h. После rs_message.h 
-* подключается к основному проекту.
-* 
-* @defgroup MODBUS_DATA
-* @ingroup  MODBUS
-* @brief    Modbus data description
-*
-*************************************************************************/
-
-#ifndef _MODBUS_DATA_H_
-#define _MODBUS_DATA_H_
-  
-#include "stdint.h"
-//--------------DEFINES FOR REGISTERS---------------
-// DEFINES FOR ARRAYS
-/** 
-  * @addtogroup MODBUS_DATA_RERISTERS_DEFINES
-  * @ingroup    MODBUS_DATA
-  * @brief      Defines for registers
-  Структура дефайна адресов
-  @verbatim    
-  Для массивов регистров:
-    R_<NAME_ARRAY>_ADDR   -  модбас адресс первого регистра в массиве
-    R_<NAME_ARRAY>_QNT    -  количество регистров в массиве
-  
-  При добавлении новых массивов регистров, необходимо их добавить в функцию MB_DefineRegistersAddress
-
-    if(MB_Check_Address_For_Arr(Addr, Qnt, R_<NEW_ARRAY>_ADDR, R_<NEW_ARRAY>_QNT) == NO_ERRORS)
-    {
-      *pRegs = MB_Set_Register_Ptr(&<NEW_ARRAY>, Addr); // начало регистров хранения/входных
-    }
-  @endverbatim
-  * @{
-  */
-  
-  
-/** 
-  * @brief Регистры хранения
-  */
-typedef struct //MB_DataInRegsTypeDef
-{
-  uint16_t in[16];
-}MB_DataInRegsTypeDef;
-
-
-/** 
-  * @brief Входные регистры 
-  */
-typedef struct //MB_DataInRegsTypeDef
-{
-  uint16_t out[16];
-}MB_DataHoldRegsTypeDef;
-
-
-// DEFINES FOR INPUT REGISTERS ARRAYS
-#define   R_INPUT_ADDR                 0
-#define   R_INPUT_QNT                  16
-
-// DEFINES FOR HOLDING REGISTERS ARRAYS
-#define   R_HOLDING_ADDR                   0
-#define   R_HOLDING_QNT                    16
-
- 
-/** MODBUS_DATA_RERISTERS_DEFINES
-  * @} 
-  */
-
-//----------------DEFINES FOR COILS-----------------
-/** 
-  * @addtogroup MODBUS_DATA_COILS_DEFINES
-  * @ingroup    MODBUS_DATA
-  * @brief      Defines for coils
-  @verbatim    
-  Структура дефайна
-  Для массивов коилов:
-    C_<NAME_ARRAY>_ADDR   - модбас адресс первого коила в массиве
-    C_<NAME_ARRAY>_QNT    - количество коилов в массиве (минимум 16)
-
-  При добавлении новых массивов коилов, необходимо их добавить в функцию MB_DefineCoilsAddress
-
-    if(MB_Check_Address_For_Arr(Addr, Qnt, C_<NEW_ARRAY>_ADDR, C_<NEW_ARRAY>_QNT) == NO_ERRORS)
-    {
-      *pCoils = MB_Set_Coil_Reg_Ptr(&<NEW_ARRAY>, Addr);
-    }
-
-  @endverbatim
-  * @{
-  */
-  
-  
-  
-/** 
-  * @brief     Коилы
-  * @details   Желательно с помощью reserved делать стркутуру кратной 16-битам
-  */
-typedef struct //MB_DataCoilsTypeDef
-{
-  unsigned reserved:16;
-}MB_DataCoilsTypeDef;
-
-// DEFINES FOR COIL ARRAYS
-#define C_CONTROL_ADDR                0
-#define C_CONTROL_QNT                 16
-
-/** MODBUS_DATA_COILS_DEFINES
-  * @} 
-  */
-  
-  
-//-----------MODBUS DEVICE DATA SETTING-------------
-// MODBUS DATA STRUCTTURE
-/** 
-  * @brief Структура со всеми регистрами и коилами модбас 
-  * @ingroup  MODBUS_DATA
-  */
-typedef struct // tester modbus data
-{
-  MB_DataInRegsTypeDef      InRegs;     ///< Modbus input registers @ref MB_DataInRegsTypeDef
-
-  MB_DataCoilsTypeDef       Coils;      ///< Modbus coils @ref MB_DataCoilsTypeDef
-  
-  MB_DataHoldRegsTypeDef    HoldRegs;   ///< Modbus holding registers @ref MB_DataHoldRegsTypeDef
-}MB_DataStructureTypeDef;
-extern MB_DataStructureTypeDef MB_DATA;
-
-
-#endif //_MODBUS_DATA_H_
-
-/////////////////////////////////////////////////////////////
-///////////////////////TEMP/OUTDATE/OTHER////////////////////
--- a/Modbus/rs_message.c
+++ b/Modbus/rs_message.c
@@ -1,631 +0,0 @@
-/** 
-**************************************************************************
-* @file rs_message.c
-* @brief Модуль для реализации протоколов по RS/UART.
-**************************************************************************\
-* @details
-* Данный модуль реализует основные функции для приема и передачи сообщений
-* по протоколу RS через UART в режиме прерываний. Реализована обработка
-* приема и передачи данных, управление состояниями RS, а также функции для
-* инициализации и управления периферией.
-*
-* Реализованы следующие функции:
-* - RS_Receive_IT() — запуск приема данных в прерывании по UART.
-* - RS_Transmit_IT() — запуск передачи данных в прерывании по UART.
-* - RS_Init() — инициализация структуры RS и привязка периферии.
-* - RS_ReInit_UART() — переинициализация UART и перезапуск приема данных.
-* - RS_Abort() — остановка работы RS/UART с очисткой флагов и структур.
-* - RS_Handle_Receive_Start() — обработка старта приема данных по RS.
-*
-* В модуле также определен буфер RS_Buffer[] для хранения принимаемых/передаваемых данных.
-*
-* @note
-* Для корректной работы модуля предполагается использование соответствующих
-* обработчиков прерываний UART и таймера (RS_UART_Handler(), RS_TIM_Handler()),
-* которые надо вызывать с обработчиках используемой периферии
-
-@verbatim
-//-------------------Функции-------------------//
-Functions: users
-  - RS_Parse_Message/RS_Collect_Message Заполнение структуры сообщения и буфера
-  - RS_Response                   Ответ на сообщение
-  - RS_Define_Size_of_RX_Message  Определение размера принимаемых данных
-
-Functions: general
-  - RS_Receive_IT                 Ожидание комманды и ответ на неё
-  - RS_Transmit_IT                Отправление комманды и ожидание ответа
-  - RS_Init                       Инициализация переферии и структуры для RS
-  - RS_ReInit_UART                Реинициализация UART для RS
-  - RS_Abort                      Отмена приема/передачи по ЮАРТ
-  - RS_Init                       Инициализация периферии и modbus handler
-
-Functions: callback/handler
-  - RS_Handle_Receive_Start       Функция для запуска приема или остановки RS
-  - RS_Handle_Transmit_Start      Функция для запуска передачи или остановки RS
-  
-  - RS_UART_RxCpltCallback        Коллбек при окончании приема или передачи
-    RS_UART_TxCpltCallback    
-    
-  - RS_UART_Handler               Обработчик прерывания для UART
-  - RS_TIM_Handler                Обработчик прерывания для TIM
-
-@endverbatim
-*************************************************************************/
-#include "rs_message.h"
-
-uint8_t RS_Buffer[MSG_SIZE_MAX]; // uart buffer
-
-extern void RS_UART_Init(void);
-extern void RS_UART_DeInit(UART_HandleTypeDef *huart);
-extern void RS_TIM_Init(void);
-extern void RS_TIM_DeInit(TIM_HandleTypeDef *htim);
-
-//-------------------------------------------------------------------
-//-------------------------GENERAL FUNCTIONS-------------------------
-/**
-  * @brief  Start receive IT.
-  * @param  hRS     - указатель на хендлер RS.
-  * @param  RS_msg  - указатель на структуру сообщения.
-  * @return RS_RES  - статус о состоянии RS после инициализации приема.
-  */
-RS_StatusTypeDef RS_Receive_IT(RS_HandleTypeDef *hRS, RS_MsgTypeDef *RS_msg)
-{
-  RS_StatusTypeDef RS_RES = 0;
-  HAL_StatusTypeDef uart_res = 0;
-  
-  //-------------CHECK RS LINE----------------
-  // check that receive isnt busy
-  if( RS_Is_RX_Busy(hRS) ) // if tx busy - return busy status
-    return RS_BUSY; 
-  
-  //-----------INITIALIZE RECEIVE-------------
-  // if all OK: start receiving
-  RS_EnableReceive();
-  RS_Set_Busy(hRS);             // set RS busy  
-  RS_Set_RX_Flags(hRS);         // initialize flags for receive
-  hRS->pMessagePtr = RS_msg;    // set pointer to message structire for filling it from UARTHandler fucntions
-  
-  // start receiving
-  __HAL_UART_ENABLE_IT(hRS->huart, UART_IT_IDLE);
-	uart_res = HAL_UART_Receive_IT(hRS->huart, hRS->pBufferPtr, MSG_SIZE_MAX); // receive until ByteCnt+1 byte, 
-  // then in Callback restart receive for rest bytes  
-  
-  // if receive isnt started - abort RS
-  if(uart_res != HAL_OK)
-  {
-    RS_RES = RS_Abort(hRS, ABORT_RS);
-    printf_rs_err("Failed to start RS receiving...");
-    TrackerCnt_Err(hRS->rs_err);
-  }
-  else
-  {
-    RS_RES = RS_OK;
-    printf_rs("Start Receiving...");
-    TrackerCnt_Ok(hRS->rs_err);
-  }
-  
-  hRS->RS_STATUS = RS_RES;
-  return RS_RES; // returns result of receive init  
-}
-
-/**
-  * @brief  Start transmit IT.
-  * @param  hRS     - указатель на хендлер RS.
-  * @param  RS_msg  - указатель на структуру сообщения.
-  * @return RS_RES  - статус о состоянии RS после инициализации передачи.
-  */
-RS_StatusTypeDef RS_Transmit_IT(RS_HandleTypeDef *hRS, RS_MsgTypeDef *RS_msg)
-{ 
-  RS_StatusTypeDef RS_RES = 0;
-  HAL_StatusTypeDef uart_res = 0;
-  
-  //-------------CHECK RS LINE----------------
-  // check that transmit isnt busy
-  if( RS_Is_TX_Busy(hRS) ) // if tx busy - return busy status
-    return RS_BUSY;
-    // check receive line
-
-  
-  //------------COLLECT MESSAGE---------------
-  RS_RES = RS_Collect_Message(hRS, RS_msg, hRS->pBufferPtr);
-  if (RS_RES != RS_OK) // if message isnt collect - stop RS and return error in RS_RES
-  {// need collect message status, so doesnt write abort to RS_RES
-    RS_Abort(hRS, ABORT_RS);
-    RS_Handle_Receive_Start(hRS, hRS->pMessagePtr); // restart receive
-  }
-  else // if collect successful
-  {
-    
-    //----------INITIALIZE TRANSMIT-------------
-    RS_EnableTransmit();
-//    for(int i = 0; i < hRS->sRS_Timeout; i++);
-    
-    RS_Set_Busy(hRS);             // set RS busy
-    RS_Set_TX_Flags(hRS);         // initialize flags for transmit IT
-    hRS->pMessagePtr = RS_msg;    // set pointer for filling given structure from UARTHandler fucntion
-
-    // if all OK: start transmitting
-    uart_res = HAL_UART_Transmit_IT(hRS->huart, hRS->pBufferPtr, hRS->RS_Message_Size); 
-    // if transmit isnt started - abort RS
-    if(uart_res != HAL_OK)
-    {
-      RS_RES = RS_Abort(hRS, ABORT_RS);
-      printf_rs_err("Failed to start RS transmitting...");
-      TrackerCnt_Err(hRS->rs_err);
-    }
-    else
-    {
-      RS_RES = RS_OK;
-      printf_rs("Start Transmitting...");
-      TrackerCnt_Ok(hRS->rs_err);
-    }
-  }
-  
-  
-  hRS->RS_STATUS = RS_RES;
-  return RS_RES; // returns result of transmit init   
-}
-
-/** 
-  * @brief  Initialize UART and handle RS stucture.
-  * @param  hRS           - указатель на хендлер RS.
-  * @param  suart         - указатель на структуру с настройками UART.
-  * @param  stim          - указатель на структуру с настройками таймера.
-  * @param  pRS_BufferPtr - указатель на буффер для приема-передачи по UART. Если он NULL, то поставиться библиотечный буфер.
-  * @return RS_RES        - статус о состоянии RS после инициализации.
-  * @note   Инициализация перефирии и структуры для приема-передачи по RS.
-  */
-RS_StatusTypeDef RS_Init(RS_HandleTypeDef *hRS, UART_HandleTypeDef *huart, TIM_HandleTypeDef *htim, uint8_t *pRS_BufferPtr)
-{
-  // check that hRS is defined
-  if (hRS == NULL)
-    return RS_ERR;
-  // check that huart is defined
-  if (huart == NULL) 
-    return RS_ERR;
-  // init uart
-  
-//  RS_UART_Init();
-  hRS->huart = huart;
-  
-//  RS_TIM_Init();
-  hRS->htim = htim;
-  
-  if (hRS->sRS_RX_Size_Mode == NULL)
-    return RS_ERR;
-  
-  // check that buffer is defined
-  if (hRS->pBufferPtr == NULL)
-  {
-    hRS->pBufferPtr = RS_Buffer;    // if no - set default
-  }
-  else
-    hRS->pBufferPtr = pRS_BufferPtr; // if yes - set by user
-    
-  return RS_OK;
-}
-
-/** 
-  * @brief  ReInitialize UART and RS receive.
-  * @param  hRS           - указатель на хендлер RS.
-  * @param  suart         - указатель на структуру с настройками UART.
-  * @return RS_RES        - статус о состоянии RS после инициализации.
-  * @note   Реинициализация UART и приема по RS.
-  */
-HAL_StatusTypeDef RS_ReInit_UART(RS_HandleTypeDef *hRS, UART_HandleTypeDef *huart)
-{
-  HAL_StatusTypeDef RS_RES;
-  hRS->f.ReInit_UART = 0;
-  
-//  // check is settings are valid
-//  if(Check_UART_Init_Struct(suart) != HAL_OK)
-//    return HAL_ERROR;
-  
-  RS_Abort(hRS, ABORT_RS);
-  
-  RS_UART_DeInit(huart);
-  
-  RS_UART_Init();
-  
-  
-  RS_Receive_IT(hRS, hRS->pMessagePtr);
-  return RS_RES;
-}
-
-
-/**
-  * @brief  Abort RS/UART.
-  * @param  hRS         - указатель на хендлер RS.
-  * @param  AbortMode   - выбор, что надо отменить.
-              - ABORT_TX:    Отмена передачи по ЮАРТ, с очищением флагов TX,
-              - ABORT_RX:    Отмена приема по ЮАРТ, с очищением флагов RX,
-              - ABORT_RX_TX: Отмена приема и передачи по ЮАРТ,
-              - ABORT_RS:    Отмена приема-передачи RS, с очищением всей структуры.
-  * @return RS_RES      - статус о состоянии RS после аборта.
-  * @note   Отмена работы UART в целом или отмена приема/передачи RS. 
-            Также очищается хендл hRS.
-  */
-RS_StatusTypeDef RS_Abort(RS_HandleTypeDef *hRS, RS_AbortTypeDef AbortMode)
-{
-  HAL_StatusTypeDef uart_res = 0;
-  
-  if(hRS->sRS_Timeout)                // if timeout setted
-    HAL_TIM_Base_Stop_IT(hRS->htim);  // stop timeout
-	hRS->htim->Instance->CNT = 0;
-	__HAL_TIM_CLEAR_IT(hRS->htim, TIM_IT_UPDATE);
-  
-  if((AbortMode&ABORT_RS) == 0x00)
-  { 
-    if((AbortMode&ABORT_RX) == ABORT_RX)
-    {
-      uart_res = HAL_UART_AbortReceive(hRS->huart);   // abort receive
-      RS_Reset_RX_Flags(hRS);
-    }
-    
-    if((AbortMode&ABORT_TX) == ABORT_TX)
-    {
-      uart_res = HAL_UART_AbortTransmit(hRS->huart);  // abort transmit
-      RS_Reset_TX_Flags(hRS);
-    }
-  }
-  else
-  {
-    uart_res = HAL_UART_Abort(hRS->huart);
-    RS_Clear_All(hRS);
-  }
-  hRS->RS_STATUS = RS_ABORTED;
-  return RS_ABORTED;
-}
-
-
-//-------------------------GENERAL FUNCTIONS-------------------------
-//-------------------------------------------------------------------
-
-
-
-//-------------------------------------------------------------------
-//--------------------CALLBACK/HANDLER FUNCTIONS---------------------
-/**
-  * @brief  Handle for starting receive.
-  * @param  hRS     - указатель на хендлер RS.
-  * @param  RS_msg  - указатель на структуру сообщения.
-  * @return RS_RES  - статус о состоянии RS после инициализации приема или окончания общения.
-  * @note   Определяет начинать прием команды/ответа или нет.
-  */
-RS_StatusTypeDef RS_Handle_Receive_Start(RS_HandleTypeDef *hRS, RS_MsgTypeDef *RS_msg)
-{ 
-  RS_StatusTypeDef RS_RES = 0;
-  
-  switch(hRS->sRS_Mode)
-  {
-    case SLAVE_ALWAYS_WAIT:                       // in slave mode with permanent waiting
-      RS_RES = RS_Receive_IT(hRS, RS_msg); break; // start receiving again
-    case SLAVE_TIMEOUT_WAIT:                      // in slave mode with timeout waiting (start receiving cmd by request)
-      RS_Set_Free(hRS);  RS_RES = RS_OK; break;   // end RS communication (set RS unbusy)
-  }
-  
-  if(RS_RES != RS_OK)
-  {
-    TrackerCnt_Err(hRS->rs_err);
-  }
-  
-  return RS_RES;
-}
-/**  
-  * @brief  Handle for starting transmit.
-  * @param  hRS     - указатель на хендлер RS.
-  * @param  RS_msg  - указатель на структуру сообщения.
-  * @return RS_RES  - статус о состоянии RS после инициализации передачи.
-  * @note   Определяет отвечать ли на команду или нет.
-  */
-RS_StatusTypeDef RS_Handle_Transmit_Start(RS_HandleTypeDef *hRS, RS_MsgTypeDef *RS_msg)
-{ 
-  RS_StatusTypeDef RS_RES = 0;
-  
-  switch(hRS->sRS_Mode)
-  {
-    case SLAVE_ALWAYS_WAIT:   // in slave mode always response
-    case SLAVE_TIMEOUT_WAIT:  // transmit response
-      RS_RES = RS_Transmit_IT(hRS, RS_msg); break; 
-  }
-  if(RS_RES != RS_OK)
-  {
-    TrackerCnt_Err(hRS->rs_err);
-  }
-  
-  return RS_RES;
-}
-
-/**  
-  * @brief  UART RX Callback: define behaviour after receiving parts of message.
-  * @param  hRS     - указатель на хендлер RS.
-  * @return RS_RES  - статус о состоянии RS после обработки приема.
-  * @note   Контролирует прием сообщения: определяет размер принимаемой посылки и обрабатывает его.
-  */
-RS_StatusTypeDef RS_UART_RxCpltCallback(RS_HandleTypeDef *hRS)
-{
-  RS_StatusTypeDef RS_RES = 0;
-  HAL_StatusTypeDef uart_res = 0;
-	int flag_to_response = 0;
-  
-  // if we had received bytes before ByteCnt
-  if((hRS->sRS_RX_Size_Mode == RS_RX_Size_NotConst) && (hRS->f.RX_Half == 0)) // if data size isnt constant and its first half, and
-  { // First receive part of message, then define size of rest of message, and start receive it
-    hRS->f.RX_Half = 1;
-    //---------------FIND DATA SIZE-----------------
-    uint32_t NuRS_of_Rest_Bytes = 0xFFFF;
-    RS_RES = RS_Define_Size_of_RX_Message(hRS, &NuRS_of_Rest_Bytes);
-    
-
-    
-    // if we need to skip this message - restart receive
-    if(RS_RES == RS_SKIP || NuRS_of_Rest_Bytes == 0xFFFF)
-    {
-      RS_Abort(hRS, ABORT_RX);
-      RS_RES = RS_Handle_Receive_Start(hRS, hRS->pMessagePtr);
-      return RS_RES;
-    }
-    
-    // if there is no bytes to receive
-    if(NuRS_of_Rest_Bytes != 0)
-    {    
-    //-------------START UART RECEIVE---------------
-    uart_res = HAL_UART_Receive_IT(hRS->huart, (hRS->pBufferPtr + RX_FIRST_PART_SIZE), NuRS_of_Rest_Bytes); 
-    
-    if(uart_res != HAL_OK)
-    {// need uart status, so doesnt write abort to RS_RES
-        TrackerCnt_Err(hRS->rs_err);
-      RS_RES = RS_Abort(hRS, ABORT_RS);
-    }
-    else
-      RS_RES = RS_OK;
-    }
-    else
-    {
-      hRS->f.RX_Half = 0;
-      flag_to_response = 1;
-    }
-  }  
-  else // if we had received whole message
-  {
-    hRS->f.RX_Half = 0;
-    flag_to_response = 1;      
-	}
-	
-  
-  if(flag_to_response)
-  {
-    //---------PROCESS DATA & ENDING RECEIVING--------
-    RS_Set_RX_End(hRS);
-    
-    if(hRS->sRS_Timeout)                // if timeout setted
-      HAL_TIM_Base_Stop_IT(hRS->htim);  // stop timeout
-    
-    // parse received data
-    RS_RES = RS_Parse_Message(hRS, hRS->pMessagePtr, hRS->pBufferPtr); // parse message
-    
-    // RESPONSE
-    if(RS_RES != RS_SKIP) // if message not for us
-    {
-      hRS->lastPacketTick = uwTick;
-      RS_RES = RS_Response(hRS, hRS->pMessagePtr);
-    }
-    else
-    {
-			RS_Abort(hRS, ABORT_RX);
-			RS_RES = RS_Handle_Receive_Start(hRS, hRS->pMessagePtr);
-    }
-  }
-  
-  return RS_RES;  
-}
-
-
-/**  
-  * @brief  UART TX Callback: define behaviour after transmiting message.
-  * @param  hRS     - указатель на хендлер RS.
-  * @return RS_RES  - статус о состоянии RS после обработки приема.
-  * @note   Определяет поведение RS после передачи сообщения.
-  */
-RS_StatusTypeDef RS_UART_TxCpltCallback(RS_HandleTypeDef *hRS)
-{
-  RS_StatusTypeDef RS_RES = RS_OK;
-  HAL_StatusTypeDef uart_res = 0;
-  
-  //--------------ENDING TRANSMITTING-------------
-  RS_Set_TX_End(hRS);
-  RS_EnableReceive();
-//  for(int i = 0; i < hRS->sRS_Timeout; i++);
-  
-  //-----------START RECEIVING or END RS----------
-  RS_RES = RS_Handle_Receive_Start(hRS, hRS->pMessagePtr);
-  
-  return RS_RES;
-}
-
-/**  
-  * @brief  Handler for UART.
-  * @param  hRS     - указатель на хендлер RS.
-  * @note   Обрабатывает ошибки если есть и вызывает RS Коллбеки.
-  *         Добавить вызов этой функции в UARTx_IRQHandler() после HAL_UART_IRQHandler().
-  */
-void RS_UART_Handler(RS_HandleTypeDef *hRS)
-{
-  //-------------CHECK IDLE FLAG FIRST-------------	
-  /* Проверяем флаг IDLE в первую очередь - это гарантирует обработку только после idle */
-  if(__HAL_UART_GET_FLAG(hRS->huart, UART_FLAG_IDLE) && __HAL_UART_GET_IT_SOURCE(hRS->huart, UART_IT_IDLE))
-  {
-    __HAL_UART_CLEAR_IDLEFLAG(hRS->huart); // Важно: очистить флаг IDLE
-    
-    // Если прием активен и мы получили IDLE - это конец фрейма
-    if(RS_Is_RX_Busy(hRS) && hRS->f.RX_Ongoing)
-    {
-      // Останавливаем таймаут
-      if(hRS->sRS_Timeout)								
-        HAL_TIM_Base_Stop_IT(hRS->htim);
-      
-      // Получаем количество фактически принятых байтов
-      uint16_t received_bytes = hRS->huart->RxXferSize - hRS->huart->RxXferCount;
-      
-      if(received_bytes > 0)
-      {
-        // Принудительно завершаем прием (IDLE прервал наш прием)
-        RS_Abort(hRS, ABORT_RX);
-        
-        // Устанавливаем фактический размер данных
-        hRS->RS_Message_Size = received_bytes;
-        
-        // Завершаем прием в нашей структуре
-        RS_Set_RX_End(hRS);
-        
-        // Проверяем адрес Modbus перед обработкой
-        if(hRS->pBufferPtr[0] != hRS->ID) 
-        {
-          // Чужое сообщение - игнорируем и начинаем новый прием
-          RS_Abort(hRS, ABORT_RX);
-          RS_Handle_Receive_Start(hRS, hRS->pMessagePtr);
-          return;
-        }
-        
-        // Парсим наше сообщение
-        RS_StatusTypeDef parse_res = RS_Parse_Message(hRS, hRS->pMessagePtr, hRS->pBufferPtr);
-        
-        // RESPONSE
-        if(parse_res != RS_SKIP) 
-        {
-          hRS->lastPacketTick = uwTick;
-          RS_Response(hRS, hRS->pMessagePtr);
-        }
-        else
-        {
-          RS_Abort(hRS, ABORT_RX);
-          RS_Handle_Receive_Start(hRS, hRS->pMessagePtr);
-        }
-      }
-      else
-      {
-        // IDLE без данных - просто перезапускаем прием
-        RS_Abort(hRS, ABORT_RX);
-        RS_Handle_Receive_Start(hRS, hRS->pMessagePtr);
-      }
-    }
-    return; // Выходим после обработки IDLE
-  }
-  
-  //-------------STANDARD UART HANDLING-------------
-  HAL_UART_IRQHandler(hRS->huart);
-  
-  //-------------CALL RS CALLBACKS------------  
-  /* IF NO ERROR OCCURS */
-  if(hRS->huart->ErrorCode == 0) 
-  {
-    hRS->htim->Instance->CNT = 0; // reset cnt;
-    
-    /* Start timeout при получении первого байта */
-    if(hRS->sRS_Timeout)                // if timeout setted
-      if((hRS->huart->RxXferCount+1 == hRS->huart->RxXferSize) && RS_Is_RX_Busy(hRS)) // if first byte is received and receive is active
-      {
-        HAL_TIM_Base_Start_IT(hRS->htim);
-        RS_Set_RX_Active_Flags(hRS);
-      }
-    
-    /* RX Callback - теперь НЕ вызываем здесь, ждем IDLE */
-    
-    /* TX Callback - оставляем без изменений */
-    if ((hRS->huart->TxXferCount == 0U) && RS_Is_TX_Busy(hRS) &&  // if all bytes are transmited and transmit is active
-          hRS->huart->gState != HAL_UART_STATE_BUSY_TX)           // also check that receive "REALLY" isnt busy
-      RS_UART_TxCpltCallback(hRS);
-      
-    /* NOTE: RX Callback больше не вызывается здесь - ждем IDLE для гарантии конца фрейма */
-  }
-  //----------------ERRORS HANDLER----------------
-  else
-  {
-    //TrackerCnt_Err(hRS->rs_err);
-    /* de-init uart transfer */
-    RS_Abort(hRS, ABORT_RS);
-    RS_Handle_Receive_Start(hRS, hRS->pMessagePtr);
-        
-    // later, maybe, will be added specific handlers for err  
-  }
-}
-
-
-/**
-  * @brief  Handler for TIM.
-  * @param  hRS     - указатель на хендлер RS.
-  * @note   Попадание сюда = таймаут и перезапуск RS приема
-  *         Добавить вызов этой функции в TIMx_IRQHandler() после HAL_TIM_IRQHandler().
-  */
-void RS_TIM_Handler(RS_HandleTypeDef *hRS)
-{
-  HAL_TIM_IRQHandler(hRS->htim);
-  
-	HAL_TIM_Base_Stop_IT(hRS->htim);
-	RS_Abort(hRS, ABORT_RS);
-	if(hRS->pMessagePtr->MbAddr == hRS->ID) // ошибка если таймаут по нашему сообщению
-		TrackerCnt_Err(hRS->rs_err);
-  RS_Handle_Receive_Start(hRS, hRS->pMessagePtr);
-}
-//--------------------CALLBACK/HANDLER FUNCTIONS---------------------
-//-------------------------------------------------------------------
-
-
-
-//-------------------------------------------------------------------
-//--------------WEAK PROTOTYPES FOR PROCESSING MESSAGE---------------
-/** 
-  * @brief  Respond accord to received message.
-  * @param  hRS     - указатель на хендлер RS.
-  * @param  RS_msg  - указатель на структуру сообщения.
-  * @return RS_RES  - статус о результате ответа на комманду.
-  * @note   Обработка принятой комманды и ответ на неё.
-  */
-__weak RS_StatusTypeDef RS_Response(RS_HandleTypeDef *hRS, RS_MsgTypeDef *RS_msg)
-{
-  /* Redefine function for user purposes */
-  return RS_ERR;
-}
-
-/** 
-  * @brief  Collect message in buffer to transmit it.
-  * @param  hRS           - указатель на хендлер RS.
-  * @param  RS_msg        - указатель на структуру сообщения.
-  * @param  msg_uart_buff - указатель на буффер UART.
-  * @return RS_RES        - статус о результате заполнения буфера.
-  * @note   Заполнение буффера UART из структуры сообщения.
-  */
-__weak RS_StatusTypeDef RS_Collect_Message(RS_HandleTypeDef *hRS, RS_MsgTypeDef *RS_msg, uint8_t *msg_uart_buff)
-{
-  /* Redefine function for user purposes */
-  return RS_ERR;
-}
-
-/** 
-  * @brief  Parse message from buffer to process it.
-  * @param  hRS           - указатель на хендлер RS.
-  * @param  RS_msg        - указатель на структуру сообщения.
-  * @param  msg_uart_buff - указатель на буффер UART.
-  * @return RS_RES        - статус о результате заполнения структуры.
-  * @note   Заполнение структуры сообщения из буффера UART.
-  */
-__weak RS_StatusTypeDef RS_Parse_Message(RS_HandleTypeDef *hRS, RS_MsgTypeDef *RS_msg, uint8_t *msg_uart_buff)
-{
-  /* Redefine function for user purposes */
-  return RS_ERR;
-}
-
-/** 
-  * @brief  Define size of RX Message that need to be received.
-  * @param  hRS           - указатель на хендлер RS.
-  * @param  rx_data_size  - указатель на переменную для записи кол-ва байт для принятия.
-  * @return RS_RES        - статус о корректности рассчета кол-ва байт для принятия.
-  * @note   Определение сколько байтов надо принять по протоколу.
-  */
-__weak RS_StatusTypeDef RS_Define_Size_of_RX_Message(RS_HandleTypeDef *hRS, uint32_t *rx_data_size)
-{
-  /* Redefine function for user purposes */
-  return RS_ERR;
-}
-//--------------WEAK PROTOTYPES FOR PROCESSING MESSAGE---------------
-//-------------------------------------------------------------------