bt-67xx_universal_hw/service_hw/Commands/bt_6701_commands.c

/********************************* (C) РОТЕК ***********************************
 * @module  bt_6701_commands
 * @file    bt_6701_commands.c
 * @version 1.0.0
 * @date    XX.XX.XXXX
 * $brief   bt_6701_commands
 *******************************************************************************
 * @history     Version  Author         Comment
 * XX.XX.XXXX   1.0.0    Telenkov D.A.  First release.
 *******************************************************************************
 */
#include "common_config.h"
#include "stm32f4xx.h"  
#include "bt_6701_commands.h"
#include "commands_api.h"
#include "gpio.h"
#include "buttons.h"
#include "led.h"
#include "netconf.h"
#include "stm32f4x7_eth_bsp.h"
#include "http_server.h"
#include "rtc.h"
#include "sntp_api.h"
#include "d_inouts.h"
#include "config_service.h"
#include "usart.h"
#include "spi_flash.h"

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

#include "lwip/opt.h"
#include "lwip/api.h"
#include "lwip/sys.h"

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

#include <string.h>

bool ntpResult = false;
uint32_t SNTP_Time;

extern uint8_t DefCounter;
extern BUTTON_NO_FIX_t defButton;

extern uint8_t SetCounter;
extern BUTTON_NO_FIX_t setButton;

/**
  * @brief  Флаг ининциализации Eth интерфейса
  */
extern unsigned char eth_ready_flag;

// -------------------------------------------------------------------------- //
//                              __weak функции

/**
  * @brief  
  */
void TestProcessing(void)
{
  
    vTaskDelay(200);
}

/**
  * @brief  
  */
void Test_U232(void)
{
    // Отправляем символы в RS232
    for (uint16_t i = 0; i < 1023; i++)
    	ups_putchar('A');
  
    vTaskDelay(10);
    
  
    for (uint16_t i = 0; i < 1023; i++)
    {
        if (ups_getchar(500) != 'A') {
            printf("U232 FAIL\r\n");
            TEST_SetTest(TEST_WAIT);
            return;
        }
    }  
    
    printf("U232 OK\r\n");
    TEST_SetTest(TEST_WAIT);
}

#ifdef DALLAS_SENSOR_ENABLE
void COM_TestOW(void)
{
    uint8_t inputState;
    uint8_t start_state = 0;
    uint8_t end_state = 1;

    gpio_hw_config_pin(gpio_pins[WDATA1].port, gpio_pins[WDATA1].pin, GPIO_MODE_IN_CFG | 
				GPIO_SPEED_HIGH_CFG);
    gpio_hw_config_pin(gpio_pins[WDATA2].port, gpio_pins[WDATA2].pin, GPIO_MODE_IN_CFG | 
				GPIO_SPEED_HIGH_CFG);

    for (uint8_t i = 0; i < INPUTS_TOTAL_COUNT; i ++) {
      vTaskDelay(100);
    
      gpio_set((DOUT1 + i), start_state);

      vTaskDelay(100);
          
      if (get_state_din_outs((WDATA1 + i)) != start_state) {
          printf("OW FAIL\r\n");
          TEST_SetTest(TEST_WAIT);
          return;
      }  

      gpio_set((DOUT1 + i), end_state);

      vTaskDelay(100);
      
      if (get_state_din_outs((WDATA1 + i)) != end_state) {
          printf("OW FAIL\r\n");
          TEST_SetTest(TEST_WAIT);
          return;
      }  
    }

    vTaskDelay(100);

    printf("OW OK\r\n");
    TEST_SetTest(TEST_WAIT);
}
#endif

#ifdef DINS_ENABLE || DOUTS_ENABLE
/**
  * @brief  
  */
void Test_DRY(void)
{
    uint8_t inputState;
    uint8_t start_state = 0;
    uint8_t end_state = 1;
#ifdef DOUTS_ENABLE
#if defined RELAY_NC 
    start_state = 0;
    end_state = 1;
    for (uint8_t i = 0; i < OUTPUTS_TOTAL_COUNT; i ++) {
      set_state_douts((DOUT1 + i), 1);
    }
#endif

#ifdef RELAY_NO
    start_state = 1;
    end_state = 0;
#endif
    
    for (uint8_t i = 0; i < OUTPUTS_TOTAL_COUNT; i ++) {
#ifdef HARDWARE_BT6703
        if(i == 2) { // функционал определяющий аппаратную часть контроллера BT-6703 (выпущено 120 шт. переделанных из BT-6702, различия в релейных выходах)
          break;
        }
#endif 
      vTaskDelay(100);
      inputState = get_state_din_outs(DIN1);
    
      set_state_douts((DOUT1 + i), start_state);

      vTaskDelay(100);
          
      if (get_state_din_outs(DIN1) == inputState) {
#ifdef HARDWARE_BT6703
          if(i == 0) {
            set_state_douts((DOUT1 + 2), start_state);

            vTaskDelay(100);
                
            if (get_state_din_outs(DIN1) == inputState) {
                printf("DRY FAIL\r\n");
                TEST_SetTest(TEST_WAIT);
                return;
            }
          } else
#endif
        {
          printf("DRY FAIL\r\n");
          TEST_SetTest(TEST_WAIT);
          return;
        }
      }  

      set_state_douts((DOUT1 + i), end_state);

      vTaskDelay(100);
      
      if (get_state_din_outs(DIN1) != inputState) {
#ifdef HARDWARE_BT6703
          if(i == 0) {
            set_state_douts((DOUT1 + 2), end_state);

            vTaskDelay(100);
                
            if (get_state_din_outs(DIN1) == inputState) {
                printf("DRY FAIL\r\n");
                TEST_SetTest(TEST_WAIT);
                return;
            }
          } else
#endif
        {
          printf("DRY FAIL\r\n");
          TEST_SetTest(TEST_WAIT);
          return;
        }
      }  
    }
#else
    for (uint8_t i = 0; i < INPUTS_TOTAL_COUNT; i ++) {
      vTaskDelay(100);
    
      gpio_set((DOUT1 + i), start_state);

      vTaskDelay(100);
          
      if (get_state_din_outs((DIN1 + i)) != start_state) {
          printf("DRY FAIL\r\n");
          TEST_SetTest(TEST_WAIT);
          return;
      }  

      gpio_set((DOUT1 + i), end_state);

      vTaskDelay(100);
      
      if (get_state_din_outs((DIN1 + i)) != end_state) {
          printf("DRY FAIL\r\n");
          TEST_SetTest(TEST_WAIT);
          return;
      }  
    }
#endif

	  vTaskDelay(100);

    printf("DRY OK\r\n");
    TEST_SetTest(TEST_WAIT);
}
#endif
/**
  * @brief  
  */
void vTest_DEF(void *params)
{
    static uint32_t timeout = 0;
    
    for (;;)
    {
        if (timeout++ > BUTTON_TIMEOUT) {
            timeout = 0;
            DefCounter = 0;
#ifdef LED_INIT_ERR
            LED_Off(LED_INIT_ERR);
#endif
#ifdef LED_ALARM
			LED_Off(LED_ALARM);
#endif
#ifdef LED_RED_MINOR
			LED_Off(LED_RED_MINOR);
#endif
            printf("DEF FAIL\r\n");
            TEST_SetTest(TEST_WAIT);
            ifTest_DEF = false;
            vTaskDelete(NULL);
        }  
	
        BUTTON_NoFixHandler(&defButton);
	
        if (DefCounter == 3)
        {
            timeout = 0;
            DefCounter = 0;
            printf("DEF OK\r\n");
	  
            /* Завершение теста T0 */
            /* Устанавливаем статус T0READY, сохраняем статус во флеш */
            COM_SetTestState(T0READY);
	  	    
            TEST_SetTest(TEST_WAIT);
            ifTest_DEF = false;
            vTaskDelete(NULL);
        }

        vTaskDelay(10);  
    }
    
}

/**
  * @brief
  */
void vTest_SET(void *params)
{
    static uint32_t timeout_set = 0;

    for (;;)
    {
        if (timeout_set++ > BUTTON_TIMEOUT) {
            timeout_set = 0;
            SetCounter = 0;
#ifdef LED_INIT_OK
            LED_Off(LED_INIT_OK);
#endif
#ifdef LED_GREEN_MINOR
			LED_Off(LED_GREEN_MINOR);
#endif
            printf("SET FAIL\r\n");
            TEST_SetTest(TEST_WAIT);
            ifTest_SET = false;
            vTaskDelete(NULL);
        }

        BUTTON_NoFixHandler(&setButton);

        if (SetCounter == 3)
        {
            timeout_set = 0;
            SetCounter = 0;
            printf("SET OK\r\n");

            /* Завершение теста T0 */
            /* Устанавливаем статус T0READY, сохраняем статус во флеш */
            COM_SetTestState(T0READY);

            TEST_SetTest(TEST_WAIT);
            ifTest_SET = false;
            vTaskDelete(NULL);
        }

        vTaskDelay(10);
    }

}

/**
  * @brief  Тестирование RTC
  */
void COM_TestRtc(void)
{
  /* Пытаемся синхронизироваться с NTP сервером */
  SNTP_Enable(true);
  SNTP_Poll();
  vTaskDelay(1000);

  /* Синхронизация удалась */
  if (ntpResult) {
    printf("RTC OK\r\n");
  }
  else
    printf("RTC FAIL SYNC\r\n");

  TEST_SetTest(TEST_WAIT);
}

/**
  * @brief  Тестирование SPIFLASH
  */
void COM_TestSPIflash(void)
{

  if (spi_flash_test()) {
    printf("SPIFLASH OK\r\n");
  }
  else
    printf("SPIFLASH FAIL SYNC\r\n");

  TEST_SetTest(TEST_WAIT);
}


/**
  * @brief  
  */
void Test_Ethernet(void)
{
    static bool ethernetInit = false;
    int timeout = 100; /* 10 sec timeout */
  
   // if (ethernetInit == false)
    {
        if (eth_ready_flag == 0) {
        	if(!ethernetInit){
        		ethernetInit = true;
				ETH_BSP_Config();
				 LwIP_Init();
        	}
        	else{
        		init_get_ip_address_controller();
        	}
        }
        /* Waiting ETH init */
        while ((eth_ready_flag == 0) && (timeout-- > 0)) {
            vTaskDelay(100);
        }

        if (eth_ready_flag == 0) {
            printf("ETH FAIL\r\n");
        }
        else {
            sys_thread_new("HTTP", vTaskTcpServer, NULL, 4*configMINIMAL_STACK_SIZE, tskIDLE_PRIORITY);
            ethernetInit = true;
        }
    }
  /*  else {
        printf("ETH OK\r\n");
    }*/
   
	TEST_SetTest(TEST_WAIT);
}

/**
  * @brief  
  */
void Test_Serno(void)
{
	macWaiting = true;
	macIsInstalled = false;
	
    // Устанавливаем статус тестирования "T1OK"
    COM_SetTestState(T0OK); 
    
    // Отправляем udp пакет с информацией
    //COM_TestSerno();  
	  
	// Пауза. В это время должен прийти GET запрос с MAC адресом. 
	//vTaskDelay(8000);
	//macWaiting = false;
	  
	//if (!macIsInstalled)
	//	printf("SERNO FAIL\r\n");
  
    for (uint8_t i = 0; i < 4; i++)
    {
        // Отправляем udp пакет с информацией
        COM_TestSerno();  
        // Пауза. В это время должен прийти GET запрос с MAC адресом. 
        vTaskDelay(8000);
        
        if (macIsInstalled)
            break;
    } 
    
    if (!macIsInstalled)
		printf("SERNO FAIL\r\n");
    
    TEST_SetTest(TEST_WAIT);
}


// -------------------------------------------------------------------------- //


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