bt-67xx_universal_hw/modules/parameters.c

/********************************* (C) РОТЕК ***********************************
 * @module  parameters
 * @file    parameters.c
 * @version 1.0.0
 * @date    XX.XX.XXXX
 * $brief   Template
 *******************************************************************************
 * @history     Version  Author         Comment
 * XX.XX.XXXX   1.0.0    Telenkov D.A.  First release.
 *******************************************************************************
 */

#include "stm32f4xx.h"
#include "parameters.h"

#include "settings_api.h"
#include "rtc.h"
#ifndef BT6702_SERVICE
#include "snmp_api.h"
#include "snmp.h"
#include "megatec.h"
#ifdef SSH_ENABLE
#include "server.h"
#endif
#ifdef DALLAS_SENSOR_ENABLE
#include "temper.h"
#endif
#endif
#include "sntp.h"
#include "lwip/snmp.h"
#include "lwip/sys.h"
#include "common_config.h"
//#include "d_inouts.h"
#include "gpio.h"
#include "round.h"
#include "urlcode.h"
#include "sntp_api.h"
#ifdef PRINTF_STDLIB
#include <stdio.h>
#endif
#ifdef PRINTF_CUSTOM
#include "tinystdio.h"
#endif
#include <string.h>
#include <stdlib.h>
#include <math.h>

#ifdef NOTIFICATION_CONTROL_ENABLE
extern const char* name_traps[];
#endif


static bool flag_reboot = false; // флаг перезагрузки контроллера (устанавливается при смене настроек ssh)

/**
  * @brief  Структура для хранения состояний дискретных входов
  */
//extern GPIO_INPUTS_t sGpioInputs;

/**
  * @brief  Общая структура настроек
  */
extern SETTINGS_t sSettings;

/**
  * @brief  Структура для хранения временных сетевых настроек
  */
extern WEB_PARAMS_t sTempWebParams;

/**
  * @brief  Флаг подтверждения новых сетевых параметров пользователем
  */
extern bool fConfirmWebParams;

extern const float UPSPowerMass[];
extern const float UPSEfficiencyFactorMass[];

/**
  * @brief 
  */
bool GetRebootStatus(void)
{
  return flag_reboot;
}


#ifndef BT6702_SERVICE

// ************************************************************************** //
//                        Параметры UPS

/**
  * @brief
  */
void GetInputFreqStr(char *str, uint8_t *len)
{
    sprintf(str, "%0.1f", UPS.Freq_in);
    *len = strlen(str);
}

/**
  * @brief
  */
void GetInputFreqInt(float *value)
{
    *value = UPS.Freq_in;
}

/**
  * @brief
  */
void GetOutputFreqStr(char *str, uint8_t *len)
{
    sprintf(str, "%0.1f", UPS.Freq_in);
    *len = strlen(str);
}

/**
  * @brief
  */
void GetInputVoltageStr(char *str, uint8_t *len)
{
    sprintf(str, "%0.1f", UPS.VAC_in);
    *len = strlen(str);
}

/**
  * @brief
  */
void GetInputVoltageInt(float *value)
{
    *value = UPS.VAC_in;
}

/**
  * @brief
  */
void GetOutputVoltageStr(char *str, uint8_t *len)
{
    sprintf(str, "%0.1f", UPS.VAC_out);
    *len = strlen(str);
}

/**
  * @brief
  */
void GetOutputVoltageInt(float *value)
{
    *value = UPS.VAC_out;
}

/**
  * @brief
  */
void GetPowerStr(char *str, uint8_t *len)
{
    sprintf(str, "%d", UPS.Load);
    *len = strlen(str);
}

/**
  * @brief
  */
void GetPowerInt(int32_t *value)
{
    *value = UPS.Load;
}

/**
  * @brief
  */
void GetBatCapacityStr(char *str, uint8_t *len)
{
    sprintf(str, "%d", UPS.SOC);
    *len = strlen(str);
}

/**
  * @brief
  */
void GetBatCapacityInt(int32_t *value)
{
    *value = UPS.SOC;
}

/**
  * @brief
  */
void GetRuntimeStr(char *str, uint8_t *len)
{
    sprintf(str, "%d", UPS.work_time);
    *len = strlen(str);
}

/**
  * @brief
  */
void GetRuntimeInt(int32_t *value)
{
    *value = UPS.work_time;
}

/**
  * @brief
  */
void GetAKBWorktimeStr(char *str, uint8_t *len)
{
    sprintf(str, "%d", (UPS.akb_work_time / 60));
    *len = strlen(str);
}

/**
  * @brief
  */
void GetAKBWorktimeInt(int32_t *value)
{
    *value = (int32_t)(UPS.akb_work_time / 60);
}

/**
  * @brief
  */
void GetInternalTempStr(char *str, uint8_t *len)
{
#ifdef DALLAS_SENSOR_ENABLE
    if(sSettings.sTempControl[0].type_sensor == TS_AKB) {
      if (sTemperSensors[0].SensorState == 1){
        sprintf(str, "%s", "Обрыв линии");
      } else {
        sprintf(str, "%0.1f", sTemperSensors[0].Temperature);
      }
    } else if (sSettings.sTempControl[1].type_sensor == TS_AKB) {
        if (sTemperSensors[1].SensorState == 1){
        sprintf(str, "%s", "Обрыв линии");
      } else {
        sprintf(str, "%0.1f", sTemperSensors[1].Temperature);
      }
    }
    else
#endif
      {
        sprintf(str, "%0.1f", UPS.Temp);
      }

    *len = strlen(str);
}

/**
  * @brief
  */
void GetInternalTempInt(float *value)
{
#ifdef DALLAS_SENSOR_ENABLE
    if(sSettings.sTempControl[0].type_sensor == TS_AKB) {
      if (sTemperSensors[0].SensorState == 1){
        *value = 85;
      } else {
        *value = sTemperSensors[0].Temperature;
      }
    } else if (sSettings.sTempControl[1].type_sensor == TS_AKB) {
        if (sTemperSensors[1].SensorState == 1){
        *value = 85;
      } else {
        *value = sTemperSensors[1].Temperature;
      }
    }
    else
#endif
      {
        *value = UPS.Temp;
      }
}

/**
  * @brief
  */
void GetAlarmMonitorStr(char *str, uint8_t *len)
{
    sprintf(str, "%d", UPS.Alarm);
    *len = strlen(str);
}

/**
  * @brief
  */
void GetConnectMonitorStr(char *str, uint8_t *len)
{
    if (UPS.Present) {
        strcpy(str, "0");
    } else {
        strcpy(str, "1");
    }
    *len = strlen(str);
}

/**
  * @brief
  */
void GetInputCurrentStr(char *str, uint8_t *len)
{
    float value;
    if (UPS.VAC_in != 0) {
        value = (sSettings.UPS_Setting.ups_power * UPS.Load) / (100 * K_EFFICIENCY * UPS.VAC_in);
    } else {
        value = 0;
    }
    sprintf(str, "%0.3f", roundto(value, 3));
    *len = strlen(str);
}

/**
  * @brief
  */
void GetInputCurrentInt(float *value)
{
    if (UPS.VAC_in != 0) {
        *value = (sSettings.UPS_Setting.ups_power * UPS.Load) / (100 * K_EFFICIENCY * UPS.VAC_in);
    } else {
        *value = 0;
    }
}

/**
  * @brief
  */
void GetOutputCurrentStr(char *str, uint8_t *len)
{
    float value;
    if (UPS.VAC_out != 0) {
        value = (sSettings.UPS_Setting.ups_power * UPS.Load) / (100 * UPS.VAC_out);
    } else {
        value = 0;
    }
    sprintf(str, "%0.3f", roundto(value, 3));
    *len = strlen(str);
}

/**
  * @brief
  */
void GetOutputCurrentInt(float *value)
{
    if (UPS.VAC_out != 0) {
        *value = (sSettings.UPS_Setting.ups_power * UPS.Load) / (100 * UPS.VAC_out);
    } else {
        *value = 0;
    }
}

/**
  * @brief
  */
void GetVoltageAKBtStr(char *str, uint8_t *len)
{
    float value;
    if (sSettings.UPS_Setting.type_ups == ups_kestar || sSettings.UPS_Setting.type_ups == ups_offline) {
     if (UPS.Vcell_curr < 7) {
          value = AKB_NUM_CELL * (sSettings.UPS_Setting.Uakb / AKB_VOLTAGE) * UPS.Vcell_curr;
      } else {
          value = (sSettings.UPS_Setting.Uakb / AKB_VOLTAGE) * UPS.Vcell_curr;
      }
      sprintf(str, "%0.1f", roundto(value, 1)); 
    } else {
      sprintf(str, "%0.1f", roundto(UPS.Vakb_curr, 1));
    }
    *len = strlen(str);
}

/**
  * @brief
  */
void GetVoltageAKBInt(float *value)
{
  if (sSettings.UPS_Setting.type_ups == ups_kestar || sSettings.UPS_Setting.type_ups == ups_offline) {
    if (UPS.Vcell_curr < 7) {
        *value = AKB_NUM_CELL * (sSettings.UPS_Setting.Uakb / AKB_VOLTAGE) * UPS.Vcell_curr;
    } else {
        *value = (sSettings.UPS_Setting.Uakb / AKB_VOLTAGE) * UPS.Vcell_curr;
    }
  } else {
    *value = UPS.Vakb_curr;
  }
}

void GetModeStr(char *str, uint8_t *len)
{
  switch(UPS.Mode){
    case 'P':
      strcpy(str, "Power on");
    break;
    case 'S':
      strcpy(str, "Standby");
    break;
    case 'Y':
      strcpy(str, "Bypass");
    break;
    case 'L':
      strcpy(str, "OnLine");
    break;
    case 'B':
      strcpy(str, "Battery");
    break;
    case 'T':
      strcpy(str, "Battery test");
    break;
    case 'F':
      strcpy(str, "Fault");
    break;
    case 'E':
      strcpy(str, "ECO");
    break;
    case 'C':
      strcpy(str, "Converter");
    break;
    case 'D':
      strcpy(str, "Shutdown");
    break;
    default:
    break;
  }
  *len = strlen(str);
}

// ************************************************************************** //
//                             Alarms

/**
  * @brief  Индикация аварийных ситуаций
  */
void GetAlarmStr(char *str, uint8_t *len)
{
    sprintf(str, "%d", UPS.Status);
    *len = strlen(str);

}

/**
  * @brief  Индикация аварийных ситуаций
  */
void GetUPSAlarmStr(char *str, uint8_t *len)
{
    if (((UPS.Status >> 7) & 0x01) || ((UPS.Status >> 4) & 0x01) || (UPS.Alarm & 0x01)) {
        strcpy(str, "Авария");
    } else if (!((UPS.Status >> 7) & 0x01) && !((UPS.Status >> 4) & 0x01) && !(UPS.Alarm & 0x01)) {
        strcpy(str, "Норма");
    } else if (((UPS.Status >> 1) & 0x01)) {
        strcat(str, "/Отключение нагрузки");
    }

    *len = strlen(str);

}

/**
  * @brief  Индикация аварийных ситуаций
  */
void GetAKBAlarmStr(char *str, uint8_t *len)
{
    if (((UPS.Status >> 6) & 0x01) || ((UPS.Alarm >> 1) & 0x01)) {
        strcpy(str, "Авария");
    } else if (!((UPS.Status >> 6) & 0x01) && !((UPS.Alarm >> 1) & 0x01)) {
        strcpy(str, "Норма");
    } else if (((UPS.Status >> 2) & 0x01)) {
        strcat(str, "/Тестирование");
    }

    *len = strlen(str);
}

/**
  * @brief  Индикация аварийных ситуаций
  */
void GetConnectUPSAlarmStr(char *str, uint8_t *len)
{

    if (((UPS.Alarm >> 2) & 0x01)) {
        strcpy(str, "Авария");
    } else if (!((UPS.Alarm >> 2) & 0x01)) {
        strcpy(str, "Норма");
    }

    *len = strlen(str);

}

/**
  * @brief  Индикация аварийных ситуаций
  */
void GetUPSModeStr(char *str, uint8_t *len)
{
    if ((UPS.Status >> 5) & 0x01) {
        sprintf(str, "Bypass");
    } else {
        sprintf(str, "Boost or Buck");
    }

    *len = strlen(str);
}
#endif
// ************************************************************************** //
//                             Параметры даты и времени

/**
  * @brief  Дата (Ready for PRS!)
  */
void GetDateStr(char *str, uint8_t *len)
{
    TM_RTC_t data;
    uint16_t sys_year ;

    TM_RTC_GetDateTime(&data, TM_RTC_Format_BIN);
    sys_year = 2000 + data.year;

    sprintf(str, "%04i-%02i-%02i", sys_year, data.month, data.date);
    *len = strlen(str);
}

/**
  * @brief  Время (Ready for PRS!)
  */
void GetTimeStr(char *str, uint8_t *len)
{
    TM_RTC_t data;

    TM_RTC_GetDateTime(&data, TM_RTC_Format_BIN);

    sprintf(str, "%02i:%02i", data.hours, data.minutes);
    *len = strlen(str);
}

/**
  * @brief  Время (Ready for PRS!)
  */
void GetUnixTimeStr(char *str, uint8_t *len)
{
    TM_RTC_t data;

    TM_RTC_GetDateTime(&data, TM_RTC_Format_BIN);

    sprintf(str, "%d", data.unix);
    *len = strlen(str);
}

// ************************************************************************** //
//                             Параметры SNTP

/**
  * @brief  Состояние SNTP (Ready for PRS!)
  */
void GetSntpStateStr(char *str, uint8_t *len)
{
    if (sSettings.sSNTP.sntpEnable) {
        sprintf(str, "%s", "1"); //авто
        *len = strlen(str);
    } else {
        sprintf(str, "%s", "0"); //ручной
        *len = strlen(str);
    }
}

/**
  * @brief  Состояние SNTP (Ready for PRS!)
  */
void GetSntpStateStrRU(char *str, uint8_t *len)
{
    if (sSettings.sSNTP.sntpEnable) {
        sprintf(str, "%s", "авто"); //авто
        *len = strlen(str);
    } else {
        sprintf(str, "%s", "ручной"); //ручной
        *len = strlen(str);
    }
}

/**
  * @brief  IP адрес SNTP сервера (Ready for PRS!)
  */
void GetSntpServerIpStr(char *str, uint8_t *len)
{
    sprintf(str, "%s", sSettings.sSNTP.ip);
    *len = strlen(str);
}

/**
  * @brief  Часовой пояс контроллера (Ready for PRS!)
  */
void GetSntpTimeZoneStr(char *str, uint8_t *len)
{
    sprintf(str, "%0.1f", sSettings.sSNTP.timeZone);
    *len = strlen(str);
}

/**
  * @brief  Дата последней синхронизации SNTP (Ready for PRS!)
  */
void GetSntpLastDataStr(char *str, uint8_t *len)
{
    sprintf(str, "%s", sSettings.sSNTP.data);
    *len = strlen(str);
}
#ifndef BT6702_SERVICE
// ************************************************************************** //
//                             Температура с внешних датчиков
#ifdef DALLAS_SENSOR_ENABLE
/**
  * @brief
  */
void GetTempCaseStr(char *str, uint8_t *len)
{

    if(sSettings.sTempControl[0].type_sensor == TS_CABINET) {
      if (sTemperSensors[0].SensorState == 1){
        sprintf(str, "%s", "Обрыв линии");
      } else {
        sprintf(str, "%0.1f", sTemperSensors[0].Temperature);
      }
    } else if (sSettings.sTempControl[1].type_sensor == TS_CABINET) {
        if (sTemperSensors[1].SensorState == 1){
        sprintf(str, "%s", "Обрыв линии");
      } else {
        sprintf(str, "%0.1f", sTemperSensors[1].Temperature);
      }
    }
    else
      {
        sprintf(str, "%s", "Нет датчика");
      }

    *len = strlen(str);
}

/**
  * @brief
  */
void GetTempCaseInt(float *value)
{
    if(sSettings.sTempControl[0].type_sensor == TS_CABINET) {
      if (sTemperSensors[0].SensorState == 1){
        *value = 85;
      } else {
        *value = sTemperSensors[0].Temperature;
      }
    } else if (sSettings.sTempControl[1].type_sensor == TS_CABINET) {
        if (sTemperSensors[1].SensorState == 1){
        *value = 85;
      } else {
        *value = sTemperSensors[1].Temperature;
      }
    }
    else
      {
        *value = 85;
      }
}

#endif
#endif
// ************************************************************************** //
//                             Параметры реле/сухих контактов
#ifdef DINS_ENABLE
/**
  * @brief  Тип действий при срабатывание сухих контактов
  */
void GetDINTypeActStr(char *str, uint8_t *len, uint8_t num)
{
    sprintf(str, "%d", sSettings.sDINs[num].din_type_act);
    *len = strlen(str);
}

/**
  * @brief  Тип действий при срабатывание сухих контактов
  */
void GetDIN0TypeActStr(char *str, uint8_t *len)
{
    uint8_t num = 0;
    if (num < INPUTS_TOTAL_COUNT) {
      GetDINTypeActStr(str, len, num);
    } else {
      *len = 0;
    }
}

/**
  * @brief  Тип действий при срабатывание сухих контактов
  */
void GetDIN1TypeActStr(char *str, uint8_t *len)
{
    uint8_t num = 1;
    if (num < INPUTS_TOTAL_COUNT) {
      GetDINTypeActStr(str, len, num);
    } else {
      *len = 0;
    }
}

/**
  * @brief  Имя сухого контакта
  */
void GetDINNameStr(char *str, uint8_t *len, uint8_t num)
{
    strcpy(str, sSettings.sDINs[num].name);
    *len = strlen(str);
}

/**
  * @brief  Имя сухого контакта
  */
void GetDIN0NameStr(char *str, uint8_t *len)
{
    uint8_t num = 0;
    if (num < INPUTS_TOTAL_COUNT) {
      GetDINNameStr(str, len, num);
    } else {
      *len = 0;
    }
}

/**
  * @brief  Имя сухого контакта
  */
void GetDIN1NameStr(char *str, uint8_t *len)
{
    uint8_t num = 1;
    if (num < INPUTS_TOTAL_COUNT) {
      GetDINNameStr(str, len, num);
    } else {
      *len = 0;
    }
}

/**
  * @brief  Состояние сухого контакта
  */
void GetDINStatusStr(char *str, uint8_t *len, uint8_t num)
{
    sprintf(str, "%d", (get_state_din_outs(DIN1 + num) ^ 1));
    *len = strlen(str);
}

/**
  * @brief  Состояние сухого контакта
  */
void GetDIN0StatusStr(char *str, uint8_t *len)
{
    uint8_t num = 0;
    if (num < INPUTS_TOTAL_COUNT) {
      GetDINStatusStr(str, len, num);
    } else {
      *len = 0;
    }
}

/**
  * @brief  Состояние сухого контакта
  */
void GetDIN1StatusStr(char *str, uint8_t *len)
{
    uint8_t num = 1;
    if (num < INPUTS_TOTAL_COUNT) {
      GetDINStatusStr(str, len, num);
    } else {
      *len = 0;
    }
}

/**
  * @brief  Состояние сухого контакта
  */
void GetDIN0StatusStrRU(char *str, uint8_t *len)
{
    if (get_state_din_outs(DIN1) ^ 1) {
        sprintf(str, "Разомкнут" );
    } else {
        sprintf(str, "Замкнут" );
    }
    *len = strlen(str);
}
#endif
#ifdef DOUTS_ENABLE
/**
  * @brief  Источник срабатывания реле
  */
void GetROTypeActStr(char *str, uint8_t *len, uint8_t num)
{
    sprintf(str, "%d", sSettings.sRelays[num].ro_type_source);
    *len = strlen(str);
}

/**
  * @brief  Источник срабатывания реле
  */
void GetRO0TypeActStr(char *str, uint8_t *len)
{
    uint8_t num = 0;
    if (num < OUTPUTS_TOTAL_COUNT) {
      GetROTypeActStr(str, len, num);
    } else {
      *len = 0;
    }
}

/**
  * @brief  Источник срабатывания реле
  */
void GetRO1TypeActStr(char *str, uint8_t *len)
{
    uint8_t num = 1;
    if (num < OUTPUTS_TOTAL_COUNT) {
      GetROTypeActStr(str, len, num);
    } else {
      *len = 0;
    }
}

/**
  * @brief  Источник срабатывания реле
  */
void GetRO2TypeActStr(char *str, uint8_t *len)
{
    uint8_t num = 2;
    if (num < OUTPUTS_TOTAL_COUNT) {
      GetROTypeActStr(str, len, num);
    } else {
      *len = 0;
    }
}

/**
  * @brief  Состояние релейного выхода
  */
void GetDOUTStatusStr(char *str, uint8_t *len, uint8_t num)
{
#ifdef RELAY_NC
    sprintf(str, "%d", (get_state_din_outs(DOUT1 + num) ^ 1));
#endif
#ifdef RELAY_NO
    sprintf(str, "%d", get_state_din_outs(DOUT1 + num));
#endif

    *len = strlen(str);
}

/**
  * @brief  Состояние релейного выхода
  */
void GetDOUTStatusStrRU(char *str, uint8_t *len, uint8_t num)
{
#ifdef RELAY_NC
    if (get_state_din_outs(DOUT1 + num) ^ 1) {
        sprintf(str, "Замкнут");
    } else {
        sprintf(str, "Разомкнут");
    }
#endif   
#ifdef RELAY_NO
    if (get_state_din_outs(DOUT1 + num)) {
        sprintf(str, "Замкнут");
    } else {
        sprintf(str, "Разомкнут");
    }
#endif

    *len = strlen(str);
}

/**
  * @brief  Состояние релейного выхода
  */
void GetDOUT0StatusStr(char *str, uint8_t *len)
{
    uint8_t num = 0;
    if (num < OUTPUTS_TOTAL_COUNT) {
      GetDOUTStatusStr(str, len, num);
    } else {
      *len = 0;
    }
}

/**
  * @brief  Состояние релейного выхода
  */
void GetDOUT1StatusStr(char *str, uint8_t *len)
{
    uint8_t num = 1;
    if (num < OUTPUTS_TOTAL_COUNT) {
      GetDOUTStatusStr(str, len, num);
    } else {
      *len = 0;
    }
}

/**
  * @brief  Состояние релейного выхода
  */
void GetDOUT2StatusStr(char *str, uint8_t *len)
{
    uint8_t num = 2;
    if (num < OUTPUTS_TOTAL_COUNT) {
      GetDOUTStatusStr(str, len, num);
    } else {
      *len = 0;
    }
}
#endif
// ************************************************************************** //
//                             Информация

#ifndef BT6702_SERVICE
/**
  * @brief  Время работы устройства
  */
void GetWorkTimeStr(char *str, uint8_t *len)
{
    u32_t    tick;
    uint16_t day;
    uint8_t  hour;
    uint8_t  min;

    // TODO открыть с новым api для snmp
    //snmp_get_sysuptime(&tick);
    MIB2_COPY_SYSUPTIME_TO(&tick);

    day = tick / 8640000;

    tick = tick % 8640000;
    hour = tick / 360000;

    tick = tick % 360000;
    min = tick / 6000;

    sprintf(str, "%d дн. %d ч. %d мин.", day, hour, min);
    *len = strlen(str);
}
#endif
/**
  * @brief  Модель устройства
  */
void GetModelStr(char *str, uint8_t *len)
{
    *len = strlen(HW_REV);
    strncpy(str, HW_REV, *len);
}

/**
  * @brief  Название устройсва устройства
  */
void GetNameDeviceStr(char *str, uint8_t *len)
{
    *len = (uint8_t)sSettings.sSnmp.sysName.len;
    strncpy(str, sSettings.sSnmp.sysName.name, *len);
}

/**
  * @brief  Дата производства
  */
void GetProductionDataStr(char *str, uint8_t *len)
{
    *len = strlen(sSettings.sInfo.productionData);
    strncpy(str, sSettings.sInfo.productionData, *len);
}

/**
  * @brief  Версия ПО
  */
void GetVersionStr(char *str, uint8_t *len) // +
{
    *len = strlen(VERSION);
    strncpy(str, VERSION, *len);
}

/**
  * @brief  MAC адрес устройства
  */
void GetMacStr(char *str, uint8_t *len)
{
    *len = strlen(sSettings.sInfo.mac);
    strncpy(str, sSettings.sInfo.mac, *len);
}

/**
  * @brief  Серийный номер устройства
  */
void GetSerialNumberStr(char *str, uint8_t *len)
{
    *len = strlen(sSettings.sInfo.serialNumber);
    strncpy(str, sSettings.sInfo.serialNumber, *len);
}

/**
  * @brief  Владелец устройства
  */
void GetOwnerStr(char *str, uint8_t *len)
{
    *len = (uint8_t)sSettings.sSnmp.sysContact.len;
    strncpy(str, sSettings.sSnmp.sysContact.contact, *len);
}

/**
  * @brief  Местоположение устройства
  */
void GetLocationStr(char *str, uint8_t *len)
{
    *len = (uint8_t) sSettings.sSnmp.sysLocation.len;
    strncpy(str, sSettings.sSnmp.sysLocation.location, *len);
}

/**
  * @brief  Комментарии
  */
void GetCommentsStr(char *str, uint8_t *len)
{
    *len = strlen(sSettings.sInfo.comments);
    strncpy(str, sSettings.sInfo.comments, *len);
}

#ifndef BT6702_SERVICE
/**
  * @brief  Модель UPS
  */
void GetUPSModelStr(char *str, uint8_t *len)
{
    *len = strlen(UPS.model);
    strncpy(str, UPS.model, *len);
}

/**
  * @brief  Серийный номер UPS
  */
void GetUPSSerialStr(char *str, uint8_t *len)
{
    char tempStr[30];

    if (sSettings.UPS_Setting.serial == 0) {
      *len = strlen(UPS.serial);
      strncpy(str, UPS.serial, *len);
    } else {
      memset(tempStr, 0, sizeof(tempStr));
      sprintf(tempStr, "%d", sSettings.UPS_Setting.serial);
      strcpy(str, tempStr);
      *len = strlen(str);
    }
}

/**
  * @brief  Версия UPS ПО
  */
void GetUPSVersionStr(char *str, uint8_t *len) // +
{
    *len = strlen(UPS.vertion);
    strncpy(str, UPS.vertion, *len);
}
#endif

#ifdef NOTIFICATION_CONTROL_ENABLE
// ************************************************************************** //
//                              Параметры уведомления

/**
  * @brief  Параметр разрешения отправки трапа
  */
void GetNotificationTrapsStateStr(char *str, uint8_t *len, uint8_t num)
{
    if ( sSettings.sFlagNotification[num] ) {
        sprintf(str, "%s", "true");
        *len = strlen(str);
    } else {
        sprintf(str, "%s", "false");
        *len = strlen(str);
    }
}

/**
  * @brief  Параметр разрешения отправки трапа
  */
void GetNotificationTrapsStateStr2(char *str, uint8_t *len, uint8_t num)
{
    if ( sSettings.sFlagNotification[num] ) {
        sprintf(str, "%s", "ENA");
        *len = strlen(str);
    } else {
        sprintf(str, "%s", "DIS");
        *len = strlen(str);
    }
}

/**
  * @brief Длинное имя трапа
  */
void GetTrapLongNameStr(char *str, uint8_t *len, uint8_t num)
{
    sprintf(str, "%s", name_traps[num]);
    *len = strlen(str);
}

#endif

// ************************************************************************** //
//                          Настройки аутентификации

void GetUserLogin(uint8_t user_id, char *str, uint8_t *len)
{
    sprintf(str, "%s", sSettings.sAuth[user_id].login);
    *len = strlen(str);
}

void GetUserPassword(uint8_t user_id, char *str, uint8_t *len)
{
    sprintf(str, "%s", sSettings.sAuth[user_id].password);
    *len = strlen(str);
}

void GetUserLevel(uint8_t user_id, char *str, uint8_t *len)
{
    sprintf(str, "%d", sSettings.sAuth[user_id].level);
    *len = strlen(str);
}

void GetUserLevelInt(uint8_t user_id, uint8_t *value)
{
    *value = sSettings.sAuth[user_id].level;
}


// ************************************************************************** //
//                             Параметры WEB

/**
  * @brief  Текущий IP адрес
  */
void GetIpStr(char *str, uint8_t *len)
{
    /* Если сейчас временные настройки */
    if (sSettings.sFlags.netsettingsChanged) {
        sprintf(str, "%s", sSettings.sWebTempParams.ip);
    } else {
        sprintf(str, "%s", sSettings.sWebParams.ip);
    }

    *len = strlen(str);
}

/**
  * @brief  Текущий шлюз
  */
void GetGatewayStr(char *str, uint8_t *len)
{
    /* Если сейчас временные настройки */
    if (sSettings.sFlags.netsettingsChanged) {
        sprintf(str, "%s", sSettings.sWebTempParams.gate);
    } else {
        sprintf(str, "%s", sSettings.sWebParams.gate);
    }

    *len = strlen(str);
}

/**
  * @brief  Текущая маска подсети
  */
void GetMaskStr(char *str, uint8_t *len)
{
    /* Если сейчас временные настройки */
    if (sSettings.sFlags.netsettingsChanged) {
        sprintf(str, "%s", sSettings.sWebTempParams.mask);
    } else {
        sprintf(str, "%s", sSettings.sWebParams.mask);
    }

    *len = strlen(str);
}

/**
  * @brief  Настройка DHCP
  */
void GetDhcpStateStr(char *str, uint8_t *len)
{
    /* Если сейчас временные настройки */
    if (sSettings.sFlags.netsettingsChanged) {
        if (sSettings.sWebTempParams.dhcpEnable) {
            *str = '1';
        } else {
            *str = '0';
        }
    } else {
        if (sSettings.sWebParams.dhcpEnable) {
            *str = '1';
        } else {
            *str = '0';
        }
    }

    *len = 1;
}

/**
  * @brief  Настройка DHCP
  */
void GetDhcpStateUDP(char *str, uint8_t *len)
{
    /* Если сейчас временные настройки или был загружен файл конфигурации */
    if (sSettings.sFlags.netsettingsChanged) {
        if (sSettings.sWebTempParams.dhcpEnable) {
            sprintf(str, "%s", "True");
        } else {
            sprintf(str, "%s", "False");
        }
    } else {
        if (sSettings.sWebParams.dhcpEnable) {
            sprintf(str, "%s", "True");
        } else {
            sprintf(str, "%s", "False");
        }
    }

    *len = strlen(str);
}

/**
  * @brief  Настройка DHCP
  */
void GetDhcpStateStrRu(char *str, uint8_t *len)
{
    /* Если сейчас временные настройки или был загружен файл конфигурации */
    if (sSettings.sFlags.netsettingsChanged) {
        if (sSettings.sWebTempParams.dhcpEnable) {
            sprintf(str, "%s", "Вкл");
        } else {
            sprintf(str, "%s", "Откл");
        }
    } else {
        if (sSettings.sWebParams.dhcpEnable) {
            sprintf(str, "%s", "Вкл");
        } else {
            sprintf(str, "%s", "Откл");
        }
    }

    *len = strlen(str);
}

#ifdef WHITELIST_ENABLE
// ************************************************************************** //
//                             Параметры доверительных хостов

/**
  * @brief  диапазон доверительных хостов
  */
void GetWhiteListSTR(char *str, uint8_t *len, uint8_t num)
{
    if (sSettings.sFlags.netsettingsChanged) {
        strcpy(str, sSettings.sWhiteListTemp[num].ip_range);
    } else {
        strcpy(str, sSettings.sWhiteList[num].ip_range);
    }
    *len = strlen(str);
}

/**
  * @brief первый диапазон доверительных хостов
  */
void GetWhiteList1STR(char *str, uint8_t *len)
{
    GetWhiteListSTR(str, len, 0);
}

/**
  * @brief второй диапазон доверительных хостов
  */
void GetWhiteList2STR(char *str, uint8_t *len)
{
    GetWhiteListSTR(str, len, 1);
}

/**
  * @brief третий диапазон доверительных хостов
  */
void GetWhiteList3STR(char *str, uint8_t *len)
{
    GetWhiteListSTR(str, len, 2);
}

/**
  * @brief четвертый диапазон доверительных хостов
  */
void GetWhiteList4STR(char *str, uint8_t *len)
{
    GetWhiteListSTR(str, len, 3);
}

/**
  * @brief пятый диапазон доверительных хостов
  */
void GetWhiteList5STR(char *str, uint8_t *len)
{
    GetWhiteListSTR(str, len, 4);
}

/**
  * @brief  маска диапазона доверительных хостов
  */
void GetWhiteListMask(uint32_t *value, uint8_t num)
{
    if (sSettings.sFlags.netsettingsChanged) {
        *value = sSettings.sWhiteListTemp[num].mask;
    } else {
        *value = sSettings.sWhiteList[num].mask;
    }
}

/**
  * @brief  ip диапазона доверительных хостов
  */
void GetWhiteListIP(uint32_t *value, uint8_t num)
{
    if (sSettings.sFlags.netsettingsChanged) {
        *value = sSettings.sWhiteListTemp[num].ip;
    } else {
        *value = sSettings.sWhiteList[num].ip;
    }
}

#endif

#ifdef PORTGW_ENABLE
// ************************************************************************** //
//                             Параметры прозрачного порта

/**
  * @brief  Включен/Выключен
  */
void GetPortGwEnabledStr(char *str, uint8_t *len)
{
    if (sSettings.sPortGw.enabled) {
        sprintf(str, "%s", "true");
    } else {
        sprintf(str, "%s", "false");
    }
    *len = strlen(str);
}

/**
  * @brief  IP-адрес
  */
void GetPortGwIpStr(char *str, uint8_t *len)
{
    sprintf(str, "%s", sSettings.sPortGw.ip);
    *len = strlen(str);
}

/**
  * @brief  Сетевой порт
  */
void GetPortGwPortnumStr(char *str, uint8_t *len)
{
    sprintf(str, "%d", sSettings.sPortGw.port);
    *len = strlen(str);
}

/**
  * @brief Скорость передачи данных
  */
void GetPortGwBaudStr(char *str, uint8_t *len)
{
    sprintf(str, "%d", sSettings.sPortGw.baud);
    *len = strlen(str);
}

/**
  * @brief Четность
  */
void GetPortGwParityStr(char *str, uint8_t *len)
{
    if (sSettings.sPortGw.parity == GW_EVEN_PAR) {
        sprintf(str, "%s", "ev");
    } else if (sSettings.sPortGw.parity == GW_ODD_PAR) {
        sprintf(str, "%s", "od");
    } else {
        sprintf(str, "%s", "no");
    }

    *len = strlen(str);
}

/**
  * @brief Число бит данных
  */
void GetPortGwDatabitsStr(char *str, uint8_t *len)
{
    sprintf(str, "%d", sSettings.sPortGw.databits);
    *len = strlen(str);
}

/**
  * @brief Число стоп-бит
  */
void GetPortGwStopbitsStr(char *str, uint8_t *len)
{
    sprintf(str, "%d", sSettings.sPortGw.stopbits);
    *len = strlen(str);
}
#endif

#ifdef DALLAS_SENSOR_ENABLE
// ************************************************************************** //
//                             Параметры датчика температуры

/**
  * @brief  Размещение датчика температуры 1
  */
void GetTS1locationStr(char *str, uint8_t *len)
{
    sprintf(str, "%d", sSettings.sTempControl[0].type_sensor);
    *len = strlen(str);
}

/**
  * @brief  Размещение датчика температуры 2
  */
void GetTS2locationStr(char *str, uint8_t *len)
{
    sprintf(str, "%d", sSettings.sTempControl[1].type_sensor);
    *len = strlen(str);
}

#endif

// ************************************************************************** //
//                             Параметры SNMP

/**
  * @brief  Текущее community для чтения
  */
void GetReadCommunity(char *str, uint8_t *len)
{
    sprintf(str, "%s", sSettings.sSnmp.readCommunity);
    *len = strlen(str);
}

/**
  * @brief  Текущее community для записи
  */
void GetWriteCommunity(char *str, uint8_t *len)
{
    sprintf(str, "%s", sSettings.sSnmp.writeCommunity);
    *len = strlen(str);
}

/**
  * @brief  IP SNMP менеджера
  */
void GetManagerIp(char *str, uint8_t *len)
{
    sprintf(str, "%s", sSettings.sSnmp.managerIP);
    *len = strlen(str);
}

void GetManagerIp2(char *str, uint8_t *len)
{
    sprintf(str, "%s", sSettings.sSnmp.managerIP2);
    *len = strlen(str);
}

void GetManagerIp3(char *str, uint8_t *len)
{
    sprintf(str, "%s", sSettings.sSnmp.managerIP3);
    *len = strlen(str);
}

void GetManagerIp4(char *str, uint8_t *len)
{
    sprintf(str, "%s", sSettings.sSnmp.managerIP4);
    *len = strlen(str);
}

void GetManagerIp5(char *str, uint8_t *len)
{
    sprintf(str, "%s", sSettings.sSnmp.managerIP5);
    *len = strlen(str);
}

#ifdef RADIUS_SERVER_ENABLE
// ************************************************************************** //
//                             Параметры RADIUS

/**
  * @brief  Текущий IP адрес
  */
void GetRDSIpStr(char *str, uint8_t *len)
{
    sprintf(str, "%s", sSettings.sRADIUS.ServerIP);

    *len = strlen(str);
}

/**
  * @brief Текущий Порт
  */
void GetRDSPortStr(char *str, uint8_t *len)
{
    sprintf(str, "%d", sSettings.sRADIUS.port);

    *len = strlen(str);
}

/**
  * @brief  Текущий Код access
  */
void GetRDSKeyAccesstStr(char *str, uint8_t *len)
{
    sprintf(str, "%d", sSettings.sRADIUS.key_access);

    *len = strlen(str);
}

/**
  * @brief  Текущая пароль RADIUS
  */
void GetRDSPasswordkStr(char *str, uint8_t *len)
{
    sprintf(str, "%s", sSettings.sRADIUS.rds_password);

    *len = strlen(str);
}

/**
  * @brief  Настройка вкл/ выкл RADIUS сервера
  */
void GetRDSEnableStateStr(char *str, uint8_t *len)
{
    if (sSettings.sRADIUS.RDSEnable) {
        *str = '1';
    } else {
        *str = '0';
    }

    *len = 1;
}

/**
  * @brief  Настройка вкл/ выкл авторизации
  */
void GetAuthEnableStateStr(char *str, uint8_t *len)
{
    if (sSettings.sRADIUS.Auth_enable) {
        *str = '1';
    } else {
        *str = '0';
    }

    *len = 1;
}

#endif

#ifdef TELNET_ENABLE
// ************************************************************************** //
//                             Параметры Telnet

/**
  * @brief Текущий Порт
  */
void GetTelnetPortStr(char *str, uint8_t *len)
{
    sprintf(str, "%d", sSettings.sTelnet.port);

    *len = strlen(str);
}

/**
  * @brief  Настройка вкл/ выкл Telnet сервера
  */
void GetTelnetEnableStateStr(char *str, uint8_t *len)
{
    if (sSettings.sTelnet.TelnetEnable) {
        *str = '1';
    } else {
        *str = '0';
    }

    *len = 1;
}

#if defined SSH_ENABLE
// ************************************************************************** //
//                             Параметры SSH

/**
  * @brief Текущий Порт
  */
void GetSSHPortStr(char *str, uint8_t *len)
{
    sprintf(str, "%d", sSettings.sSSH.port);

    *len = strlen(str);
}

/**
  * @brief  Настройка вкл/ выкл SSH сервера
  */
void GetSSHEnableStateStr(char *str, uint8_t *len)
{
    if (sSettings.sSSH.SSHEnable) {
        *str = '1';
    } else {
        *str = '0';
    }

    *len = 1;
}
#endif // SSH_ENABLE
#endif // TELNET_ENABLE
#ifdef HARDWARE_BT6711
void GetFTPServer(char *str, uint8_t *len)
{
  *len = sprintf(str, "%s", ipaddr_ntoa(&sSettings.sFTPUpdate.server_ip));
}
void GetFTPPort(char *str, uint8_t *len)
{
  *len = sprintf(str, "%d", sSettings.sFTPUpdate.server_port);
}
void GetFTPPath(char *str, uint8_t *len)
{
  *len = sprintf(str, "%s", sSettings.sFTPUpdate.remote_path);
}
void GetFTPLogin(char *str, uint8_t *len)
{
  *len = sprintf(str, "%s", sSettings.sFTPUpdate.user);
}
void GetFTPPassword(char *str, uint8_t *len)
{
  *len = sprintf(str, "%s", sSettings.sFTPUpdate.pass);
}
#endif // HARDWARE_BT6711


// ************************************************************************** //
//                          Флаги

/**
  * @brief  Вернуть признак изменения сетевых параметров
  */
void GetWebReinitFlag(char *str, uint8_t *len)
{
    if (sSettings.sFlags.netsettingsChanged) {
        sprintf(str, "%s", "true");
        *len = strlen(str);
    } else {
        sprintf(str, "%s", "false");
        *len = strlen(str);
    }

}

// ************************************************************************** //
//                             Параметры настройки ИБП

/**
  * @brief  Минимальное напряжение на ячейках АКБ
  */
void GetUPSVoltCellMinStr(char *str, uint8_t *len)
{
    sprintf(str, "%0.2f", roundto(sSettings.UPS_Setting.Ucellmin, 2));
    *len = strlen(str);
}

/**
  * @brief  Минимальное напряжение на ячейках АКБ
  */
void GetUPSVoltCellMinInt(float *value)
{
    *value = sSettings.UPS_Setting.Ucellmin;
}

/**
  * @brief  Максимальное напряжение на ячейках АКБ
  */
void GetUPSVoltCellMaxStr(char *str, uint8_t *len)
{
    sprintf(str, "%0.2f", roundto(sSettings.UPS_Setting.Ucellmax, 2));
    *len = strlen(str);
}

/**
  * @brief  Максимальное напряжение на ячейках АКБ
  */
void GetUPSVoltCellMaxInt(float *value)
{
    *value = sSettings.UPS_Setting.Ucellmax;
}

/**
  * @brief Дата замены АКБ
  */
void GetDataNextChangeAKBStrRU(char *str, uint8_t *len)
{
    if (sSettings.UPS_Setting.set_data == 0) {
        sprintf(str, "%s", "не установлена");
        *len = strlen(str);
        return;
    }
    TM_RTC_t data;
    uint16_t sys_year;
    uint32_t data_change = sSettings.UPS_Setting.set_data + (31536000 * sSettings.UPS_Setting.life_time);

    memset(&data, 0, sizeof(data));

    TM_RTC_GetDateTimeFromUnix(&data, data_change);
    sys_year = 2000 + data.year;

    sprintf(str, "%04i-%02i-%02i", sys_year, data.month, data.date);
    *len = strlen(str);
}

/**
  * @brief Дата замены АКБ
  */
void GetDataNextChangeAKBStr(char *str, uint8_t *len)
{
    if (sSettings.UPS_Setting.set_data == 0) {
        *len = 0;
        return;
    }
    TM_RTC_t data;
    uint16_t sys_year;
    uint32_t data_change = sSettings.UPS_Setting.set_data + (31536000 * sSettings.UPS_Setting.life_time);

    memset(&data, 0, sizeof(data));

    TM_RTC_GetDateTimeFromUnix(&data, data_change);
    sys_year = 2000 + data.year;

    sprintf(str, "%04i-%02i-%02i", sys_year, data.month, data.date);
    *len = strlen(str);
}

/**
  * @brief Дата установки АКБ
  */
void GetDataSetAKBStr(char *str, uint8_t *len)
{
    if (sSettings.UPS_Setting.set_data == 0) {
        *len = 0;
        return;
    }
    TM_RTC_t data;
    uint16_t sys_year;

    TM_RTC_GetDateTimeFromUnix(&data, sSettings.UPS_Setting.set_data);
    sys_year = 2000 + data.year;

    sprintf(str, "%04i-%02i-%02i", sys_year, data.month, data.date);
    *len = strlen(str);
}

/**
  * @brief Срок службы АКБ
  */
void GetLifeTimeAKBStr(char *str, uint8_t *len)
{
    sprintf(str, "%d", (int32_t)sSettings.UPS_Setting.life_time);

    *len = strlen(str);
}

/**
  * @brief Номинальное напряжение АКБ
  */
void GetVoltageAKBNominalStr(char *str, uint8_t *len)
{
    sprintf(str, "%d", (int32_t)sSettings.UPS_Setting.Uakb);
    *len = strlen(str);
}

/**
  * @brief Полная мощность АКБ
  */
void GetUPSPowerStr(char *str, uint8_t *len)
{
    sprintf(str, "%d", (int32_t)sSettings.UPS_Setting.ups_power);
    *len = strlen(str);
}

/**
  * @brief Полная мощность АКБ
  */
void GetUPSPowerEnumStr(char *str, uint8_t *len)
{
    for(uint8_t i = 0; i < ups_power_num_max; i ++) {
      if(sSettings.UPS_Setting.ups_power == UPSPowerMass[i]) {
        sprintf(str, "%d", (int32_t)i);
        break;
      }
    }
    *len = strlen(str);
}

/**
  * @brief КПД ИБП
  */
void GetUPSEfficiencyFactorInt(float *value)
{
    for(uint8_t i = 0; i < ups_power_num_max; i ++) {
      if(sSettings.UPS_Setting.ups_power == UPSPowerMass[i]) {
        *value = UPSEfficiencyFactorMass[i];
        break;
      }
    }
}

/**
  * @brief Емкость АКБ
  */
void GetCapacityNominalAKBStr(char *str, uint8_t *len)
{
    sprintf(str, "%d", (int32_t)sSettings.UPS_Setting.common_capacity);
    *len = strlen(str);
}

/**
  * @brief Емкость АКБ
  */
void GetCapacityNominalAKBInt(int32_t *value)
{
    *value = (int32_t)sSettings.UPS_Setting.common_capacity;
}

// ************************************************************************** //
//                             Параметры менеджера аварийных событий

/**
  * @brief Верхняя граница VAC
  */
void GetVACAlarmHighRangeStr(char *str, uint8_t *len)
{
    sprintf(str, "%d", (int)sSettings.sAlarmManager.ac_output_range.high);

    *len = strlen(str);
}

/**
  * @brief Верхняя граница VAC
  */
void GetVACAlarmHighRangeInt(int32_t *value)
{
    *value = (int)sSettings.sAlarmManager.ac_output_range.high;
}

/**
  * @brief Нижняя граница VAC
  */
void GetVACAlarmLowRangeStr(char *str, uint8_t *len)
{
    sprintf(str, "%d", (int)sSettings.sAlarmManager.ac_output_range.low);

    *len = strlen(str);
}

/**
  * @brief Нижняя граница VAC
  */
void GetVACAlarmLowRangeInt(int32_t *value)
{
    *value = (int)sSettings.sAlarmManager.ac_output_range.low;
}

/**
  * @brief Гистерезис (VAC)
  */
void GetVACAlarmHisteStr(char *str, uint8_t *len)
{
    sprintf(str, "%0.1f", sSettings.sAlarmManager.ac_output_range.hyst);

    *len = strlen(str);
}

/**
  * @brief Гистерезис (VAC)
  */
void GetVACAlarmHisteInt(float *value)
{
    *value = sSettings.sAlarmManager.ac_output_range.hyst;
}
#ifdef VAC_IN_MONITOR
/**
  * @brief Верхняя граница входящего напряжения
  */
void GetVACInputAlarmHighRangeStr(char *str, uint8_t *len)
{
    sprintf(str, "%d", (int)sSettings.sAlarmManager.ac_input_range.high);

    *len = strlen(str);
}

/**
  * @brief Верхняя граница входящего напряжения
  */
void GetVACInputAlarmHighRangeInt(int32_t *value)
{
    *value = (int)sSettings.sAlarmManager.ac_input_range.high;
}

/**
  * @brief Нижняя граница входящего напряжения
  */
void GetVACInputAlarmLowRangeStr(char *str, uint8_t *len)
{
    sprintf(str, "%d", (int)sSettings.sAlarmManager.ac_input_range.low);

    *len = strlen(str);
}

/**
  * @brief Нижняя граница входящего напряжения
  */
void GetVACInputAlarmLowRangeInt(int32_t *value)
{
    *value = (int)sSettings.sAlarmManager.ac_input_range.low;
}

/**
  * @brief Гистерезис входящего напряжения
  */
void GetVACinputAlarmHisteStr(char *str, uint8_t *len)
{
    sprintf(str, "%0.1f", sSettings.sAlarmManager.ac_input_range.hyst);

    *len = strlen(str);
}

/**
  * @brief Гистерезис входящего напряжения
  */
void GetVACinputAlarmHisteInt(float *value)
{
    *value = sSettings.sAlarmManager.ac_input_range.hyst;
}
#endif
/**
  * @brief Верхняя граница температуры
  */
void GetTemperatureAlarmHighRangeStr(char *str, uint8_t *len)
{
    sprintf(str, "%d", (int)sSettings.sAlarmManager.Temprature_range.high);

    *len = strlen(str);
}

/**
  * @brief Верхняя граница температуры
  */
void GetTemperatureAlarmHighRangeInt(int32_t *value)
{
    *value = (int)sSettings.sAlarmManager.Temprature_range.high;
}

/**
  * @brief Нижняя граница температуры
  */
void GetTemperatureAlarmLowRangeStr(char *str, uint8_t *len)
{
    sprintf(str, "%d", (int)sSettings.sAlarmManager.Temprature_range.low);

    *len = strlen(str);
}

/**
  * @brief Нижняя граница температуры
  */
void GetTemperatureAlarmLowRangeInt(int32_t *value)
{
    *value = (int)sSettings.sAlarmManager.Temprature_range.low;
}

/**
  * @brief Гистерезис (температура)
  */
void GetTemperatureAlarmHisteStr(char *str, uint8_t *len)
{
    sprintf(str, "%0.1f", sSettings.sAlarmManager.Temprature_range.hyst);

    *len = strlen(str);
}

/**
  * @brief Гистерезис (температура)
  */
void GetTemperatureAlarmHisteInt(float *value)
{
    *value = sSettings.sAlarmManager.Temprature_range.hyst;
}

#if !(HARDWARE_BT6709 || HARDWARE_BT6709_MTS)

/**
  * @brief Верхняя граница температуры
  */
void GetTemperatureCabinetAlarmHighRangeStr(char *str, uint8_t *len)
{
    sprintf(str, "%d", (int)sSettings.sAlarmManager.Temprature_cabinet_range.high);

    *len = strlen(str);
}

/**
  * @brief Верхняя граница температуры
  */
void GetTemperatureCabinetAlarmHighRangeInt(int32_t *value)
{
    *value = (int)sSettings.sAlarmManager.Temprature_cabinet_range.high;
}

/**
  * @brief Нижняя граница температуры
  */
void GetTemperatureCabinetAlarmLowRangeStr(char *str, uint8_t *len)
{
    sprintf(str, "%d", (int)sSettings.sAlarmManager.Temprature_cabinet_range.low);

    *len = strlen(str);
}

/**
  * @brief Нижняя граница температуры
  */
void GetTemperatureCabinetAlarmLowRangeInt(int32_t *value)
{
    *value = (int)sSettings.sAlarmManager.Temprature_cabinet_range.low;
}

/**
  * @brief Гистерезис (температура)
  */
void GetTemperatureCabinetAlarmHisteStr(char *str, uint8_t *len)
{
    sprintf(str, "%0.1f", sSettings.sAlarmManager.Temprature_cabinet_range.hyst);

    *len = strlen(str);
}

/**
  * @brief Гистерезис (температура)
  */
void GetTemperatureCabinetAlarmHisteInt(float *value)
{
    *value = sSettings.sAlarmManager.Temprature_cabinet_range.hyst;
}

#endif

/**
  * @brief Верхняя граница нагрузки
  */
void GetLoadAlarmHighRangeStr(char *str, uint8_t *len)
{
    sprintf(str, "%d", (int)sSettings.sAlarmManager.load_range.high);

    *len = strlen(str);
}

/**
  * @brief Верхняя граница нагрузки
  */
void GetLoadAlarmHighRangeInt(int32_t *value)
{
    *value = (int)sSettings.sAlarmManager.load_range.high;
}

/**
  * @brief Гистерезис (нагрузки)
  */
void GetLoadAlarmHisteStr(char *str, uint8_t *len)
{
    sprintf(str, "%0.1f", sSettings.sAlarmManager.load_range.hyst);

    *len = strlen(str);
}

/**
  * @brief Гистерезис (нагрузки)
  */
void GetLoadAlarmHisteInt(float *value)
{
    *value = sSettings.sAlarmManager.load_range.hyst;
}

// ************************************************************************** //
//                             Установка параметрв
// ************************************************************************** //

/**
  * @brief  Установить признак обновления ПО.
  */
void SetLoadMode(void)
{
    /* Set loadMode = 1 */
    RTC_WriteBackupRegister(RTC_BKP_DR1, 1);
    /* Set bootTry = 0 */
    RTC_WriteBackupRegister(RTC_BKP_DR2, 0);
}

/**
  * @brief  Установить признак изменения сетевых параметров
  */
void SetWebReinitFlag(bool value)
{
    sSettings.sFlags.netsettingsChanged = value;
}

/**
  * @brief  Установить флаг подтверждения сетевых настроек пользователем
  */
void SetConfirmWebParamsFlag(void)
{
    fConfirmWebParams = true;
}

#ifdef NOTIFICATION_CONTROL_ENABLE
// ************************************************************************** //
//                              Параметры уведомления

/**
  * @brief  Параметр разрешения отправки
  */
void SetNotificationFlagsStr(uint8_t *value, uint8_t num)
{
    sSettings.sFlagNotification[num] = *value;
}
#endif
// ************************************************************************** //
//                             Сетевые параметры
/**
  * @brief  IP адрес
  */
void SetIPStr(char *str)
{
    //strcpy(sSettings.sWebParams.ip, str);
    strcpy(sSettings.sWebTempParams.ip, str);
}

/**
  * @brief  Шлюз
  */
void SetGatewayStr(char *str)
{
    //strcpy(sSettings.sWebParams.gate, str);
    strcpy(sSettings.sWebTempParams.gate, str);
}

/**
  * @brief  Текущая маска подсети
  */
void SetMaskStr(char *str)
{
    //strcpy(sSettings.sWebParams.mask, str);
    strcpy(sSettings.sWebTempParams.mask, str);
}

/**
  * @brief  Настройка DHCP
  */
void SetDhcpStateStr(char *str)
{
    if (strncmp(str, "on", 2) == 0)
        //sSettings.sWebParams.dhcpEnable = 1;
    {
        sSettings.sWebTempParams.dhcpEnable = 1;
    } else
        //sSettings.sWebParams.dhcpEnable = 0;
    {
        sSettings.sWebTempParams.dhcpEnable = 0;
    }
}

/**
  * @brief  Настройка DHCP
  */
void SetUDPDhcpStateStr(char *str)
{
    if (strncmp(str, "True", 4) == 0) {
        sSettings.sWebTempParams.dhcpEnable = 1;
    } else if (strncmp(str, "False", 5) == 0) {
        sSettings.sWebTempParams.dhcpEnable = 0;
    }
}

#ifdef WHITELIST_ENABLE
// ************************************************************************** //
//                             Параметры довверительных хостов

/**
  * @brief  диапазон доверительных хостов
  */
void SetWhiteListSTR(char *str, uint8_t num)
{
    char ip_str[20];
    char *mask_str;
    uint32_t mask;
    uint8_t num_octet = 0;

    strcpy(sSettings.sWhiteListTemp[num].ip_range, str);
    if (strlen(sSettings.sWhiteListTemp[num].ip_range) != 0) {
        mask_str = strstr(sSettings.sWhiteListTemp[num].ip_range, "/");
        if (mask_str != NULL) {
            mask = atoi(&mask_str[1]);
            sSettings.sWhiteListTemp[num].mask = 0;
            for (uint8_t i = 0; i < mask; i ++) {
                if (i < 8) {
                    num_octet = 1;
                } else {
                    num_octet = i / 8 + 1;
                }
                sSettings.sWhiteListTemp[num].mask |= (1 << (8 * num_octet - 1 - (i - 8 * (num_octet - 1))));
            }
            memset(ip_str, 0, 20);
            strncpy(ip_str, sSettings.sWhiteListTemp[num].ip_range, (mask_str - sSettings.sWhiteListTemp[num].ip_range));
            sSettings.sWhiteListTemp[num].ip = ipaddr_addr(ip_str);
        } else {
            memset(&sSettings.sWhiteListTemp[num], 0, sizeof(sSettings.sWhiteListTemp[num]));
            sSettings.sWhiteListTemp[num].mask = 0;
            sSettings.sWhiteListTemp[num].ip = 0;
        }
    } else {
            memset(&sSettings.sWhiteListTemp[num], 0, sizeof(sSettings.sWhiteListTemp[num]));
            sSettings.sWhiteListTemp[num].mask = 0;
            sSettings.sWhiteListTemp[num].ip = 0;
    }
}

/**
  * @brief  Первый диапазон доверительных хостов
  */
void SetWhiteList1STR(char *str)
{
  SetWhiteListSTR(str, 0);
}

/**
  * @brief  Второй диапазон доверительных хостов
  */
void SetWhiteList2STR(char *str)
{
  SetWhiteListSTR(str, 1);
}

/**
  * @brief  Третий диапазон доверительных хостов
  */
void SetWhiteList3STR(char *str)
{
  SetWhiteListSTR(str, 2);
}

/**
  * @brief  Четвертый диапазон доверительных хостов
  */
void SetWhiteList4STR(char *str)
{
  SetWhiteListSTR(str, 3);
}

/**
  * @brief  Пятый диапазон доверительных хостов
  */
void SetWhiteList5STR(char *str)
{
  SetWhiteListSTR(str, 4);
}

#endif

#ifdef PORTGW_ENABLE
// ************************************************************************** //
//                             Параметры прозрачного порта

/**
  * @brief  Включен/Выключен
  */
void SetPortGwEnabledStr(char *str)
{
    if (strncmp(str, "on", 2) == 0) {
        sSettings.sPortGw.enabled = true;
    } else {
        sSettings.sPortGw.enabled = false;
    }
}

/**
  * @brief  Сетевой порт
  */
void SetPortGwPortnumStr(char *str)
{
    sSettings.sPortGw.port = atoi(str);
}

/**
  * @brief Скорость передачи данных
  */
void SetPortGwBaudStr(char *str)
{
    sSettings.sPortGw.baud = atoi(str);
}

/**
  * @brief Четность
  */
void SetPortGwParityStr(char *str)
{
    if (strncmp(str, "no", 2) == 0) {
        sSettings.sPortGw.parity = GW_NO_PAR;
    } else if (strncmp(str, "od", 2) == 0) {
        sSettings.sPortGw.parity = GW_ODD_PAR;
    } else if (strncmp(str, "ev", 2) == 0) {
        sSettings.sPortGw.parity = GW_EVEN_PAR;
    }
}

/**
  * @brief Число бит данных
  */
void SetPortGwDatabitsStr(char *str)
{
    sSettings.sPortGw.databits = atoi(str);
}

/**
  * @brief Число стоп-бит
  */
void SetPortGwStopbitsStr(char *str)
{
    sSettings.sPortGw.stopbits = atoi(str);
}
#endif

#ifdef DALLAS_SENSOR_ENABLE
// ************************************************************************** //
//                             Параметры датчика температуры

/**
  * @brief  Размещение датчика температуры 1
  */
void SetTS1locationStr(char *str)
{
    sSettings.sTempControl[0].type_sensor = atoi(str);
}

/**
  * @brief  Размещение датчика температуры 2
  */
void SetTS2locationStr(char *str)
{
    sSettings.sTempControl[1].type_sensor = atoi(str);
}

#endif

// ************************************************************************** //
//                             Параметры SNMP

/**
  * @brief  Community для чтения
  */
void SetReadCommunity(char *str)
{
    strcpy(sSettings.sSnmp.readCommunity, str);
}

/**
  * @brief  Community для записи
  */
void SetWriteCommunity(char *str)
{
    strcpy(sSettings.sSnmp.writeCommunity, str);
}

#ifndef BT6702_SERVICE
/**
  * @brief  IP SNMP менеджера
  */
void SetManagerIp(char *str)
{
    strcpy(sSettings.sSnmp.managerIP, str);
    SNMP_SetManagerIP(sSettings.sSnmp.managerIP);
}

void SetManagerIp2(char *str)
{
    strcpy(sSettings.sSnmp.managerIP2, str);
    SNMP_SetManagerIP(sSettings.sSnmp.managerIP2);
}

void SetManagerIp3(char *str)
{
    strcpy(sSettings.sSnmp.managerIP3, str);
    SNMP_SetManagerIP(sSettings.sSnmp.managerIP3);
}

void SetManagerIp4(char *str)
{
    strcpy(sSettings.sSnmp.managerIP4, str);
    SNMP_SetManagerIP(sSettings.sSnmp.managerIP4);
}

void SetManagerIp5(char *str)
{
    strcpy(sSettings.sSnmp.managerIP5, str);
    SNMP_SetManagerIP(sSettings.sSnmp.managerIP5);
}

/**
  * @brief  Название устройсва устройства
  */
void SetNameDeviceStr(char *str)
{
    strcpy(sSettings.sSnmp.sysName.name, str);
    sSettings.sSnmp.sysName.len = strlen(str);
}

/**
  * @brief  Установить владельца
  */
void SetOwner(char *str)
{
    strcpy(sSettings.sSnmp.sysContact.contact, str);
    sSettings.sSnmp.sysContact.len = strlen(str);
    SNMP_SetObjDescr();
}

/**
  * @brief  Установить местоположение
  */
void SetLocation(char *str)
{
    strcpy(sSettings.sSnmp.sysLocation.location, str);
    sSettings.sSnmp.sysLocation.len = strlen(str);
}
#endif
/**
  * @brief  Установить комментарий
  */
void SetComment(char *str)
{
    strcpy(sSettings.sInfo.comments, str);
}

#ifdef RADIUS_SERVER_ENABLE
// ************************************************************************** //
//                             Сетевые параметры RADIUS сервера
/**
  * @brief  IP адрес
  */
void SetRDSIpStr(char *str)
{
    strcpy(sSettings.sRADIUS.ServerIP, str);
}

/**
  * @brief  Порт
  */
void SetRDSPortStr(char *str)
{
    sSettings.sRADIUS.port = atoi(str);
}

/**
  * @brief  Код access
  */
void SetRDSKeyAccesstStr(char *str)
{
    sSettings.sRADIUS.key_access = atoi(str);
}

/**
  * @brief  пароль RADIUS
  */
void SetRDSPasswordkStr(char *str)
{
    strcpy(sSettings.sRADIUS.rds_password, str);
}

/**
  * @brief  Настройка вкл/ выкл RADIUS сервера
  */
void SetRDSEnableStateStr(char *str)
{
    if (strncmp(str, "on", 2) == 0) {
        sSettings.sRADIUS.RDSEnable = 1;
    } else {
        sSettings.sRADIUS.RDSEnable = 0;
    }
}

/**
  * @brief  Настройка вкл/ выкл авторизации
  */
void SetAuthEnableStateStr(char *str)
{
    if (strncmp(str, "on", 2) == 0) {
        sSettings.sRADIUS.Auth_enable = 1;
    } else {
        sSettings.sRADIUS.Auth_enable = 0;
    }
}
#endif

#ifdef TELNET_ENABLE
#ifndef BT6702_SERVICE
// ************************************************************************** //
//                             Параметры Telnet
/**
  * @brief Текущий Порт
  */
void SetTelnetPortStr(char *str)
{
    sSettings.sTelnet.port = atoi(str);
}

/**
  * @brief  Настройка вкл/ выкл Telnet сервера
  */
void SetTelnetEnableStateStr(char *str)
{
    if (strncmp(str, "on", 2) == 0) {
        sSettings.sTelnet.TelnetEnable = 1;
    } else {
        sSettings.sTelnet.TelnetEnable = 0;
    }

}

#if defined SSH_ENABLE
#include "server.h"

extern bool fl_reinit_ssh;
// ************************************************************************** //
//                             Параметры SSH
/**
  * @brief Текущий Порт
  */
void SetSSHPortStr(char *str)
{
    uint16_t new_port = atoi(str);
    bool port_changed = new_port != sSettings.sSSH.port;
    sSettings.sSSH.port = new_port;
    if (port_changed) {
        flag_reboot = true;
        ssh_server_restart();
    }
}

/**
  * @brief  Настройка вкл/ выкл SSH сервера
  */
void SetSSHEnableStateStr(char *str)
{
    bool old_state = sSettings.sSSH.SSHEnable;
    if (strncmp(str, "on", 2) == 0) {
        sSettings.sSSH.SSHEnable = 1;
        if (old_state != true && fl_reinit_ssh == true) {
            ssh_server_init();
        }
    } else {
        sSettings.sSSH.SSHEnable = 0;
        ssh_server_restart();
    }
    if(old_state != sSettings.sSSH.SSHEnable) {
        flag_reboot = true;
    }
}
#endif // SSH_ENABLE
#endif // !BT6702_SERVICE
#endif // TELNET_ENABLE
// ************************************************************************** //
//                             Параметры даты и времени

/**
  * @brief  Дата
  */
void SetDateStr(char *str)
{
    TM_RTC_t tmp_data;
    char str_data[18];
    char str_time[9];
    uint8_t len;

    memset(str_data, 0, 18);
    memset(str_time, 0, 9);
    str += 2;
    strncpy(str_data, (str + 6), 2);
    strncat(str_data, (str + 2), 4);
    strncat(str_data, str, 2);
    TM_RTC_GetDateTime(&tmp_data, TM_RTC_Format_BIN);
    sprintf(str_time, "-01-%02i:%02i", tmp_data.hours, tmp_data.minutes);
    len = strlen(str_time);
    strncat(str_data, str_time, len);

    //TM_RTC_SetDateTimeString(&str_data);
    TM_RTC_SetDateTimeString(str_data);
}

/**
  * @brief  Время
  */
void SetTimeStr(char *str)
{
    TM_RTC_t tmp_data;
    char str_data[18];
    char str_date[14];
    uint8_t len;

    memset(str_data, 0, 18);
    memset(str_date, 0, 14);

    TM_RTC_GetDateTime(&tmp_data, TM_RTC_Format_BIN);
    sprintf(str_date, "%02i-%02i-%02i-01-", tmp_data.date, tmp_data.month, tmp_data.year);
    len = strlen(str_date);
    strncat(str_data, str_date, len);
    strncat(str_data, str, 5);

    //TM_RTC_SetDateTimeString(&str_data);
    TM_RTC_SetDateTimeString(str_data);
}

/**
  * @brief  Время
  */
void SetTimeWebStr(char *str)
{
    char tmp_str[MAX_WEB_PARAM_LEN];
    
    memset(tmp_str, 0, sizeof(tmp_str));
    url_decode(tmp_str, sizeof(tmp_str), str);

    TM_RTC_t tmp_data;
    char str_data[18];
    char str_date[14];
    uint8_t len;

    memset(str_data, 0, 18);
    memset(str_date, 0, 14);

    TM_RTC_GetDateTime(&tmp_data, TM_RTC_Format_BIN);
    sprintf(str_date, "%02i-%02i-%02i-01-", tmp_data.date, tmp_data.month, tmp_data.year);
    len = strlen(str_date);
    strncat(str_data, str_date, len);
    strncat(str_data, tmp_str, 5);

    //TM_RTC_SetDateTimeString(&str_data);
    TM_RTC_SetDateTimeString(str_data);
}

// ************************************************************************** //
//                             Параметры SNTP
#ifndef BT6702_SERVICE
/**
  * @brief  Состояние SNTP
  */
void SetSntpStateStr(char *str)
{
    bool enable_old_sntp = sSettings.sSNTP.sntpEnable;
    if (strncmp(str, "1", 1) == 0) {
        sSettings.sSNTP.sntpEnable = true;
    } else {
        sSettings.sSNTP.sntpEnable = false;
    }
    if (sSettings.sSNTP.sntpEnable != enable_old_sntp) {
#ifndef BT6702_SERVICE
      SNTP_Init();
#endif
      //vTaskDelay(7000);
      SNTP_Poll();
    }
}
#endif

/**
  * @brief  IP адрес SNTP сервера
  */
void SetSntpServerIpStr(char *str)
{
  if (strncmp(str, sSettings.sSNTP.ip, strlen(str)) != 0) {
    strcpy(sSettings.sSNTP.ip, str);
#ifndef BT6702_SERVICE
    SNTP_Init();
#endif
    //vTaskDelay(7000);
    SNTP_Poll();
  }
}

/**
  * @brief  Часовой пояс контроллера
  */
void SetSntpTimeZoneStr(char *str)
{
    float newUtc;

    newUtc = atof(str);

    if (sSettings.sSNTP.timeZone > 0) {
        if (newUtc >= 0) {
            if (newUtc >= sSettings.sSNTP.timeZone) {
                TM_RTC_Correction(newUtc - sSettings.sSNTP.timeZone);
            }

            else

            {
                TM_RTC_Correction(newUtc - sSettings.sSNTP.timeZone);
            }
        } else {
            TM_RTC_Correction(newUtc - sSettings.sSNTP.timeZone);
        }

    } else if (sSettings.sSNTP.timeZone < 0) {
        if (newUtc >= 0) {
            TM_RTC_Correction(newUtc + fabs(sSettings.sSNTP.timeZone));
        } else {
            if (newUtc >= sSettings.sSNTP.timeZone) {
                TM_RTC_Correction(fabs(sSettings.sSNTP.timeZone) - fabs(newUtc));
            } else {
                TM_RTC_Correction(newUtc - sSettings.sSNTP.timeZone);
            }
        }
    } else if (sSettings.sSNTP.timeZone == 0) {
        TM_RTC_Correction(newUtc);
    }

    sSettings.sSNTP.timeZone = newUtc; // atof(str);
    //TM_RTC_Correction(sSettings.sSNTP.timeZone);
}

// ************************************************************************** //
//                             Параметры реле/сухих контактов
#ifdef DINS_ENABLE
/**
  * @brief  Тип действий при срабатывание сухих контактов
  */
void SetDINTypeActStr(char *str, uint8_t num)
{
    sSettings.sDINs[num].din_type_act = atoi(str);
}

/**
  * @brief  Тип действий при срабатывание сухих контактов
  */
void SetDIN0TypeActStr(char *str)
{
    uint8_t num = 0;
    if(num < INPUTS_TOTAL_COUNT) {
      SetDINTypeActStr(str, num);
    }
}

/**
  * @brief  Тип действий при срабатывание сухих контактов
  */
void SetDIN1TypeActStr(char *str)
{
    uint8_t num = 1;
    if(num < INPUTS_TOTAL_COUNT) {
      SetDINTypeActStr(str, num);
    }
}

/**
  * @brief  Имя сухого контакта
  */
void SetDINNameStr(char *str, uint8_t num)
{
    strcpy(sSettings.sDINs[num].name, str);
}

/**
  * @brief  Имя сухого контакта
  */
void SetDIN0NameStr(char *str)
{
    uint8_t num = 0;
    if(num < INPUTS_TOTAL_COUNT) {
      SetDINNameStr(str, num);
    }
}

/**
  * @brief  Имя сухого контакта
  */
void SetDIN1NameStr(char *str)
{
    uint8_t num = 1;
    if(num < INPUTS_TOTAL_COUNT) {
      SetDINNameStr(str, num);
    }
}
#endif
#ifdef DOUTS_ENABLE
/**
  * @brief  Источник срабатывания реле
  */
void SetROTypeActStr(char *str, uint8_t num)
{
    static uint8_t OldROtype_Sourse[OUTPUTS_TOTAL_COUNT] = {0};

    OldROtype_Sourse[num] = sSettings.sRelays[num].ro_type_source;

    sSettings.sRelays[num].ro_type_source = atoi(str);

    if (OldROtype_Sourse[num] != sSettings.sRelays[num].ro_type_source) {
        SetROInt(0, num);
    }
}

/**
  * @brief  Источник срабатывания реле 1
  */
void SetRO1TypeActStr(char *str)
{
  uint8_t num = 0;
  if (num < OUTPUTS_TOTAL_COUNT) {
    SetROTypeActStr(str, num);
  }
}

/**
  * @brief  Источник срабатывания реле 2
  */
void SetRO2TypeActStr(char *str)
{
  uint8_t num = 1;
  if (num < OUTPUTS_TOTAL_COUNT) {
    SetROTypeActStr(str, num);
  }
}

/**
  * @brief  Источник срабатывания реле 3
  */
void SetRO3TypeActStr(char *str)
{
    uint8_t num = 2;
    if (num < OUTPUTS_TOTAL_COUNT) {
      SetROTypeActStr(str, num);
    }
}

/**
  * @brief
  */
void SetROStr(char *str, uint8_t num)
{
    set_state_douts((DOUT1 + num), atoi(str));
}

/**
  * @brief
  */
void SetROInt(uint8_t val, uint8_t num)
{
    set_state_douts((DOUT1 + num), val);
}
#endif
// ************************************************************************** //
//                             Параметры настройки ИБП

/**
  * @brief  Минимальное напряжение на ячейках АКБ
  */
void SetUPSVoltCellMinStr(char *str)
{
    sSettings.UPS_Setting.Ucellmin = atof(str);
}

/**
  * @brief  Минимальное напряжение на ячейках АКБ
  */
void SetUPSVoltCellMinInt(float value)
{
    sSettings.UPS_Setting.Ucellmin = value;
}

/**
  * @brief  Максимальное напряжение на ячейках АКБ
  */
void SetUPSVoltCellMaxStr(char *str)
{
    sSettings.UPS_Setting.Ucellmax = atof(str);
}

/**
  * @brief  Максимальное напряжение на ячейках АКБ
  */
void SetUPSVoltCellMaxInt(float value)
{
    sSettings.UPS_Setting.Ucellmax = value;
}

/**
  * @brief Дата установки АКБ
  */
void SetDataSetAKBStr(char *str)
{
    TM_RTC_t tmp_data;
    char str_data[3];
    if (str[0] != 0) {
        memset(str_data, 0, 3);
        memset(&tmp_data, 0, sizeof(tmp_data));
        str += 2;
        strncpy(str_data, str, 2);
        tmp_data.year = atoi(str_data);
        memset(str_data, 0, 3);
        strncat(str_data, (str + 3), 2);
        tmp_data.month = atoi(str_data);
        memset(str_data, 0, 3);
        strncat(str_data, (str + 6), 2);
        tmp_data.date = atoi(str_data);
        sSettings.UPS_Setting.set_data = TM_RTC_GetUnixTimeStamp(&tmp_data);
    } else {
        sSettings.UPS_Setting.set_data = 0;
    }
}

/**
  * @brief Срок службы АКБ
  */
void SetLifeTimeAKBStr(char *str)
{
    sSettings.UPS_Setting.life_time = atof(str);
}

/**
  * @brief Номинальное напряжение АКБ
  */
void SetVoltageAKBNominalStr(char *str)
{
    sSettings.UPS_Setting.Uakb = atof(str);
}

/**
  * @brief Полная мощность АКБ
  */
void SetUPSPowerStr(char *str)
{
    sSettings.UPS_Setting.ups_power = atof(str);
}

/**
  * @brief Полная мощность АКБ
  */
void SetUPSPowerEnumStr(char *str)
{
  int32_t index = atoi(str);
  sSettings.UPS_Setting.ups_power = UPSPowerMass[index];
}

/**
  * @brief Емкость АКБ
  */
void SetCapacityNominalAKBStr(char *str)
{
    sSettings.UPS_Setting.common_capacity = atoi(str);
}

/**
  * @brief  Серийный номер ИБП
  */
void SetUPSSerialStr(char *str)
{
	sSettings.UPS_Setting.serial = atoi(str);
}

// ************************************************************************** //
//                             Параметры менеджера аварий

/**
  * @brief  Верхняя граница VAC
  */
void SetVACAlarmHighRangeStr(char *str)
{
    sSettings.sAlarmManager.ac_output_range.high = atof(str);
}

/**
  * @brief  Верхняя граница VAC
  */
void SetVACAlarmHighRangeInt(float value)
{
    sSettings.sAlarmManager.ac_output_range.high = value;
}

/**
  * @brief  Нижняя граница VAC
  */
void SetVACAlarmLowRangeStr(char *str)
{
    sSettings.sAlarmManager.ac_output_range.low = atof(str);
}

/**
  * @brief  Нижняя граница VAC
  */
void SetVACAlarmLowRangeInt(float value)
{
    sSettings.sAlarmManager.ac_output_range.low = value;
}

/**
  * @brief  Гистерезис (VAC)
  */
void SetVACAlarmHisteStr(char *str)
{
    sSettings.sAlarmManager.ac_output_range.hyst = atof(str);
}

/**
  * @brief  Гистерезис (VAC)
  */
void SetVACAlarmHisteInt(float value)
{
    sSettings.sAlarmManager.ac_output_range.hyst = value;
}

#ifdef VAC_IN_MONITOR
/**
  * @brief Верхняя граница входящего напряжения
  */
void SetVACInputAlarmHighRangeStr(char *str)
{
    sSettings.sAlarmManager.ac_input_range.high = atof(str);
}

/**
  * @brief Верхняя граница входящего напряжения
  */
void SetVACInputAlarmHighRangeInt(float value)
{
    sSettings.sAlarmManager.ac_input_range.high = value;
}

/**
  * @brief Нижняя граница входящего напряжения
  */
void SetVACInputAlarmLowRangeStr(char *str)
{
    sSettings.sAlarmManager.ac_input_range.low = atof(str);
}

/**
  * @brief Нижняя граница входящего напряжения
  */
void SetVACInputAlarmLowRangeInt(float value)
{
    sSettings.sAlarmManager.ac_input_range.low = value;
}

/**
  * @brief Гистерезис входящего напряжения
  */
void SetVACinputAlarmHisteStr(char *str)
{
    sSettings.sAlarmManager.ac_input_range.hyst = atof(str);
}

/**
  * @brief Гистерезис входящего напряжения
  */
void SetVACinputAlarmHisteInt(float value)
{
    sSettings.sAlarmManager.ac_input_range.hyst = value;
}
#endif

/**
  * @brief  Верхняя граница температуры
  */
void SetTemperatureAlarmHighRangeStr(char *str)
{
    sSettings.sAlarmManager.Temprature_range.high = atof(str);
}

/**
  * @brief  Верхняя граница температуры
  */
void SetTemperatureAlarmHighRangeInt(float value)
{
    sSettings.sAlarmManager.Temprature_range.high = value;
}

/**
  * @brief  Нижняя граница температуры
  */
void SetTemperatureAlarmLowRangeStr(char *str)
{
    sSettings.sAlarmManager.Temprature_range.low = atof(str);
}

/**
  * @brief  Нижняя граница температуры
  */
void SetTemperatureAlarmLowRangeInt(float value)
{
    sSettings.sAlarmManager.Temprature_range.low = value;
}

/**
  * @brief  Гистерезис (температура)
  */
void SetTemperatureAlarmHisteStr(char *str)
{
    sSettings.sAlarmManager.Temprature_range.hyst = atof(str);
}

/**
  * @brief  Гистерезис (температура)
  */
void SetTemperatureAlarmHisteInt(float value)
{
    sSettings.sAlarmManager.Temprature_range.hyst = value;
}

#if !(HARDWARE_BT6709 || HARDWARE_BT6709_MTS) 
/**
  * @brief  Верхняя граница температуры
  */
void SetTemperatureCabinetAlarmHighRangeStr(char *str)
{
    sSettings.sAlarmManager.Temprature_cabinet_range.high = atof(str);
}

/**
  * @brief  Верхняя граница температуры
  */
void SetTemperatureCabinetAlarmHighRangeInt(float value)
{
    sSettings.sAlarmManager.Temprature_cabinet_range.high = value;
}

/**
  * @brief  Нижняя граница температуры
  */
void SetTemperatureCabinetAlarmLowRangeStr(char *str)
{
    sSettings.sAlarmManager.Temprature_cabinet_range.low = atof(str);
}

/**
  * @brief  Нижняя граница температуры
  */
void SetTemperatureCabinetAlarmLowRangeInt(float value)
{
    sSettings.sAlarmManager.Temprature_cabinet_range.low = value;
}

/**
  * @brief  Гистерезис (температура)
  */
void SetTemperatureCabinetAlarmHisteStr(char *str)
{
    sSettings.sAlarmManager.Temprature_cabinet_range.hyst = atof(str);
}

/**
  * @brief  Гистерезис (температура)
  */
void SetTemperatureCabinetAlarmHisteInt(float value)
{
    sSettings.sAlarmManager.Temprature_cabinet_range.hyst = value;
}
#endif

/**
  * @brief  Верхняя граница нагрузки
  */
void SetLoadAlarmHighRangeStr(char *str)
{
    sSettings.sAlarmManager.load_range.high = atof(str);
}

/**
  * @brief  Верхняя граница нагрузки
  */
void SetLoadAlarmHighRangeInt(float value)
{
    sSettings.sAlarmManager.load_range.high = value;
}

/**
  * @brief  Гистерезис (нагрузки)
  */
void SetLoadAlarmHistStr(char *str)
{
    sSettings.sAlarmManager.load_range.hyst = atof(str);
}

/**
  * @brief  Гистерезис (нагрузки)
  */
void SetLoadAlarmHistInt(float value)
{
    sSettings.sAlarmManager.load_range.hyst = value;
}


void SetEmptyFuncStr(char *str)
{

}

/********************************* (C) РОТЕК **********************************/