sggt/App/APP_WU/Src/timer.c

#include "timer.h"

int heart_1000ms_flag = 0;
int heart_1000ms_cnt = 0;
int battery_2000ms_flag = 0;
int battery_2000ms_cnt = 0;
int plot_ms_flag = 0;
int plot_ms_cnt = 0;
int twk_1000ms_flag = 0;
int twk_1000ms_cnt = 0;
int input_500ms_flag = 0;
int input_500ms_cnt = 0;
uint16_t sig2slave_previous_tick = 0;
uint16_t sig2slave_current_tick = 0;

void duty_tim3(void)
{
    freq_signal.over_cnt++;

}

void duty_tim6(void)
{
    //lv_tick_inc(1);
    
    heart_1000ms_cnt++;
    if( heart_1000ms_cnt >= 1000)
    {
      heart_1000ms_cnt = 0;
      heart_1000ms_flag = 1;
    }

    battery_2000ms_cnt++;
    if( battery_2000ms_cnt >= 2000)
    {
      battery_2000ms_cnt = 0;
      battery_2000ms_flag = 1;
    }

    plot_ms_cnt++;
    if( plot_ms_cnt >= tabdata.item1_page0_sample_interval)
    {
      plot_ms_cnt = 0;
      plot_ms_flag = 1;
    }

    twk_1000ms_cnt++;
    if( twk_1000ms_cnt >= 1000)
    {
      twk_1000ms_cnt = 0;
      twk_1000ms_flag = 1;
    }

    input_500ms_cnt++;
    if( input_500ms_cnt >= 500)
    {
      input_500ms_cnt = 0;
      input_500ms_flag = 1;
    }

    //发送完成 或者 已经接收到一部分数据之后开始计时
    if( (sig2slave_step == 1)||(mod_master.tx_flag == TX_OK) )
    {
      sig2slave_current_tick++;
      mod_master.rx_error_message = RX_ERROR_NONE;

      if(sig2slave_current_tick > mod_master.timeout)
      {
        if(sig2slave_step == 0)
        {
          //进入此处说明发送成功后未收到任何数据
          mod_master.rx_error_message = RX_ERROR_TIMEOUT;
          mod_master.tx_flag = TX_NONE;
        }

        HAL_UART_DMAStop(&huart2);
        __HAL_UART_CLEAR_IDLEFLAG(&huart2);
    
        sig2slave_current_tick = 0;
        sig2slave_step = 2;                       //无论是哪个阶段出现超时，均跳转至step2
        scom2_rs485.rx_flag = TRUE;
        sig_trans = TRANS_MODBUS_SIG_TO_SLAVE;    //发送回调中会修改成none，因此在这里重新赋值（接收超时也属于接收的一种结果）
      }
    }
}

void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
{
  //记录发送完成的时间点
  st_flag = TRANSPARENT_TRANSMIT_END;
  tick_end = xTaskGetTickCountFromISR();

  //计算延迟，捕获失败时清零（速度过快，小于1ms）
  //trans_log_rx = tick_middle - tick_start;
  //if(trans_log_rx > 1000) trans_log_rx = 0;
  trans_log_tx = tick_end - tick_middle;
  if(trans_log_tx > 1000) trans_log_tx = 0;

  //发送完成后将相关数组清零
  if(huart == &huart1)
  {
    //HART重新使能接收
    HART_RTS(RTS_OFF);
    
    memset(scom1_hart.tx_buff, 0, scom1_hart.tx_len);
    scom1_hart.tx_len = 0;

    //PC--->SIG--->HART，重新开启485的DMA
    HAL_UART_Receive_DMA(&huart2, scom2_rs485.rx_buff, BUFFER_SIZE);
  }

  if(huart == &huart2)
  {
    memset(scom2_rs485.tx_buff, 0, scom2_rs485.tx_len);
    scom2_rs485.tx_len = 0;

    //开启对应的DMA
    switch (sig_trans)
    {
      case TRANS_HART_TO_PC:
      {
        HAL_UART_Receive_DMA(&huart1, scom1_hart.rx_buff, BUFFER_SIZE);
      }
      break;

      case TRANS_BLE_TO_PC:
      {
        HAL_UART_Receive_DMA(&huart6, scom6_ble.rx_buff, BUFFER_SIZE);
      }
      break;

      case TRANS_MODBUS_PC_TO_SIG:
      {
        HAL_UART_Receive_DMA(&huart2, scom2_rs485.rx_buff, BUFFER_SIZE);
      }
      break;

      case TRANS_MODBUS_SIG_TO_SLAVE:
      {
        mod_master.tx_flag = TX_OK;
        HAL_UART_Receive_DMA(&huart2, scom2_rs485.rx_buff, BUFFER_SIZE);
        sig2slave_current_tick = 0;
      }
      break;
    
      default:
      break;
    }
  }

  if(huart == &huart6)
  {
    memset(scom6_ble.tx_buff, 0, scom6_ble.tx_len);
    scom6_ble.tx_len = 0;

    //PC--->SIG--->BLE，重新开启485的DMA
    HAL_UART_Receive_DMA(&huart2, scom2_rs485.rx_buff, BUFFER_SIZE);
  }

  //通讯模式清空，等待下一次接收
  sig_trans = TRANS_NONE;

  //如果显示任务被挂起，则在此处释放（无DMA的情况）
  if(screen_suspend_flag)
  {
    xTaskResumeFromISR(task_lcdHandle);
    xTaskResumeFromISR(task_menuHandle);
    screen_suspend_flag = 0;
  }
}

void delay_cnt(uint16_t cnt)
{
  while(cnt > 0)
  {
    cnt--;
  }
}

#define CPU_FREQUENCY_MHZ    165.888		// STM32时钟主频
void wu_delay_us(__IO uint32_t delay)
{
    int last, curr, val;
    int temp;

    while (delay != 0)
    {
        temp = delay > 900 ? 900 : delay;
        last = SysTick->VAL;
        curr = last - CPU_FREQUENCY_MHZ * temp;
        if (curr >= 0)
        {
            do
            {
                val = SysTick->VAL;
            }
            while ((val < last) && (val >= curr));
        }
        else
        {
            curr += CPU_FREQUENCY_MHZ * 1000;
            do
            {
                val = SysTick->VAL;
            }
            while ((val <= last) || (val > curr));
        }
        delay -= temp;
    }
}