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"
#if defined HARDWARE_BT6707 || HARDWARE_BT6709
#include "telnet_server.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"
//#if defined HARDWARE_BT6703
#ifdef PRINTF_STDLIB
#include <stdio.h>
#endif
#ifdef PRINTF_CUSTOM
#include "tinystdio.h"
#endif
#include <string.h>
#include <stdlib.h>
#include <math.h>

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

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

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

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

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

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

/**
  * @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 GetOutputVoltageStr(char *str, uint8_t *len)
{
    sprintf(str, "%0.1f", UPS.VAC_out);
    *len = strlen(str);
}

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

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

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

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

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

/**
  * @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);
}

#ifdef HARDWARE_BT6709

/**
  * @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 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 GetVoltageAKBtStr(char *str, uint8_t *len)
{
    float value;
    if(UPS.Vakb_curr < 7) {
      value = AKB_NUM_CELL*(sSettings.UPS_Setting.Uakb/AKB_VOLTAGE) * UPS.Vakb_curr;
    } else {
        value = sSettings.UPS_Setting.Uakb * UPS.Vakb_curr;
    }
    sprintf(str, "%0.1f", roundto(value, 1));
    *len = strlen(str);
}

#endif

// ************************************************************************** //
//                             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 HARDWARE_BT6709
// ************************************************************************** //
//                             Параметры реле/сухих контактов

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

/**
  * @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)
{
    sprintf(str, "%d", (get_state_din_outs(DIN1) ^ 1));
    *len = strlen(str);
}

/**
  * @brief  Состояние сухого контакта
  */
void GetDIN0StatusStrRU(char *str, uint8_t *len)
{
    if (get_state_din_outs(DIN1) ^ 1) {
        sprintf(str, "Разомкнут" );
    } else {
        sprintf(str, "Замкнут" );
    }
    *len = strlen(str);
}

/**
  * @brief  Источник срабатывания реле
  */
void GetROTypeActStr(char *str, uint8_t *len, uint8_t num)
{
    sprintf(str, "%d", sSettings.sInOuts.ro_type_source[num]);
    *len = strlen(str);
}

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

    *len = strlen(str);
}

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

    *len = strlen(str);
}

/**
  * @brief  Состояние релейного выхода
  */
void GetDOUT0StatusStr(char *str, uint8_t *len)
{
#if defined HARDWARE_BT6707 || HARDWARE_BT6709
    sprintf(str, "%d", (get_state_din_outs(DOUT1) ^ 1));
#elif HARDWARE_BT6703
    sprintf(str, "%d", get_state_din_outs(DOUT1));
#endif
    *len = strlen(str);
}

/**
  * @brief  Состояние релейного выхода
  */
void GetDOUT1StatusStr(char *str, uint8_t *len)
{
#if defined HARDWARE_BT6707 || HARDWARE_BT6709
    sprintf(str, "%d", (get_state_din_outs(DOUT2) ^ 1));
#elif HARDWARE_BT6703
    sprintf(str, "%d", get_state_din_outs(DOUT2));
#endif
    *len = strlen(str);
}

#if defined HARDWARE_BT6707 || HARDWARE_BT6709
/**
  * @brief  Состояние релейного выхода
  */
void GetDOUT2StatusStr(char *str, uint8_t *len)
{
    sprintf(str, "%d", (get_state_din_outs(DOUT3) ^ 1));
    *len = strlen(str);
}
#endif
#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)
{
    *len = strlen(UPS.serial);
    strncpy(str, UPS.serial, *len);
}

/**
  * @brief  Версия UPS ПО
  */
void GetUPSVersionStr(char *str, uint8_t *len) // +
{
    *len = strlen(UPS.vertion);
    strncpy(str, UPS.vertion, *len);
}
#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 HARDWARE_BT6709
// ************************************************************************** //
//                             Параметры довверительных хостов

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

// ************************************************************************** //
//                             Параметры 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 HARDWARE_BT6703
// ************************************************************************** //
//                             Параметры 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

#if defined HARDWARE_BT6707 || HARDWARE_BT6709
// ************************************************************************** //
//                             Параметры 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;
}

#endif

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

/**
  * @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 GetUPSVoltCellMaxStr(char *str, uint8_t *len)
{
    sprintf(str, "%0.2f", roundto(sSettings.UPS_Setting.Ucellmax, 2));
    *len = strlen(str);
}

#ifdef HARDWARE_BT6709

/**
  * @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);

    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 GetCapacityNominalAKBStr(char *str, uint8_t *len)
{
    sprintf(str, "%d", (int32_t)sSettings.UPS_Setting.common_capacity);
    *len = strlen(str);
}

#endif

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

/**
  * @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 GetVACAlarmLowRangeStr(char *str, uint8_t *len)
{
    sprintf(str, "%d", (int)sSettings.sAlarmManager.ac_output_range.low);

    *len = strlen(str);
}

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

    *len = strlen(str);
}

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

    *len = strlen(str);
}

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

    *len = strlen(str);
}

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

    *len = strlen(str);
}

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

    *len = strlen(str);
}

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

    *len = strlen(str);
}

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

/**
  * @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;
}


// ************************************************************************** //
//                             Сетевые параметры
/**
  * @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 HARDWARE_BT6709
// ************************************************************************** //
//                             Параметры довверительных хостов

/**
  * @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 {
            sSettings.sWhiteListTemp[num].mask = 0;
            sSettings.sWhiteListTemp[num].ip = 0;
        }
    }
}

#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 HARDWARE_BT6703
// ************************************************************************** //
//                             Сетевые параметры 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

#if defined HARDWARE_BT6707 || HARDWARE_BT6709
// ************************************************************************** //
//                             Параметры Telnet
#ifndef BT6702_SERVICE
/**
  * @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;
    }

}
#endif
#endif
// ************************************************************************** //
//                             Параметры даты и времени

/**
  * @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);
}

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

/**
  * @brief  IP адрес SNTP сервера
  */
void SetSntpServerIpStr(char *str)
{
    strcpy(sSettings.sSNTP.ip, str);
}

/**
  * @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);
}
#ifndef HARDWARE_BT6709
// ************************************************************************** //
//                             Параметры реле/сухих контактов

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

/**
  * @brief  Источник срабатывания реле
  */
void SetROTypeActStr(char *str, uint8_t num)
{
    static uint8_t OldROtype_Sourse[2] = {0};

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

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

    if (OldROtype_Sourse[num] != sSettings.sInOuts.ro_type_source[num]) {
        SetROInt(0, 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 SetUPSVoltCellMaxStr(char *str)
{
    sSettings.UPS_Setting.Ucellmax = atof(str);
}

#ifdef HARDWARE_BT6709

/**
  * @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 SetCapacityNominalAKBStr(char *str)
{
    sSettings.UPS_Setting.common_capacity = atoi(str);
}

#endif

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

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

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

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

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

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

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

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

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

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