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"
#endif
#include "sntp.h"
#include "lwip/snmp.h"
#include "lwip/sys.h"
#include "common_config.h"
#include "settings_api.h"
//#include "d_inouts.h"
#include "gpio.h"
#if defined HARDWARE_BT6702
#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 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);
}

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

/**
  * @brief  Индикация аварийных ситуаций
  */
void GetAlarmStr(char *str, uint8_t *len)
{
	sprintf(str, "%d", UPS.Status);
	*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  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);
}

// ************************************************************************** //
//                             Параметры реле/сухих контактов

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

/**
  * @brief  Состояние релейного выхода
  */
void GetDOUT0StatusStr(char *str, uint8_t *len)
{
	sprintf(str, "%d", get_state_din_outs(DOUT1));
	*len = strlen(str);
}

/**
  * @brief  Состояние релейного выхода
  */
void GetDOUT1StatusStr(char *str, uint8_t *len)
{
	sprintf(str, "%d", get_state_din_outs(DOUT2));
	*len = strlen(str);
}

// ************************************************************************** //
//                             Информация

#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(sSettings.sSnmp.sysName);
  strncpy(str, sSettings.sSnmp.sysName, *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 = strlen(sSettings.sSnmp.sysContact);
  strncpy(str, sSettings.sSnmp.sysContact, *len);
}

/**
  * @brief  Местоположение устройства
  */
void GetLocationStr(char *str, uint8_t *len)
{
  *len = strlen(sSettings.sSnmp.sysLocation);
  strncpy(str, sSettings.sSnmp.sysLocation, *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 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);
}

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

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

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

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

// ************************************************************************** //
//                             Параметры 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 SetOwner(char *str)
{
  strcpy(sSettings.sSnmp.sysContact, str);
  SNMP_SetSysContact(sSettings.sSnmp.sysContact);
  SNMP_SetObjDescr();
}

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

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

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

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

// ************************************************************************** //
//                             Параметры реле/сухих контактов

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


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