/********************************* (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
#ifdef AM2301_SENSOR_ENABLE
#include "AM2301.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>
#include "syslog.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 GetLoadAKBModeStr(char *str, uint8_t *len)
{
sprintf(str, "%d", UPS.Load_test_akb);
*len = strlen(str);
}
/**
* @brief
*/
void GetLoadAKBModeInt(int32_t *value)
{
*value = UPS.Load_test_akb;
}
/**
* @brief
*/
void GetDataCheckLoadStr(char *str, uint8_t *len)
{
if (UPS.data_check_load_flag) {
sprintf(str, "%d", UPS.data_check_load);
}
*len = strlen(str);
}
/**
* @brief
*/
void GetDataFormatCheckLoadStr(char *str, uint8_t *len)
{
TM_RTC_t data;
uint16_t sys_year;
TM_RTC_GetDateTimeFromUnix(&data, UPS.data_check_load);
sys_year = 2000 + data.year;
if (UPS.data_check_load_flag) {
sprintf(str, "%04i-%02i-%02i %02i:%02i", sys_year, data.month, data.date, data.hours, data.minutes);
}
*len = strlen(str);
}
/**
* @brief
*/
void GetBatCapacityStr(char *str, uint8_t *len)
{
sprintf(str, "%d", UPS.SOC);
*len = strlen(str);
}
/**
* @brief
*/
void GetBatCapacityPrevStr(char *str, uint8_t *len)
{
sprintf(str, "%d", UPS.SOC_prev);
*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
#elif defined AM2301_SENSOR_ENABLE
if(sSettings.sTempControl[0].type_sensor == TS_AKB) {
if (sAM2301Sensorsdata[0].SensorState == 1){
sprintf(str, "%s", "Обрыв линии");
} else {
sprintf(str, "%0.1f", sAM2301Sensorsdata[0].temp);
}
} else if (sSettings.sTempControl[1].type_sensor == TS_AKB) {
if (sAM2301Sensorsdata[1].SensorState == 1){
sprintf(str, "%s", "Обрыв линии");
} else {
sprintf(str, "%0.1f", sAM2301Sensorsdata[1].temp);
}
}
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
#elif defined AM2301_SENSOR_ENABLE
if(sSettings.sTempControl[0].type_sensor == TS_AKB) {
if (sAM2301Sensorsdata[0].SensorState == 1){
*value = 85;
} else {
*value = sAM2301Sensorsdata[0].temp;
}
} else if (sSettings.sTempControl[1].type_sensor == TS_AKB) {
if (sAM2301Sensorsdata[1].SensorState == 1){
*value = 85;
} else {
*value = sAM2301Sensorsdata[1].temp;
}
}
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 != UPS_FAIL_CONNECT) {
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 && UPS.Mode != 'B') {
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 && UPS.Mode != 'B') {
*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.Alarm >> 8) & 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;
}
}
#elif defined AM2301_SENSOR_ENABLE
void GetHumidityCaseStr(char *str, uint8_t *len)
{
if(sSettings.sTempControl[0].type_sensor == TS_CABINET) {
if (sAM2301Sensorsdata[0].SensorState == 1){
sprintf(str, "%s", "Обрыв линии");
} else {
sprintf(str, "%0.1f", sAM2301Sensorsdata[0].hum);
}
} else if (sSettings.sTempControl[1].type_sensor == TS_CABINET) {
if (sAM2301Sensorsdata[1].SensorState == 1){
sprintf(str, "%s", "Обрыв линии");
} else {
sprintf(str, "%0.1f", sAM2301Sensorsdata[1].hum);
}
}
else
{
sprintf(str, "%s", "Нет датчика");
}
*len = strlen(str);
}
void GetTempCaseStr(char *str, uint8_t *len)
{
if(sSettings.sTempControl[0].type_sensor == TS_CABINET) {
if (sAM2301Sensorsdata[0].SensorState == 1){
sprintf(str, "%s", "Обрыв линии");
} else {
sprintf(str, "%0.1f", sAM2301Sensorsdata[0].temp);
}
} else if (sSettings.sTempControl[1].type_sensor == TS_CABINET) {
if (sAM2301Sensorsdata[1].SensorState == 1){
sprintf(str, "%s", "Обрыв линии");
} else {
sprintf(str, "%0.1f", sAM2301Sensorsdata[1].temp);
}
}
else
{
sprintf(str, "%s", "Нет датчика");
}
*len = strlen(str);
}
/**
* @brief
*/
void GetTempCaseInt(float *value)
{
if(sSettings.sTempControl[0].type_sensor == TS_CABINET) {
if (sAM2301Sensorsdata[0].SensorState == 1){
*value = 85;
} else {
*value = sAM2301Sensorsdata[0].temp;
}
} else if (sSettings.sTempControl[1].type_sensor == TS_CABINET) {
if (sAM2301Sensorsdata[1].SensorState == 1){
*value = 85;
} else {
*value = sAM2301Sensorsdata[1].temp;
}
}
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 GetDINStatusStrRU(char *str, uint8_t *len, uint8_t num)
{
if (get_state_din_outs(DIN1+num) ^ 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)
{
#ifdef HARDWARE_BT6709_MTS
strcpy(str, "BT-6709-MTS");
*len = strlen(str);
#else
*len = strlen(HW_REV);
strncpy(str, HW_REV, *len);
#endif
}
/**
* @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);
if(*len == 0){
strcpy(str, "00000000000000");
} else {
strcpy(str, UPS.serial);
}
} else {
memset(tempStr, 0, sizeof(tempStr));
memset(str, 0, 14);
sprintf(str, "%lu", sSettings.UPS_Setting.serial);
*len = strlen(str);
strcpy(tempStr, UPS.serial);
if (*len < 8) {
for(uint8_t i = 0; i < (8-*len); i ++) {
tempStr[6+i] = '0';
}
tempStr[6+(8-*len)] = 0;
} else {
tempStr[6] = 0;
}
strncat(tempStr, str, strlen(str));
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 Включен/Выключен
*/
void GetPortGwEnabledRUStr(char *str, uint8_t *len)
{
if (sSettings.sPortGw.enabled) {
sprintf(str, "%s", "Включен");
} else {
sprintf(str, "%s", "Выключен");
}
*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 GetPortGwParityRUStr(char *str, uint8_t *len)
{
if (sSettings.sPortGw.parity == GW_EVEN_PAR) {
sprintf(str, "%s", "Четный");
} else if (sSettings.sPortGw.parity == GW_ODD_PAR) {
sprintf(str, "%s", "Нечетный");
} else {
sprintf(str, "%s", "Нет");
}
*len = strlen(str);
}
/**
* @brief Четность
*/
void GetPortGwParityInt(uint32_t *value)
{
*value = sSettings.sPortGw.parity;
}
/**
* @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
#if defined(DALLAS_SENSOR_ENABLE) || defined(AM2301_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);
}
/**
* @brief Размещение датчика температуры
*/
void GetTSlocationStr(char *str, uint8_t *len, uint8_t num)
{
switch (sSettings.sTempControl[num].type_sensor)
{
case TS_NONE:
strcat(str, "Нет");
break;
case TS_CABINET:
strcat(str, "Шкаф");
break;
case TS_AKB:
strcat(str, "АКБ");
break;
default:
break;
}
*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;
}
void GetRADIUSEnableStrRU(char *str, uint8_t *len)
{
if( sSettings.sRADIUS.RDSEnable) {
strcpy(str, "Включена");
} else {
strcpy(str, "Выключена");
}
*len = strlen(str);
}
/**
* @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 FTP_ENABLE
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 // FTP_ENABLE
#ifdef SYSLOG_ENABLE
void GetSyslogEnable(char *str, uint8_t *len)
{
str[0] = sSettings.sSyslog.enabled ? '1' : '0';
*len = 1;
}
void GetSyslogEnableStrRU(char *str, uint8_t *len)
{
if(sSettings.sSyslog.enabled) {
strcpy(str, "Включена");
} else {
strcpy(str, "Выключена");
}
*len = strlen(str);
}
void GetSyslogServer(char *str, uint8_t *len)
{
*len = sprintf(str, "%s", ipaddr_ntoa(&sSettings.sSyslog.server_ip));
}
void GetSyslogPort(char *str, uint8_t *len)
{
*len = sprintf(str, "%d", sSettings.sSyslog.server_port);
}
void SetSyslogEnable(char *str)
{
sSettings.sSyslog.enabled = strncmp(str, "on", 2) == 0;
}
void SetSyslogServer(char *str)
{
ipaddr_aton(str, &sSettings.sSyslog.server_ip);
}
void SetSyslogPort(char *str)
{
sSettings.sSyslog.server_port = atoi(str);
}
#endif // SYSLOG_ENABLE
// ************************************************************************** //
// Флаги
/**
* @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 SetPortGwParityInt(uint32_t value)
{
sSettings.sPortGw.parity = value;
}
/**
* @brief Число бит данных
*/
void SetPortGwDatabitsStr(char *str)
{
sSettings.sPortGw.databits = atoi(str);
}
/**
* @brief Число стоп-бит
*/
void SetPortGwStopbitsStr(char *str)
{
sSettings.sPortGw.stopbits = atoi(str);
}
#endif
#if defined(DALLAS_SENSOR_ENABLE) || defined(AM2301_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);
}
/**
* @brief Размещение датчика температуры
*/
void SetTSlocationStr(char *str, uint8_t num)
{
sSettings.sTempControl[num].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 (strstr(str, sSettings.sSNTP.ip) == 0 || strlen(str) != strlen(sSettings.sSNTP.ip)) {
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 = atol(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) РОТЕК **********************************/