bt-67xx_universal_hw/modules/monitor/ups_monitor.c

/********************************* (C) РОТЕК ***********************************
 * @module  ups_monitor
 * @file    ups_monitor.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.
 *******************************************************************************
 */
#pragma GCC diagnostic error "-Wall"
#pragma GCC diagnostic error "-Wextra"
#include "FreeRTOS.h"
#include "task.h"
#include "fr_timers.h"
#include "stm32f4xx.h"
#include "ups_monitor.h"
#include "parameters.h"
#include "settings_api.h"
#include "megatec.h"
#include "led.h"
#include "log.h"
#include "rtc.h"
#include "hal.h"

#include "FreeRTOS.h"
#include "task.h"

#include "trap_api.h"
#include "snmp_api.h"
#include "syslog.h"

#include <stdbool.h>

#ifdef PRINTF_STDLIB
#include <stdio.h>
#endif
#ifdef PRINTF_CUSTOM
#include "tinystdio.h"
#endif


bool flCriticalAlarm = false;
bool flNonCriticalAlarm = false;
bool flLedAlarm = false;

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

extern bool flUpdateLog;

extern int test_time;
#if defined(INVERTERHIGHVOLTAGE_MONITOR) || defined(OVERTEMPRATURE_MONITOR)
TimerHandle_t UPSRestartTimer;

void UPSRestartCallback(TimerHandle_t pxTimer) {
  (void)pxTimer;
  UPScmd(ups_remote_turn_on);
}
#endif
#ifdef INVERTERHIGHVOLTAGE_MONITOR
TimerHandle_t UPSTurnOffTimer;

void UPSTurnOffCallback(TimerHandle_t pxTimer) {
  (void)pxTimer;
  UPScmd(ups_remote_turn_off);
  xTimerStart(UPSRestartTimer, 0);
}
#endif
/**
  * @brief  Задача мониторинга параметров UPS
  */
void UPS_Monitor(void *params)
{
	(void)params;
#if defined(INVERTERHIGHVOLTAGE_MONITOR) || defined(OVERTEMPRATURE_MONITOR)
  UPSRestartTimer = xTimerCreate("UPSRestartTmr", configTICK_RATE_HZ*10, pdFALSE, ( void * ) 0, UPSRestartCallback);
#endif
#ifdef INVERTERHIGHVOLTAGE_MONITOR
  UPSTurnOffTimer = xTimerCreate("UPSTurnOffTmr", configTICK_RATE_HZ*300, pdFALSE, ( void * ) 0, UPSTurnOffCallback);
#endif
	vTaskDelay(5000);
  for (;;)
  {
		flCriticalAlarm = false;
	  flNonCriticalAlarm = false;
    flLedAlarm = false;

#define XMONITOR(monitor_func, present) if (present) { monitor_func(); }
        MONITOR_TABLE
#undef XMONITOR

#ifdef LED_ALARM
      if(flLedAlarm){
    	  if (UPS.Present == UPS_CONNECTED)
    		  LED_On(LED_ALARM);
    	  else
    		  LED_Toggle(LED_ALARM);
      }
      else{
    	  LED_Off(LED_ALARM);
      }
#endif
    vTaskDelay(1000);
  }
}

#ifdef DINS_ENABLE
/**
  * @brief  Мониторинг бита DI0 state
  */
void UPS_DI0Monitor(void)
{
#ifdef DIN_MONITOR
  static bool isValueRecv = false;
  static uint8_t DI0OldState[INPUTS_TOTAL_COUNT];
  uint8_t DI0StateCurrent;

  for(uint8_t i = 0; i < INPUTS_TOTAL_COUNT; i ++) {
    DI0StateCurrent = get_state_din_outs((DIN1+i)) ^ sSettings.sDINs[i].din_type_act;

    UPS.Alarm = (UPS.Alarm & ~(1 << (4 + i))) | (DI0StateCurrent << (4 + i));

      if (!isValueRecv) {
      DI0OldState[i] = DI0StateCurrent;
      if (DI0StateCurrent){
        log_event_data((LOG_ALARM_DIO + i), "Авария");
        SNMP_SendUserTrap(DI0_ALARM + 2*i);
        flUpdateLog = true;
      }
      else{
        log_event_data((LOG_ALARM_DIO + i), "Норма");
        SNMP_SendUserTrap(DI0_NORM + 2*i);
        flUpdateLog = true;
      }
      if (i == (INPUTS_TOTAL_COUNT - 1)) {
        isValueRecv = true;
        break;
      } 
      continue;
    }

    if (DI0StateCurrent) {
      flLedAlarm = true;
    }
      
    // Значение параметра изменилось
    if (DI0StateCurrent != DI0OldState[i])
    {
      if (!DI0StateCurrent){
        log_event_data((LOG_ALARM_DIO + i), "Норма");
        SNMP_SendUserTrap((DI0_NORM + 2*i));
        flUpdateLog = true;
      }
      else{
        log_event_data((LOG_ALARM_DIO + i), "Авария");
        SNMP_SendUserTrap(DI0_ALARM + 2*i);
        flUpdateLog = true;
      }

    }

    DI0OldState[i] = DI0StateCurrent;
  }
#endif
}
#endif

#ifdef  DOUTS_ENABLE 
void relay_setup_log(uint8_t *curr_source, ro_type_source_t src_act_ro, uint8_t state_relay)
{
	uint8_t i = 0;

	for(i = 0; i < OUTPUTS_TOTAL_COUNT; i ++){
		if(curr_source[i] == src_act_ro){
			  SetROInt(state_relay, i);
			  SNMP_SendUserTrap((DO0_TOGGLED+i));
			  if(state_relay){
				  flUpdateLog = true;
#if	defined RELAY_NC
				  log_event_data((LOG_DO0_STATE + i), "Разомкнуто");
#else
				  log_event_data((LOG_DO0_STATE + i), "Замкнуто");
#endif

			  }
			  else{
				  flUpdateLog = true;
#if	defined RELAY_NC
				  log_event_data((LOG_DO0_STATE + i), "Замкнуто");
#else
				  log_event_data((LOG_DO0_STATE + i), "Разомкнуто");
#endif
			  }
		}
	}
}


void relay_setup_log_change(uint8_t *curr_source, uint8_t *prev_source, ro_type_source_t src_act_ro)
{
	uint8_t i = 0;

	for(i = 0; i < OUTPUTS_TOTAL_COUNT; i ++){
		if(curr_source[i] != prev_source[i] && (prev_source[i] == src_act_ro || curr_source[i] == src_act_ro)){
#if	defined RELAY_NC
			if(curr_source[i] != src_act_ro){
				flUpdateLog = true;
				 SetROInt(0, i);
				 SNMP_SendUserTrap((DO0_TOGGLED+i));
				 log_event_data((LOG_DO0_STATE + i), "Замкнуто");
			  }
			  else{
				  flUpdateLog = true;
				  SetROInt(1, i);
				  SNMP_SendUserTrap((DO0_TOGGLED+i));
				  log_event_data((LOG_DO0_STATE + i), "Разомкнуто");
			  }
#else
			  if(curr_source[i] != src_act_ro){
				  flUpdateLog = true;
				  SetROInt(0, i);
				  SNMP_SendUserTrap((DO0_TOGGLED+i));
				  log_event_data((LOG_DO0_STATE + i), "Разомкнуто");
			  }
			  else{
				  flUpdateLog = true;
				  SetROInt(1, i);
				 SNMP_SendUserTrap((DO0_TOGGLED+i));
				  log_event_data((LOG_DO0_STATE + i), "Замкнуто");
			  }
#endif

		}
	}
}
#endif


#ifdef TYPE_CRITICAL_ALARM_MONITOR
/**
  * @brief  Мониторинг бита CriticalAlarm
  */
void UPS_CriticalAlarmMonitor(void)
{
  static bool isValueRecv = false;
  static uint8_t CriticalAlarmOldState = 0;
  uint8_t CriticalAlarmCurrent;
  uint8_t i = 0;
  static uint8_t OldROtype_Sourse[OUTPUTS_TOTAL_COUNT] = {0};
  uint8_t CurrROtype_Sourse[OUTPUTS_TOTAL_COUNT] = {0};

  for(i = 0; i < OUTPUTS_TOTAL_COUNT; i ++)
	  CurrROtype_Sourse[i] = sSettings.sRelays[i].ro_type_source;

  CriticalAlarmCurrent = flCriticalAlarm;

  if (!isValueRecv) {
	isValueRecv = true;
	CriticalAlarmOldState = CriticalAlarmCurrent;
	for(i = 0; i < OUTPUTS_TOTAL_COUNT; i ++)
		OldROtype_Sourse[i] = CurrROtype_Sourse[i];
	if(CriticalAlarmCurrent){
	  relay_setup_log(CurrROtype_Sourse, CRITICAL, 1);
	}
	else{
		relay_setup_log(CurrROtype_Sourse, CRITICAL, 0);
	}
	return;
  }

  // Значение параметра изменилось
  if (CriticalAlarmCurrent != CriticalAlarmOldState)
  {
	  if(CriticalAlarmCurrent){
		  relay_setup_log(CurrROtype_Sourse, CRITICAL, 1);
	  }
	  else{
		  relay_setup_log(CurrROtype_Sourse, CRITICAL, 0);
	  }
  }
  else
  {
	  if(CriticalAlarmCurrent)
		  relay_setup_log_change(CurrROtype_Sourse, OldROtype_Sourse, CRITICAL);

  }

	for(i = 0; i < OUTPUTS_TOTAL_COUNT; i ++){
	  OldROtype_Sourse[i] = CurrROtype_Sourse[i];
	}
  CriticalAlarmOldState = CriticalAlarmCurrent;
}

/**
  * @brief  Мониторинг бита NonCriticalAlarm
  */
void UPS_NonCriticalAlarmMonitor(void)
{
  static bool isValueRecv = false;
  static uint8_t NonCriticalAlarmOldState = 0;
  uint8_t NonCriticalAlarmCurrent;
  uint8_t i = 0;
  static uint8_t OldROtype_Sourse[OUTPUTS_TOTAL_COUNT] = {0};
  uint8_t CurrROtype_Sourse[OUTPUTS_TOTAL_COUNT] = {0};

  for(i = 0; i < OUTPUTS_TOTAL_COUNT; i ++)
	  CurrROtype_Sourse[i] = sSettings.sRelays[i].ro_type_source;

  NonCriticalAlarmCurrent = flNonCriticalAlarm;

  if (!isValueRecv) {
	isValueRecv = true;
	NonCriticalAlarmOldState = NonCriticalAlarmCurrent;
	 for(i = 0; i < OUTPUTS_TOTAL_COUNT; i ++)
		 OldROtype_Sourse[i] = CurrROtype_Sourse[i];
	  if(NonCriticalAlarmCurrent)
		  relay_setup_log(CurrROtype_Sourse, NON_CRITICAL, 1);
	  else
		  relay_setup_log(CurrROtype_Sourse, NON_CRITICAL, 0);

	return;
  }

  // Значение параметра изменилось
  if (NonCriticalAlarmCurrent != NonCriticalAlarmOldState)
  {
	  if(NonCriticalAlarmCurrent){
		  relay_setup_log(CurrROtype_Sourse, NON_CRITICAL, 1);
	  }
	  else{
		  relay_setup_log(CurrROtype_Sourse, NON_CRITICAL, 0);
	  }
  }
  else
  {
	  if(NonCriticalAlarmCurrent)
		  relay_setup_log_change(CurrROtype_Sourse, OldROtype_Sourse, NON_CRITICAL);
  }

  for(i = 0; i < OUTPUTS_TOTAL_COUNT; i ++){
  	  OldROtype_Sourse[i] = CurrROtype_Sourse[i];
  }
  NonCriticalAlarmOldState = NonCriticalAlarmCurrent;
}
#endif
static bool test_akb_flag = false;
/**
  * @brief  Мониторинг бита Test in progress
  */
void UPS_TestFinishMonitor(void)
{
#ifdef TEST_AKB_FINISH_MONITOR
  static uint8_t TestFinishState = 0;
  uint8_t TestFinishStateCurrent;
  char log_string[50];
  static uint32_t start_time_test = 0;

  TestFinishStateCurrent = (UPS.Status >> 2) & 0x01;

  // Значение параметра изменилось
  if (TestFinishStateCurrent != TestFinishState)
  {
    if (!TestFinishStateCurrent){
      printf("Test finish\r\n");
#ifdef TEST_ALARM_AKB_MONITOR
      float time_test_actual = ((float)(xTaskGetTickCount() - start_time_test)) / (1000*60);
      UPSReadTestStatus();

#ifdef RELAY_ALARM_AKB
      static uint8_t AKBAlarmState = 0;
      uint8_t i = 0;
      static uint8_t OldROtype_Sourse[OUTPUTS_TOTAL_COUNT] = {0};
      uint8_t CurrROtype_Sourse[OUTPUTS_TOTAL_COUNT] = {0};

      for(i = 0; i < OUTPUTS_TOTAL_COUNT; i ++)
	        CurrROtype_Sourse[i] = sSettings.sRelays[i].ro_type_source;
#endif
      float Uakb_av = voltage_bat_average();
      float Pload_av = power_load_average();
      float k_eff;
      printf("Uakb_av: %0.2f", Uakb_av);
      printf("Pload_av: %0.2f", Pload_av);
      if(UPS.Test_Status != 2 && Pload_av >= 3) {
        GetUPSEfficiencyFactorInt(&k_eff);
        float Ccalc = (sSettings.UPS_Setting.ups_power*Pload_av*time_test_actual)/(100*60*Uakb_av*(k_eff));
        printf("Ccalc: %0.2f", Ccalc);
        float Ccalc_percent = (100*Ccalc)/sSettings.UPS_Setting.common_capacity;
        if (Ccalc_percent >= 80) {
          sprintf(log_string, "Авария(%0.2f Ач)", Ccalc);
          log_event_data(LOG_TEST_ALARM_AKB, log_string);
	        syslog(SYSLOG_INFORMATIONAL, "Ёмкость АКБ: %s", log_string);
#if HARDWARE_BT6711 || HARDWARE_BT6711_V1 || HARDWARE_BT6721
          SNMP_SendUserTrap(BATTERY_FAIL);
#endif
#ifdef RELAY_ALARM_AKB
          relay_setup_log(CurrROtype_Sourse, ALARM_AKB, 1);
          AKBAlarmState = 1;
#endif
        } else {
          sprintf(log_string, "Норма(%0.2f Ач)", Ccalc);
          log_event_data(LOG_TEST_ALARM_AKB, log_string);
	        syslog(SYSLOG_INFORMATIONAL, "Ёмкость АКБ: %s", log_string);
#if HARDWARE_BT6711 || HARDWARE_BT6711_V1 || HARDWARE_BT6721
          SNMP_SendUserTrap(BATTERY_NORM);
#endif
#ifdef RELAY_ALARM_AKB
          relay_setup_log(CurrROtype_Sourse, ALARM_AKB, 0);
          AKBAlarmState = 0;
#endif
        }
      }
#ifdef RELAY_ALARM_AKB
      if (AKBAlarmState)
          relay_setup_log_change(CurrROtype_Sourse, OldROtype_Sourse, ALARM_AKB);

      for(i = 0; i < OUTPUTS_TOTAL_COUNT; i ++)
          OldROtype_Sourse[i] = CurrROtype_Sourse[i];
#endif
      memset(log_string, 0, sizeof(log_string));
      if(UPS.Test_Status == 2 ||( (time_test_actual <= 0.9*test_time || time_test_actual >= 1.1*test_time) && (test_time != 0 && test_time != 100))){// 
        strcpy(log_string, "Ошибка");
      } else {
        strcpy(log_string, "Завершен");
      }
       uint8_t len1 = strlen(log_string);
       sprintf(&log_string[len1], "(%0.1f мин)", time_test_actual);
       log_event_data(LOG_TEST_UPS, log_string);
       syslog(SYSLOG_INFORMATIONAL, "Тест батареи: %s", log_string);
       printf("Value to syslog: %s\r\n", log_string);
       test_time = 0;
#if HARDWARE_BT6711 || HARDWARE_BT6711_V1 || HARDWARE_BT6721
          SNMP_SendUserTrap(TEST_BAT_STOP);
#endif
#else
      log_event_data(LOG_TEST_UPS, "Завершен");
      syslog_str(SYSLOG_INFORMATIONAL, "Тест батареи: Завершён");
      printf("Value to syslog: %s\r\n", log_string);
#endif
      flUpdateLog = true;
    } else {
      test_akb_flag = true;
      memset(log_string, 0, sizeof(log_string));
      switch (get_act_source()) {
        case WEB_ACT:
            strcpy(log_string, name_login);
            break;
        case SNMP_ACT:
        case OTHER_ACT:
            strcpy(log_string, "Администратор");
            break;
#ifdef CLI_ENABLE
        case CLI_ACT:
            strcpy(log_string, "Администратор");
            break;
#endif
        case AUTO_ACT:
            strcpy(log_string, "Автоматический");
            break;
        default:
            break;
      }
#ifdef TEST_ALARM_AKB_MONITOR
      start_time_test = xTaskGetTickCount();
     if (test_time == 0) {
       strcat(log_string, " (авто)");
     } else if (test_time == 100) {
        strcat(log_string, " (до разряда)");
     } else {
       uint8_t len = strlen(log_string);
       sprintf(&log_string[len], "(%i мин)", test_time);
     }
#else
       strcat(log_string, " (Запущен)");
#endif
      printf("Test start\r\n");
      log_event_data(LOG_TEST_UPS, log_string);
      syslog(SYSLOG_INFORMATIONAL, "Тест батареи: %s", log_string);
      printf("Value to syslog: %s\r\n", log_string);
#if HARDWARE_BT6711 || HARDWARE_BT6711_V1 || HARDWARE_BT6721
          SNMP_SendUserTrap(TEST_BAT_RUN);
#endif
      flUpdateLog = true;
    }
  }

  TestFinishState = TestFinishStateCurrent;
#endif
}

uint8_t UPS_VACinputRangeAlarm(void)
{
#ifdef VAC_IN_MONITOR
  uint8_t flag = 0;
  static uint8_t stateCurrentVACinput_low = HYST_IDLE;
  static uint8_t stateCurrentVACinput_high = HYST_IDLE;
  float VACinputCurrent = UPS.VAC_in;
  static uint8_t cnt = 0;
  if(test_akb_flag) {
   
    if (UPS.VAC_in>255) {
      test_akb_flag = false;
      cnt = 0;
      ups_metac_service_pdu(ups_cancel_test);
      log_event_data(LOG_TEST_UPS, "Ошибка");
    } else {
      if(cnt < 20){
        cnt++;
      } else {
          if (UPS.Mode == 'L') {
            test_akb_flag = false;
          }
        cnt = 0;
      }
    }
  }

  /* Отслеживается переход через нижнию границу */
  if (VACinputCurrent < sSettings.sAlarmManager.ac_input_range.low)
  {
      if (stateCurrentVACinput_low == HYST_IDLE || stateCurrentVACinput_low == HYST_DOWN) {
        stateCurrentVACinput_low = HYST_DOWN;
        flag |= (1 << 1);
      }
  } else  if (VACinputCurrent > (sSettings.sAlarmManager.ac_input_range.low + sSettings.sAlarmManager.ac_input_range.hyst))
  {
      if (stateCurrentVACinput_low == HYST_DOWN)
	    {
        stateCurrentVACinput_low = HYST_IDLE;
        flag &= 0xfd;
      }
  } else {
    if (stateCurrentVACinput_low == HYST_DOWN) {
      flag |= (1 << 1);
    }
  }

  /* Отслеживается переход через верхнюю границу */
  if (VACinputCurrent > sSettings.sAlarmManager.ac_input_range.high)
  {
      if (stateCurrentVACinput_high == HYST_IDLE || stateCurrentVACinput_high == HYST_UP) {
        stateCurrentVACinput_high = HYST_UP;
        flag |= (1 << 2);
      }
  } else  if (VACinputCurrent < (sSettings.sAlarmManager.ac_input_range.high - sSettings.sAlarmManager.ac_input_range.hyst))
  {
      if (stateCurrentVACinput_high == HYST_UP)
	    {
        stateCurrentVACinput_high = HYST_IDLE;
        flag &= 0xfb;
      }
  } else {
    if (stateCurrentVACinput_high == HYST_UP) {
      flag |= (1 << 2);
    }
  }
  return flag;
#endif
}

/**
  * @brief  Мониторинг бита LainFail
  */
void UPS_LineFailMonitor(void)
{
#ifdef LINE_FAIL_MONITOR
  static bool isValueRecv = false;
  static uint8_t lineFailOldState = 0;
  uint8_t lineFailCurrent;
  char log_string[50];
  uint8_t len;

#if defined RELAY_AC_PRESENT
  uint8_t i = 0;
  static uint8_t OldROtype_Sourse[OUTPUTS_TOTAL_COUNT] = {0};
  uint8_t CurrROtype_Sourse[OUTPUTS_TOTAL_COUNT] = {0};

  for(i = 0; i < OUTPUTS_TOTAL_COUNT; i ++)
	  CurrROtype_Sourse[i] = sSettings.sRelays[i].ro_type_source;
#endif
#ifdef VAC_IN_MONITOR
  lineFailCurrent = ((UPS.Status >> 7) & 0x01);
  lineFailCurrent |= UPS_VACinputRangeAlarm();
#else 
  lineFailCurrent = (UPS.Status >> 7) & 0x01;
#endif
  
  if (!isValueRecv) {
    isValueRecv = true;
    lineFailOldState = lineFailCurrent;

    if (lineFailCurrent != 0){
      memset(log_string, 0, sizeof(log_string));
      strcat(log_string, "Авария");
       len = strlen(log_string);
       sprintf(&log_string[len], " (%0.1f В)", UPS.VAC_in);  
    	log_event_data(LOG_ALARM_LINE, log_string);
          SNMP_SendUserTrap(LINE_ALARM);
          syslog(SYSLOG_ERROR, "Авария сети (%0.1f В)", UPS.VAC_in);
          flUpdateLog = true;
#if	defined RELAY_AC_PRESENT
    	relay_setup_log(CurrROtype_Sourse, AC_PRESENT, 1);
#endif
    }
    else{
#if	defined RELAY_AC_PRESENT
      relay_setup_log(CurrROtype_Sourse, AC_PRESENT, 0);
#endif
      log_event_data(LOG_ALARM_LINE, "Норма");
      SNMP_SendUserTrap(LINE_NORM);
      syslog(SYSLOG_NOTICE, "Сеть в норме (%0.1f В)", UPS.VAC_in);
      flUpdateLog = true;
    }

    return;
  }

  if (lineFailCurrent != 0){
    flCriticalAlarm = true;
    flLedAlarm = true;
  }
	  
  // Значение параметра изменилось
  if (lineFailCurrent != lineFailOldState)
  {
    if ((lineFailCurrent != 0) && (lineFailOldState == 0)) {
#if	defined RELAY_AC_PRESENT
    	relay_setup_log(CurrROtype_Sourse, AC_PRESENT, 1);
#endif

      memset(log_string, 0, sizeof(log_string));
      strcat(log_string, "Авария");
       len = strlen(log_string);
       sprintf(&log_string[len], " (%0.1f В)", UPS.VAC_in);  
    	log_event_data(LOG_ALARM_LINE, log_string);
    	SNMP_SendUserTrap(LINE_ALARM);
       syslog(SYSLOG_ERROR, "Авария сети (%0.1f В)", UPS.VAC_in);
#ifdef AKB_CHANGE_MONITOR
      if(UPS.Alarm & 0x40) {
        log_event_data(LOG_ALARM_CHANGE_AKB, "Авария");
    	  SNMP_SendUserTrap(BATTERY_CHANGE_ALARM);
      }   
#endif
    	flUpdateLog = true;
    }
    else if (lineFailCurrent == 0) {
      if (UPS.VAC_in == 0) {
        return;
      }
#if	defined RELAY_AC_PRESENT
      relay_setup_log(CurrROtype_Sourse, AC_PRESENT, 0);
#endif
      log_event_data(LOG_ALARM_LINE, "Норма");
      SNMP_SendUserTrap(LINE_NORM);
      syslog(SYSLOG_NOTICE, "Сеть в норме (%0.1f В)", UPS.VAC_in);
      flUpdateLog = true;
    }
  }

#if defined RELAY_AC_PRESENT
  else{
	  if (lineFailCurrent != 0)
		  relay_setup_log_change(CurrROtype_Sourse, OldROtype_Sourse, AC_PRESENT);
  }

  for(i = 0; i < OUTPUTS_TOTAL_COUNT; i ++){
	  OldROtype_Sourse[i] = CurrROtype_Sourse[i];
  }
#endif

  lineFailOldState = lineFailCurrent;
#endif
}

#ifdef VAC_OUT_MONITOR
/**
  * @brief  Мониторинг аварии выходного напряжения по нижней границе
  */
void UPS_VACoutputLowRangeMonitor(void)
{

  static uint8_t stateCurrentVACoutput = HYST_IDLE;
  float VACoutputCurrent;
#if	defined RELAY_DC_PRESENT
  uint8_t i = 0;
  static bool isValueRecv = false;
  static uint8_t OldROtype_Sourse[OUTPUTS_TOTAL_COUNT] = {0};
  uint8_t CurrROtype_Sourse[OUTPUTS_TOTAL_COUNT] = {0};

  for(i = 0; i < OUTPUTS_TOTAL_COUNT; i ++){
	  CurrROtype_Sourse[i] = sSettings.sRelays[i].ro_type_source;
	  if(!isValueRecv)
		  OldROtype_Sourse[i] = CurrROtype_Sourse[i];
  }
#endif

  VACoutputCurrent = UPS.VAC_out;

  /* Отслеживается переход через нижнию границу */
  if (VACoutputCurrent < sSettings.sAlarmManager.ac_output_range.low)
  {
      if (stateCurrentVACoutput == HYST_IDLE)
	    {
          UPS.Alarm |= (1 << 7);
          stateCurrentVACoutput = HYST_DOWN;
#if	defined RELAY_DC_PRESENT
          relay_setup_log(CurrROtype_Sourse, DC_PRESENT, 1);
#endif
	        log_event_data(LOG_ALARM_VAC_LOW_OUTPUT, "Авария");
#if HARDWARE_BT6711 || HARDWARE_BT6711_V1 || HARDWARE_BT6721
	        // Отправка трапа о занижении
	        SNMP_SendUserTrap(VAC_LOW_OUTPUT_ALARM);
		syslog(SYSLOG_ERROR, "Низкое выходное напряжение (%0.1f В)", VACoutputCurrent);
#endif
	        flUpdateLog = true;
	    } else {
#if	defined RELAY_DC_PRESENT
    	    relay_setup_log_change(CurrROtype_Sourse, OldROtype_Sourse, DC_PRESENT);
#endif
      }
  }
  /* Отслеживается нормализация */
  else if (VACoutputCurrent > (sSettings.sAlarmManager.ac_output_range.low + sSettings.sAlarmManager.ac_output_range.hyst))
  {
      if (stateCurrentVACoutput == HYST_DOWN)
	    {
          UPS.Alarm &= 0xffffff7f;
    	    stateCurrentVACoutput = HYST_IDLE;
#if	defined RELAY_DC_PRESENT
	        relay_setup_log(CurrROtype_Sourse, DC_PRESENT, 0);
#endif
	        log_event_data(LOG_ALARM_VAC_LOW_OUTPUT, "Норма");
#if HARDWARE_BT6711 || HARDWARE_BT6711_V1 || HARDWARE_BT6721
	        // Отправка трапа о нормализации
	        SNMP_SendUserTrap(VAC_LOW_OUTPUT_NORM);
		syslog(SYSLOG_NOTICE, "Выходное напряжение в норме (%0.1f В)", VACoutputCurrent);
#endif
	        flUpdateLog = true;
	    }
  } 
  if (UPS.Alarm & 0x80) {
    flLedAlarm = true;
  }
#if	defined RELAY_DC_PRESENT
  for(i = 0; i < OUTPUTS_TOTAL_COUNT; i ++){
  	  OldROtype_Sourse[i] = CurrROtype_Sourse[i];
    }
#endif
}

/**
  * @brief  Мониторинг аварии выходного напряжения по верхней границе
  */
void UPS_VACoutputHighRangeMonitor(void)
{

  static uint8_t stateCurrentVACoutput = HYST_IDLE;
  float VACoutputCurrent;
#if	defined RELAY_DC_PRESENT
  uint8_t i = 0;
  static bool isValueRecv = false;
  static uint8_t OldROtype_Sourse[OUTPUTS_TOTAL_COUNT] = {0};
  uint8_t CurrROtype_Sourse[OUTPUTS_TOTAL_COUNT] = {0};

  for(i = 0; i < OUTPUTS_TOTAL_COUNT; i ++){
	  CurrROtype_Sourse[i] = sSettings.sRelays[i].ro_type_source;
	  if(!isValueRecv)
		  OldROtype_Sourse[i] = CurrROtype_Sourse[i];
  }
#endif

  VACoutputCurrent = UPS.VAC_out;

  /* Отслеживается переход через верхнюю границу */
  if (VACoutputCurrent > sSettings.sAlarmManager.ac_output_range.high)
  {
      if (stateCurrentVACoutput == HYST_IDLE) {
          UPS.Alarm |= (1 << 7);
          stateCurrentVACoutput = HYST_UP;
#if	defined RELAY_DC_PRESENT
          relay_setup_log(CurrROtype_Sourse, DC_PRESENT, 1);
#endif
	        log_event_data(LOG_ALARM_VAC_HIGH_OUTPUT, "Авария");
#if HARDWARE_BT6711 || HARDWARE_BT6711_V1 || HARDWARE_BT6721
	        // Отправка трапа о завышении
	        SNMP_SendUserTrap(VAC_HIGH_OUTPUT_ALARM);
		syslog(SYSLOG_ERROR, "Высокое выходное напряжение (%0.1f В)", VACoutputCurrent);
#endif
	        flUpdateLog = true;
	    } else {
#if	defined RELAY_DC_PRESENT
    	    relay_setup_log_change(CurrROtype_Sourse, OldROtype_Sourse, DC_PRESENT);
#endif
      }
  }
  /* Отслеживается нормализация */
  else if (VACoutputCurrent < (sSettings.sAlarmManager.ac_output_range.high - sSettings.sAlarmManager.ac_output_range.hyst))
  {
      if (stateCurrentVACoutput == HYST_UP) {
          UPS.Alarm &= 0xffffff7f;
    	    stateCurrentVACoutput = HYST_IDLE;
#if	defined RELAY_DC_PRESENT
	        relay_setup_log(CurrROtype_Sourse, DC_PRESENT, 0);
#endif
	        log_event_data(LOG_ALARM_VAC_HIGH_OUTPUT, "Норма");
#if HARDWARE_BT6711 || HARDWARE_BT6711_V1 || HARDWARE_BT6721      
	        // Отправка трапа о нормализации
	        SNMP_SendUserTrap(VAC_HIGH_OUTPUT_NORM);
		syslog(SYSLOG_NOTICE, "Выходное напряжение в норме (%0.1f В)", VACoutputCurrent);
#endif
	        flUpdateLog = true;
	    }
  }
  if (UPS.Alarm & 0x80) {
    flLedAlarm = true;
  }
#if	defined RELAY_DC_PRESENT
  for(i = 0; i < OUTPUTS_TOTAL_COUNT; i ++){
  	  OldROtype_Sourse[i] = CurrROtype_Sourse[i];
    }
#endif
}

#endif

/**
  * @brief  Мониторинг бита LowBat  
  */
void UPS_LowBatMonitor(void)
{
#ifdef LOW_BAT_MONITOR
  static bool isValueRecv = false;
  static uint8_t lowBatOldState = 0;
  static bool flag_alarm_time = false;
  uint8_t lowBatCurrent;

#if defined RELAY_CHARGE_AKB
  uint8_t i = 0;
  static uint8_t OldROtype_Sourse[OUTPUTS_TOTAL_COUNT] = {0};
  uint8_t CurrROtype_Sourse[OUTPUTS_TOTAL_COUNT] = {0};

  for(i = 0; i < OUTPUTS_TOTAL_COUNT; i ++)
	  CurrROtype_Sourse[i] = sSettings.sRelays[i].ro_type_source;
#endif

  if((UPS.Status >> 7) & 0x01)
	  lowBatCurrent = (UPS.Status >> 6) & 0x01;
  else
	  lowBatCurrent = 0;
  
  if (!isValueRecv) {
    isValueRecv = true;
    lowBatOldState = lowBatCurrent;
    if (lowBatCurrent){
    	log_event_data(LOG_ALARM_LOW_BAT, "Авария");
          SNMP_SendUserTrap(LOW_BAT_ALARM);
	  syslog(SYSLOG_ERROR, "Низкий заряд АКБ (%d%%)", UPS.SOC);
          flUpdateLog = true;
#if defined RELAY_CHARGE_AKB
      relay_setup_log(CurrROtype_Sourse, CHARGE_AKB, 1);
#endif
    }
    else{
	  SNMP_SendUserTrap(LOW_BAT_NORM);
	  log_event_data(LOG_ALARM_LOW_BAT, "Норма");
	  syslog(SYSLOG_NOTICE, "Заряд АКБ в норме (%d%%)", UPS.SOC);
	  flUpdateLog = true;
#if defined RELAY_CHARGE_AKB
	  relay_setup_log(CurrROtype_Sourse, CHARGE_AKB, 0);
#endif
	}
    return;
  }
  // Значение параметра изменилось
  if (lowBatCurrent != lowBatOldState)
  {
	if(flag_alarm_time){
		flag_alarm_time = false;
		if (lowBatCurrent){
		  SNMP_SendUserTrap(LOW_BAT_ALARM);
		  syslog(SYSLOG_ERROR, "Низкий заряд АКБ (%d%%)", UPS.SOC);
		  log_event_data(LOG_ALARM_LOW_BAT, "Авария");
		  flUpdateLog = true;
#ifdef RELAY_CHARGE_AKB
		  relay_setup_log(CurrROtype_Sourse, CHARGE_AKB, 1);
#endif
		}
		else{
		  SNMP_SendUserTrap(LOW_BAT_NORM);
		  syslog(SYSLOG_NOTICE, "Заряд АКБ в норме (%d%%)", UPS.SOC);
		  log_event_data(LOG_ALARM_LOW_BAT, "Норма");
		  flUpdateLog = true;
#if defined RELAY_CHARGE_AKB
		  relay_setup_log(CurrROtype_Sourse, CHARGE_AKB, 0);
#endif
		}
	}
	else{
		flag_alarm_time = true;
	}
  }
#if defined RELAY_CHARGE_AKB
  else{
	  flag_alarm_time = false;
	  if (lowBatCurrent)
		  relay_setup_log_change(CurrROtype_Sourse, OldROtype_Sourse, CHARGE_AKB);
  }

  for(i = 0; i < OUTPUTS_TOTAL_COUNT; i ++){
	  OldROtype_Sourse[i] = CurrROtype_Sourse[i];
  }
#endif
  
  if(!flag_alarm_time){
	  if (lowBatCurrent){
		  flNonCriticalAlarm = true;
      flLedAlarm = true;
	  }
	  lowBatOldState = lowBatCurrent;
  }
  else{
	  if (lowBatOldState){
		  flNonCriticalAlarm = true;
      flLedAlarm = true;
	  }
  }
#endif
}

static uint8_t UPS_LoadRangeAlarm(void)
{
#ifdef LOAD_MONITOR
  uint8_t flag = 0;
  static uint8_t stateCurrent = HYST_IDLE;
  float load = UPS.Load;

  /* Отслеживается переход через верхнюю границу */
  if (load > sSettings.sAlarmManager.load_range.high)
  {
     if (stateCurrent == HYST_IDLE || stateCurrent == HYST_UP) {
        stateCurrent = HYST_UP;
        flag = 1;
      }
  } else  if (load < (sSettings.sAlarmManager.load_range.high - sSettings.sAlarmManager.load_range.hyst))
  {
      if (stateCurrent == HYST_UP)
	    {
        stateCurrent = HYST_IDLE;
        flag = 0;
      }
  } else {
    if (stateCurrent == HYST_UP) {
      flag = 1;
    }
  }
  return flag;
#endif
}


/**
  * @brief  Мониторинг нагрузки 
  */
void UPS_PowerMonitor(void)
{
#ifdef LOAD_MONITOR
  uint8_t powerStatusCurrent;
  static uint8_t powerStatusOld = 0;

  if(!get_sync_data()) {
    return;
  }

  powerStatusCurrent = ((UPS.warn_status >> 5) & 0x01);
  powerStatusCurrent |= UPS_LoadRangeAlarm();

  if (powerStatusCurrent)
  {
	  UPS.Alarm = (UPS.Alarm & 0xfffffffe) | (1 << 0);
    if (powerStatusCurrent != powerStatusOld)
	{
#ifdef LED_RED_MINOR
      LED_On(LED_RED_MINOR);
#endif
#ifdef LED_GREEN_MINOR
      LED_On(LED_GREEN_MINOR);
#endif
      
	  log_event_data(LOG_ALARM_POWER, "Авария");
	  // Отправка трапа о завышении 
	  SNMP_SendUserTrap(POWER_ALARM);
	  syslog(SYSLOG_ERROR, "Авария нагрузки (%d%%)", UPS.Load);
	  flUpdateLog = true;
	}
  }
  /* Отслеживается нормализация */
  else {
    UPS.Alarm = (UPS.Alarm & 0xfffffffe);
    if (powerStatusCurrent != powerStatusOld)
    {
#ifdef LED_RED_MINOR
        LED_Off(LED_RED_MINOR);
#endif
#ifdef LED_GREEN_MINOR
        LED_Off(LED_GREEN_MINOR);
#endif 
      log_event_data(LOG_ALARM_POWER, "Норма");
      // Отправка трапа о нормализации 
      SNMP_SendUserTrap(POWER_NORM);
      syslog(SYSLOG_NOTICE, "Авария нагрузки нормализовалась (%d%%)", UPS.Load);
      flUpdateLog = true;
    }
  }

  powerStatusOld = powerStatusCurrent;

  if (UPS.Alarm & 0x00000001) {
    flCriticalAlarm = true;
    flLedAlarm = true;
  }
#endif
}

#ifdef SENSOR_TEMP_MONITOR
/**
  * @brief  Мониторинг аварии датчика температуры
  */
void sensorTemperatureMonitor(void)
{
  float temperature;
  static uint8_t type_sensor[MAX_T_SENSORS];
  static uint8_t alarm[MAX_T_SENSORS]; 
  static uint8_t start_monitor = 0;

  if (start_monitor == 0) {
    start_monitor = 1;
    for(uint8_t i = 0; i < MAX_T_SENSORS; i ++){
      type_sensor[i] = sSettings.sTempControl[i].type_sensor;
    }
  } 

  for(uint8_t i = 0; i < MAX_T_SENSORS; i ++){
    if (alarm[i] && sSettings.sTempControl[i].type_sensor != type_sensor[i]) {
      alarm[i] = 0;
      if (type_sensor[i] == TS_AKB) {
        log_event_data(LOG_ALARM_SENSOR_AKB, "Норма");
        flUpdateLog = true;
      } else if (type_sensor[i] == TS_CABINET) {
        log_event_data(LOG_ALARM_SENSOR_CABINET, "Норма");
        flUpdateLog = true;
      }
    }
    if (sSettings.sTempControl[i].type_sensor == TS_AKB) {
      GetInternalTempInt(&temperature);
      if(temperature == 85) {
        if(!alarm[i]) {
          log_event_data(LOG_ALARM_SENSOR_AKB, "Авария");
          flUpdateLog = true;
          flLedAlarm = true;
          alarm[i] = 1;
        }
      } else {
        if(alarm[i]) {
          log_event_data(LOG_ALARM_SENSOR_AKB, "Норма");
          flUpdateLog = true;
          alarm[i] = 0;
        }
      }
    } else if (sSettings.sTempControl[i].type_sensor == TS_CABINET) {
      GetTempCaseInt(&temperature);
      if(temperature == 85) {
        if(!alarm[i]) {
          log_event_data(LOG_ALARM_SENSOR_CABINET, "Авария");
          flUpdateLog = true;
          flLedAlarm = true;
          alarm[i] = 1;
        }
      } else {
        if(alarm[i]) {
          log_event_data(LOG_ALARM_SENSOR_CABINET, "Норма");
          flUpdateLog = true;
          alarm[i] = 0;
        }
      }
    }
    type_sensor[i] = sSettings.sTempControl[i].type_sensor;
  }
}

#endif

#ifdef TEMP_AKB_MONITOR

static uint8_t UPS_TempHighRangeAlarm(void)
{
  uint8_t flag = 0;
  float temperature;
  static uint8_t stateCurrent = HYST_IDLE;
    
  GetInternalTempInt(&temperature);

  if(temperature == 85) {
    if (stateCurrent == HYST_UP) {
      stateCurrent = HYST_IDLE;
      flag = 0;
    }
    return flag;
  }

  /* Отслеживается переход через верхнюю границу */
  if (temperature > sSettings.sAlarmManager.Temprature_range.high)
  {
     if (stateCurrent == HYST_IDLE || stateCurrent == HYST_UP) {
        stateCurrent = HYST_UP;
        flag = 1;
      }
  } else  if (temperature < (sSettings.sAlarmManager.Temprature_range.high - sSettings.sAlarmManager.Temprature_range.hyst))
  {
      if (stateCurrent == HYST_UP)
	    {
        stateCurrent = HYST_IDLE;
        flag = 0;
      }
  } else {
    if (stateCurrent == HYST_UP) {
      flag = 1;
    }
  }
  return flag;
}
/**
  * @brief  Мониторинг температуры по верхней границе
  */
void UPS_TemperatureHighRangeMonitor(void)
{
  float temperature;
  uint8_t tempStatusCurrent;
  static uint8_t tempStatusOld = 0;
    
  GetInternalTempInt(&temperature);

  tempStatusCurrent = ((UPS.warn_status >> 6) & 0x01);
  tempStatusCurrent |= UPS_TempHighRangeAlarm();

  if (tempStatusCurrent)
  {
    UPS.Alarm = (UPS.Alarm & 0xfffffffd) | (1 << 1);
    if (tempStatusCurrent != tempStatusOld) {
      log_event_data(LOG_ALARM_HIGH_TEMP, "Авария");
      // Отправка трапа о завышении 
      SNMP_SendUserTrap(BATTERY_HIGH_TEMPERATURE_ALARM);
      syslog(SYSLOG_ERROR, "Высокая температура (%0.1f C)", temperature);
      flUpdateLog = true;
    }
  }
  /* Отслеживается нормализация */
  else {
    UPS.Alarm = (UPS.Alarm & 0xfffffffd);
    if (tempStatusCurrent != tempStatusOld) {
	    log_event_data(LOG_ALARM_HIGH_TEMP, "Норма");
	  // Отправка трапа о нормализации 
	    SNMP_SendUserTrap(BATTERY_HIGH_TEMPERATURE_NORM);
	    syslog(SYSLOG_NOTICE, "Температура в норме (%0.1f C)", temperature);
	    flUpdateLog = true;
	  }
  }
  tempStatusOld = tempStatusCurrent;
  if (UPS.Alarm & 0x00000002) {
    flCriticalAlarm = true;
    flLedAlarm = true;
  }
}

/**
  * @brief  Мониторинг температуры по нижней границе
  */
void UPS_TemperatureLowRangeMonitor(void)
{
  float temperature;
  static uint8_t stateCurrent = HYST_IDLE;

  GetInternalTempInt(&temperature);

  if(temperature == 85) {
    UPS.Alarm = (UPS.Alarm & 0xfffffeff) | (1 << 8);
    if (stateCurrent == HYST_DOWN) {
      stateCurrent = HYST_IDLE;
      log_event_data(LOG_ALARM_LOW_TEMP, "Норма");
      // Отправка трапа о нормализации
	    SNMP_SendUserTrap(BATTERY_LOW_TEMPERATURE_NORM);
	    syslog(SYSLOG_NOTICE, "Температура в норме (%0.1f C)", temperature);
      flUpdateLog = true;
    }
    return;
  } else {
    if (stateCurrent == HYST_IDLE) {
      UPS.Alarm = (UPS.Alarm & 0xfffffeff);
    }
  }

  /* Отслеживается переход через нипжнюю границу */
  if (temperature < sSettings.sAlarmManager.Temprature_range.low)
  {
    if (stateCurrent == HYST_IDLE)
	{
	  stateCurrent = HYST_DOWN;
    UPS.Alarm = (UPS.Alarm & 0xfffffeff) | (1 << 8);

	  log_event_data(LOG_ALARM_LOW_TEMP, "Авария");
	  // Отправка трапа о занижении
	  SNMP_SendUserTrap(BATTERY_LOW_TEMPERATURE_ALARM);
	  syslog(SYSLOG_ERROR, "Низкая температура (%0.1f C)", temperature);
	  flUpdateLog = true;
	}
  }
  /* Отслеживается нормализация */
  else if (temperature > (sSettings.sAlarmManager.Temprature_range.low + sSettings.sAlarmManager.Temprature_range.hyst))
  {
    if (stateCurrent == HYST_DOWN)
	{
	  stateCurrent = HYST_IDLE;
    UPS.Alarm = (UPS.Alarm & 0xfffffeff);
	  log_event_data(LOG_ALARM_LOW_TEMP, "Норма");
	  // Отправка трапа о нормализации
	  SNMP_SendUserTrap(BATTERY_LOW_TEMPERATURE_NORM);
	  syslog(SYSLOG_NOTICE, "Температура в норме (%0.1f C)", temperature);
	  flUpdateLog = true;
	}
  }
  if (UPS.Alarm & 0x00000100) {
    flCriticalAlarm = true;
    flLedAlarm = true;
  }
}
#endif

#ifdef TEMP_CABINET_MONITOR
/**
  * @brief  Мониторинг температуры шкафа по верхней границе
  */
void Cabinet_TemperatureHighRangeMonitor(void)
{
  float temperature;
  static uint8_t stateCurrent = HYST_IDLE;
    
  GetTempCaseInt(&temperature);

  if(temperature == 85) {
    UPS.Alarm = (UPS.Alarm & 0xfffffdff) | (1 << 9);
    if (stateCurrent == HYST_UP) {
      stateCurrent = HYST_IDLE;
      log_event_data(LOG_ALARM_HIGH_CABINET_TEMP, "Норма");
      // Отправка трапа о нормализации
	    SNMP_SendUserTrap(CABINET_HIGH_TEMPERATURE_NORM);
      flUpdateLog = true;
    }
    return;
  } else {
    if (stateCurrent == HYST_IDLE) {
      UPS.Alarm = (UPS.Alarm & 0xfffffdff);
    }
  }
  /* Отслеживается переход через верхнюю границу */
  if (temperature > sSettings.sAlarmManager.Temprature_cabinet_range.high)
  {
	
    if (stateCurrent == HYST_IDLE)
	  {
      UPS.Alarm = (UPS.Alarm & 0xfffffdff) | (1 << 9);
	    stateCurrent = HYST_UP;
      

	  log_event_data(LOG_ALARM_HIGH_CABINET_TEMP, "Авария");
	  // Отправка трапа о завышении 
	  SNMP_SendUserTrap(CABINET_HIGH_TEMPERATURE_ALARM);
	  flUpdateLog = true;
	}
  }
  /* Отслеживается нормализация */
  else if (temperature < (sSettings.sAlarmManager.Temprature_cabinet_range.high - sSettings.sAlarmManager.Temprature_cabinet_range.hyst))
  {
    if (stateCurrent == HYST_UP)
	  {
      UPS.Alarm = (UPS.Alarm & 0xfffffdff);
	    stateCurrent = HYST_IDLE;
      
	  log_event_data(LOG_ALARM_HIGH_CABINET_TEMP, "Норма");
	  // Отправка трапа о нормализации 
	  SNMP_SendUserTrap(CABINET_HIGH_TEMPERATURE_NORM);
	  flUpdateLog = true;
	}
  }
  if (UPS.Alarm & 0x00000200) {
    flLedAlarm = true;
  }
}

/**
  * @brief  Мониторинг температуры шкафа по нижней границе
  */
void Cabinet_TemperatureLowRangeMonitor(void)
{
  float temperature;
  static uint8_t stateCurrent = HYST_IDLE;

  GetTempCaseInt(&temperature);

  if(temperature == 85) {
    UPS.Alarm = (UPS.Alarm & 0xfffffbff) | (1 << 10);
    if (stateCurrent == HYST_DOWN) {
      stateCurrent = HYST_IDLE;
      log_event_data(LOG_ALARM_LOW_CABINET_TEMP, "Норма");
      // Отправка трапа о нормализации
	    SNMP_SendUserTrap(CABINET_LOW_TEMPERATURE_NORM);
      flUpdateLog = true;
    }
    return;
  } else {
    if (stateCurrent == HYST_IDLE) {
      UPS.Alarm = (UPS.Alarm & 0xfffffbff);
    }
  }

  /* Отслеживается переход через нипжнюю границу */
  if (temperature < sSettings.sAlarmManager.Temprature_cabinet_range.low)
  {
    if (stateCurrent == HYST_IDLE)
	  {
	    stateCurrent = HYST_DOWN;
      UPS.Alarm = (UPS.Alarm & 0xfffffbff) | (1 << 10);

	  log_event_data(LOG_ALARM_LOW_CABINET_TEMP, "Авария");
	  // Отправка трапа о занижении
	  SNMP_SendUserTrap(CABINET_LOW_TEMPERATURE_ALARM);
	  flUpdateLog = true;
	}
  }
  /* Отслеживается нормализация */
  else if (temperature > (sSettings.sAlarmManager.Temprature_cabinet_range.low + sSettings.sAlarmManager.Temprature_cabinet_range.hyst))
  {
    if (stateCurrent == HYST_DOWN)
	  {
      UPS.Alarm = (UPS.Alarm & 0xfffffbff);
	    stateCurrent = HYST_IDLE;

	  log_event_data(LOG_ALARM_LOW_CABINET_TEMP, "Норма");
	  // Отправка трапа о нормализации
	  SNMP_SendUserTrap(CABINET_LOW_TEMPERATURE_NORM);
	  flUpdateLog = true;
	}
  }
  if (UPS.Alarm & 0x00000400) {
    flLedAlarm = true;
  }
}
#endif

/**
  * @brief  Мониторинг параметра upsParams.connect
  */
void UPS_ConnectMonitor(void)
{
#ifdef UPS_CONNECT_MONITOR
  static bool isValueRecv = false;
  static ups_state_connection_t connectOldState;
  ups_state_connection_t connectCurrent;
  
  connectCurrent = UPS.Present;

  if(connectCurrent == UPS_WAIT_CONNECT) {
    return;
  }
  
  UPS.Alarm = (UPS.Alarm & 0xfffffffb) | ((connectCurrent^1) << 2);

  if (!isValueRecv) {
    isValueRecv = true;
    connectOldState = connectCurrent;
    if (connectCurrent == UPS_FAIL_CONNECT){
    	log_event_data(LOG_ALARM_UPS, "Авария");
    	SNMP_SendUserTrap(CONNECT_MONITOR_ALARM);
	syslog_str(SYSLOG_ERROR, "Потеряна связь с ИБП");
    }
    else{
    	log_event_data(LOG_ALARM_UPS, "Норма");
		SNMP_SendUserTrap(CONNECT_MONITOR_NORM);
		syslog_str(SYSLOG_NOTICE, "Восстановлена связь с ИБП");
		flUpdateLog = true;
    }
    return;
  }
  if (connectCurrent == UPS_FAIL_CONNECT){
    flCriticalAlarm = true;
    flLedAlarm = true;
  }
  // Значение параметра изменилось
  if (connectCurrent != connectOldState)
  {
    if (connectCurrent == UPS_CONNECTED){
      log_event_data(LOG_ALARM_UPS, "Норма");
      SNMP_SendUserTrap(CONNECT_MONITOR_NORM);
      syslog_str(SYSLOG_NOTICE, "Восстановлена связь с ИБП");
      flUpdateLog = true;
    }
    else{
      log_event_data(LOG_ALARM_UPS, "Авария");
      SNMP_SendUserTrap(CONNECT_MONITOR_ALARM);
      syslog_str(SYSLOG_ERROR, "Потеряна связь с ИБП");
    }
  }
  
  connectOldState = connectCurrent;
#endif
}

/**
  * @brief  Мониторинг параметра upsParams.connect
  */
void UPS_BatteryConnectMonitor(void)
{
#ifdef BAT_CONNECT_MONITOR
  static bool isValueRecv = false;
  static bool flag_alarm_time = false;
  static uint8_t AKBconnectOldState = 0;
  uint8_t AKBconnectCurrent;

#if defined RELAY_OFF_AKB
  uint8_t i = 0;
  static uint8_t OldROtype_Sourse[OUTPUTS_TOTAL_COUNT] = {0};
  uint8_t CurrROtype_Sourse[OUTPUTS_TOTAL_COUNT] = {0};

  for(i = 0; i < OUTPUTS_TOTAL_COUNT; i ++)
	  CurrROtype_Sourse[i] = sSettings.sRelays[i].ro_type_source;
#endif

  if(((UPS.Status >> 7) & 0x01) == 0)
	  AKBconnectCurrent = (UPS.Status >> 6) & 0x01;
  else{
	  AKBconnectCurrent = 0;
  }
  AKBconnectCurrent |= UPS.warn_status & 0x01;

  UPS.Alarm = (UPS.Alarm & 0xfffffff7) | (AKBconnectCurrent << 3);

  if (!isValueRecv) {
    isValueRecv = true;
    AKBconnectOldState = AKBconnectCurrent;
    if (AKBconnectCurrent){
      log_event_data(LOG_ALARM_AKB, "Авария");
	  SNMP_SendUserTrap(BATTERY_CONNECT_ALARM);
	  syslog_str(SYSLOG_ERROR, "Авария связи с АКБ");
	  flUpdateLog = true;
#if defined RELAY_OFF_AKB
      relay_setup_log(CurrROtype_Sourse, OFF_AKB, 1);
#endif
    }
    else{
    	log_event_data(LOG_ALARM_AKB, "Норма");
		  SNMP_SendUserTrap(BATTERY_CONNECT_NORM);
		  syslog_str(SYSLOG_NOTICE, "Связь с АКБ восстановлена");
		  flUpdateLog = true;
#if	defined RELAY_OFF_AKB
		  relay_setup_log(CurrROtype_Sourse, OFF_AKB, 0);
#endif
    }
    return;
  }
  // Значение параметра изменилось
  if (AKBconnectCurrent != AKBconnectOldState)
  {
	if(flag_alarm_time){
		flag_alarm_time = false;
		if (!AKBconnectCurrent){
		  log_event_data(LOG_ALARM_AKB, "Норма");
		  SNMP_SendUserTrap(BATTERY_CONNECT_NORM);
		  syslog_str(SYSLOG_NOTICE, "Связь с АКБ восстановлена");
		  flUpdateLog = true;
#if defined RELAY_OFF_AKB
		  relay_setup_log(CurrROtype_Sourse, OFF_AKB, 0);
#endif
		}
		else{
		  log_event_data(LOG_ALARM_AKB, "Авария");
		  SNMP_SendUserTrap(BATTERY_CONNECT_ALARM);
		  syslog_str(SYSLOG_ERROR, "Авария связи с АКБ");
		  flUpdateLog = true;
#if defined RELAY_OFF_AKB
		  relay_setup_log(CurrROtype_Sourse, OFF_AKB, 1);
#endif
		}
	}
	else{
		flag_alarm_time = true;
	}
  }
#if defined RELAY_OFF_AKB
  else{
	  flag_alarm_time = false;
	  if (AKBconnectCurrent)
		  relay_setup_log_change(CurrROtype_Sourse, OldROtype_Sourse, OFF_AKB);
  }

  for(i = 0; i < OUTPUTS_TOTAL_COUNT; i ++){
	  OldROtype_Sourse[i] = CurrROtype_Sourse[i];
  }
#endif

  if(!flag_alarm_time){
	  if (AKBconnectCurrent){
      flCriticalAlarm = true;
      flLedAlarm = true;
	  }
	  AKBconnectOldState = AKBconnectCurrent;
  }
  else{
	  if (AKBconnectOldState){
      flCriticalAlarm = true;
      flLedAlarm = true;
	  }
  }
#endif
}

#ifdef AKB_CHANGE_MONITOR
/**
  * @brief  Мониторинг параметра замены АКБ
  */
void AKB_Change_Monitor(void)
{
  uint32_t data_change = sSettings.UPS_Setting.set_data + (31536000*sSettings.UPS_Setting.life_time);
  TM_RTC_t tmp_data;
  static bool isValueRecv = false;
  static uint8_t status_change_akb = 0;
  uint8_t curr_status_change_akb = 0;
  
  TM_RTC_GetDateTime(&tmp_data, TM_RTC_Format_BIN);
  
  if (tmp_data.unix >= data_change) {
    UPS.Alarm |= (1 << 6);
    curr_status_change_akb = 1;
    flCriticalAlarm = true;
    flLedAlarm = true;
  }
  else {
    UPS.Alarm &= 0xffffffbf;
    curr_status_change_akb = 0;
  }

  if (!isValueRecv) {
    isValueRecv = true;
    status_change_akb = curr_status_change_akb;
    if (curr_status_change_akb){
    	log_event_data(LOG_ALARM_CHANGE_AKB, "Авария");
    	SNMP_SendUserTrap(BATTERY_CHANGE_ALARM);
    	flUpdateLog = true;
    }
    else{
    	log_event_data(LOG_ALARM_CHANGE_AKB, "Норма");
      SNMP_SendUserTrap(BATTERY_CHANGE_MORM);
      flUpdateLog = true;
    }
    return;
  }

  // Значение параметра изменилось
  if (status_change_akb != curr_status_change_akb)
  {
    if (curr_status_change_akb){
      log_event_data(LOG_ALARM_CHANGE_AKB, "Авария");
    	SNMP_SendUserTrap(BATTERY_CHANGE_ALARM);
      flUpdateLog = true;
    } else {
      log_event_data(LOG_ALARM_CHANGE_AKB, "Норма");
      SNMP_SendUserTrap(BATTERY_CHANGE_MORM);
      flUpdateLog = true;
    }
  }
  status_change_akb = curr_status_change_akb;
}
#endif

#ifdef UPS_FAILED_MONITOR
void UPS_Failed_Monitor(void)
{
  static bool isValueRecv = false;
  static uint8_t UPSFailOldState = 0;
  uint8_t UPSFailCurrent;

  UPSFailCurrent = (UPS.Status >> 4) & 0x01;
  
  if (!isValueRecv) {
    isValueRecv = true;
    UPSFailOldState = UPSFailCurrent;

    if (UPSFailCurrent){
    	log_event_data(LOG_ALARM_UPS_FAILED, "Авария");
          SNMP_SendUserTrap(UPS_ALARM);
          flUpdateLog = true;
    }
    else{
      log_event_data(LOG_ALARM_UPS_FAILED, "Норма");
      SNMP_SendUserTrap(UPS_NORM);
      flUpdateLog = true;
    }

    return;
  }

  if (UPSFailCurrent){
    flCriticalAlarm = true;
    flLedAlarm = true;
  }
	  
  // Значение параметра изменилось
  if (UPSFailCurrent != UPSFailOldState)
  {
    if (UPSFailCurrent){
    	log_event_data(LOG_ALARM_UPS_FAILED, "Авария");
    	SNMP_SendUserTrap(UPS_ALARM);
    	flUpdateLog = true;
    }
    else{
      log_event_data(LOG_ALARM_UPS_FAILED, "Норма");
      SNMP_SendUserTrap(UPS_NORM);
      flUpdateLog = true;
    }
  }

  UPSFailOldState = UPSFailCurrent;  
}
#endif

#ifdef PHASE_FAIL_MONITOR
void UPS_PhaseFailMonitor(void)
{
  static bool isValueRecv = false;
  uint8_t phaseStatusCurrent;
  static uint8_t phaseStatusOld = 0;

  phaseStatusCurrent = ((UPS.warn_status >> 1) & 0x01);

  if (phaseStatusCurrent != 0){
    flCriticalAlarm = true;
    flLedAlarm = true;
    UPS.Alarm = (UPS.Alarm & 0xfffffeff) | (1 << 8);
  } else {
    UPS.Alarm = (UPS.Alarm & 0xfffffeff);
  }

  if (!isValueRecv) {
    isValueRecv = true;
    phaseStatusOld = phaseStatusCurrent;

    if (phaseStatusCurrent != 0){
      log_event_data(LOG_PHASE_FAIL, "Авария");
      // Отправка трапа о завышении 
      SNMP_SendUserTrap(PHASE_FAIL);
      syslog(SYSLOG_ERROR, "Ошибка подкл. вх. напряжения");
      flUpdateLog = true;
    }
    else{
      log_event_data(LOG_PHASE_FAIL, "Норма");
      // Отправка трапа о нормализации 
      SNMP_SendUserTrap(PHASE_NORM);
      syslog(SYSLOG_NOTICE, "Подкл. вх. напряжения в норме");
      flUpdateLog = true;
    }

    return;
  }

  if (phaseStatusCurrent)
  {
    if (phaseStatusCurrent != phaseStatusOld)
    {
      log_event_data(LOG_PHASE_FAIL, "Авария");
      // Отправка трапа о завышении 
      SNMP_SendUserTrap(PHASE_FAIL);
      syslog(SYSLOG_ERROR, "Ошибка подкл. вх. напряжения");
      flUpdateLog = true;
    }
  }
  /* Отслеживается нормализация */
  else {
    if (phaseStatusCurrent != phaseStatusOld)
    {
      log_event_data(LOG_PHASE_FAIL, "Норма");
      // Отправка трапа о нормализации 
      SNMP_SendUserTrap(PHASE_NORM);
      syslog(SYSLOG_NOTICE, "Подкл. вх. напряжения в норме");
      flUpdateLog = true;
    }
  }

  phaseStatusOld = phaseStatusCurrent;
}
#endif

#ifdef EPO_MONITOR
void UPS_EPOMonitor(void)
{
  static bool isValueRecv = false;
  uint8_t EPOStatusCurrent;
  static uint8_t EPOStatusOld = 0;

  EPOStatusCurrent = ((UPS.warn_status >> 8) & 0x01);

  if (EPOStatusCurrent != 0){
    flCriticalAlarm = true;
    flLedAlarm = true;
    UPS.Alarm = (UPS.Alarm & 0xfffffdff) | (1 << 9);
  } else {
    UPS.Alarm = (UPS.Alarm & 0xfffffdff);
  }

  if (!isValueRecv) {
    isValueRecv = true;
    EPOStatusOld = EPOStatusCurrent;

    if (EPOStatusCurrent != 0){
      log_event_data(LOG_EPO_FAIL, "Авария");
      // Отправка трапа о завышении 
      SNMP_SendUserTrap(EPO_FAIL);
      syslog(SYSLOG_ERROR, "Срабатывание EPO");
      flUpdateLog = true;
    }
    else{
      log_event_data(LOG_EPO_FAIL, "Норма");
      // Отправка трапа о нормализации 
      SNMP_SendUserTrap(EPO_NORM);
      syslog(SYSLOG_NOTICE, "EPO в норме");
      flUpdateLog = true;
    }

    return;
  }

  if (EPOStatusCurrent)
  {
    if (EPOStatusCurrent != EPOStatusOld)
    {
      log_event_data(LOG_EPO_FAIL, "Авария");
      // Отправка трапа о завышении 
      SNMP_SendUserTrap(EPO_FAIL);
      syslog(SYSLOG_ERROR, "Ошибка EPO");
      flUpdateLog = true;
    }
  }
  /* Отслеживается нормализация */
  else {
    if (EPOStatusCurrent != EPOStatusOld)
    {
      log_event_data(LOG_EPO_FAIL, "Норма");
      // Отправка трапа о нормализации 
      SNMP_SendUserTrap(EPO_NORM);
      syslog(SYSLOG_NOTICE, "EPO в норме");
      flUpdateLog = true;
    }
  }

  EPOStatusOld = EPOStatusCurrent;
}
#endif

#ifdef OVERTEMPRATURE_MONITOR
void UPS_OverTempratureMonitor(void)
{
    if (((UPS.fault_type == 0x41) || (UPS.fault_type == 0x13)) && (UPS.Temp < 55) && ((UPS.Status >> 7) & 0x01)) {
        UPScmd(ups_remote_turn_off);
        xTimerStart(UPSRestartTimer, 0);
        UPS.fault_type = 0;
    }
}
#endif

#ifdef INVERTERHIGHVOLTAGE_MONITOR
void UPS_InventerHighVoltageMonitor(void)
{
    if(UPS.fault_type == 0x12) {
        xTimerStart(UPSTurnOffTimer, 0);
        UPS.fault_type = 0;
    }

}
#endif

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