RT-Thread-TA的回答

/*
 * Copyright (c) 2006-2021, RT-Thread Development Team
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date           Author       Notes
 * 2022-09-16     Administrator       the first version
 */
#include <rtthread.h>
#include <board.h>
#include <drivers/pin.h>
TIM_HandleTypeDef htim8;
#define    POWER1_CTRL                     GET_PIN(H,2)
/**
  * @brief TIM8 Initialization Function
  * @param None
  * @retval None
  */
static void MX_TIM8_Init(void)
{
  /* USER CODE BEGIN TIM8_Init 0 */
  /* USER CODE END TIM8_Init 0 */
  TIM_ClockConfigTypeDef sClockSourceConfig = {0};
  TIM_MasterConfigTypeDef sMasterConfig = {0};
  TIM_IC_InitTypeDef sConfigIC = {0};
  /* USER CODE BEGIN TIM8_Init 1 */
  /* USER CODE END TIM8_Init 1 */
  htim8.Instance = TIM8;
  htim8.Init.Prescaler = 180-1;
  htim8.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim8.Init.Period = 65535;
  htim8.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim8.Init.RepetitionCounter = 0;
  htim8.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  if (HAL_TIM_Base_Init(&htim8) != HAL_OK)
  {
    Error_Handler();
  }
  sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
  if (HAL_TIM_ConfigClockSource(&htim8, &sClockSourceConfig) != HAL_OK)
  {
    Error_Handler();
  }
  if (HAL_TIM_IC_Init(&htim8) != HAL_OK)
  {
    Error_Handler();
  }
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim8, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }
  sConfigIC.ICPolarity = TIM_INPUTCHANNELPOLARITY_RISING;
  sConfigIC.ICSelection = TIM_ICSELECTION_DIRECTTI;
  sConfigIC.ICPrescaler = TIM_ICPSC_DIV1;
  sConfigIC.ICFilter = 0;
  if (HAL_TIM_IC_ConfigChannel(&htim8, &sConfigIC, TIM_CHANNEL_1) != HAL_OK)
  {
    Error_Handler();
  }
  if (HAL_TIM_IC_ConfigChannel(&htim8, &sConfigIC, TIM_CHANNEL_2) != HAL_OK)
  {
    Error_Handler();
  }
  if (HAL_TIM_IC_ConfigChannel(&htim8, &sConfigIC, TIM_CHANNEL_3) != HAL_OK)
  {
    Error_Handler();
  }
  if (HAL_TIM_IC_ConfigChannel(&htim8, &sConfigIC, TIM_CHANNEL_4) != HAL_OK)
  {
    Error_Handler();
  }
    __HAL_TIM_DISABLE(&htim8);        //关闭定时器8
    __HAL_TIM_SET_COUNTER(&htim8,0);
    HAL_TIM_IC_Start_IT(&htim8,TIM_CHANNEL_1);   //开启TIM8的捕获通道1，并且开启捕获中断
    HAL_TIM_IC_Start_IT(&htim8,TIM_CHANNEL_2);   //开启TIM8的捕获通道2，并且开启捕获中断
    HAL_TIM_IC_Start_IT(&htim8,TIM_CHANNEL_3);   //开启TIM8的捕获通道3，并且开启捕获中断
    HAL_TIM_IC_Start_IT(&htim8,TIM_CHANNEL_4);   //开启TIM8的捕获通道4，并且开启捕获中断
    __HAL_TIM_ENABLE_IT(&htim8,TIM_IT_UPDATE);   //使能更新中断
    __HAL_TIM_ENABLE(&htim8);//使能定时器8
}
/**
* @brief TIM_Base MSP Initialization
* This function configures the hardware resources used in this example
* @param htim_base: TIM_Base handle pointer
* @retval None
*/
void HAL_TIM_Base_MspInit(TIM_HandleTypeDef* htim_base)
{
  GPIO_InitTypeDef GPIO_InitStruct = {0};
  if(htim_base->Instance==TIM8)
  {
  /* USER CODE BEGIN TIM8_MspInit 0 */
  /* USER CODE END TIM8_MspInit 0 */
    /* Peripheral clock enable */
    __HAL_RCC_TIM8_CLK_ENABLE();
    __HAL_RCC_GPIOI_CLK_ENABLE();
    /**TIM8 GPIO Configuration
    PI7     ------> TIM8_CH3
    PI6     ------> TIM8_CH2
    PI5     ------> TIM8_CH1
    PI2     ------> TIM8_CH4
    */
    GPIO_InitStruct.Pin = GPIO_PIN_7|GPIO_PIN_6|GPIO_PIN_5|GPIO_PIN_2;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull = GPIO_PULLDOWN;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    GPIO_InitStruct.Alternate = GPIO_AF3_TIM8;
    HAL_GPIO_Init(GPIOI, &GPIO_InitStruct);
    /* TIM8 interrupt Init */
    //HAL_NVIC_SetPriority(TIM8_BRK_TIM12_IRQn, 0, 0);
    //HAL_NVIC_EnableIRQ(TIM8_BRK_TIM12_IRQn);
    HAL_NVIC_SetPriority(TIM8_UP_TIM13_IRQn, 0, 0);
    HAL_NVIC_EnableIRQ(TIM8_UP_TIM13_IRQn);
    //HAL_NVIC_SetPriority(TIM8_TRG_COM_TIM14_IRQn, 0, 0);
    //HAL_NVIC_EnableIRQ(TIM8_TRG_COM_TIM14_IRQn);
    HAL_NVIC_SetPriority(TIM8_CC_IRQn, 0, 0);
    HAL_NVIC_EnableIRQ(TIM8_CC_IRQn);
  /* USER CODE BEGIN TIM8_MspInit 1 */
  /* USER CODE END TIM8_MspInit 1 */
  }
}
/**
* @brief TIM_Base MSP De-Initialization
* This function freeze the hardware resources used in this example
* @param htim_base: TIM_Base handle pointer
* @retval None
*/
void HAL_TIM_Base_MspDeInit(TIM_HandleTypeDef* htim_base)
{
  if(htim_base->Instance==TIM8)
  {
  /* USER CODE BEGIN TIM8_MspDeInit 0 */
  /* USER CODE END TIM8_MspDeInit 0 */
    /* Peripheral clock disable */
    __HAL_RCC_TIM8_CLK_DISABLE();
    /**TIM8 GPIO Configuration
    PI7     ------> TIM8_CH3
    PI6     ------> TIM8_CH2
    PI5     ------> TIM8_CH1
    PI2     ------> TIM8_CH4
    */
    HAL_GPIO_DeInit(GPIOI, GPIO_PIN_7|GPIO_PIN_6|GPIO_PIN_5|GPIO_PIN_2);
    /* TIM8 interrupt DeInit */
    //HAL_NVIC_DisableIRQ(TIM8_BRK_TIM12_IRQn);
    HAL_NVIC_DisableIRQ(TIM8_UP_TIM13_IRQn);
    //HAL_NVIC_DisableIRQ(TIM8_TRG_COM_TIM14_IRQn);
    HAL_NVIC_DisableIRQ(TIM8_CC_IRQn);
  /* USER CODE BEGIN TIM8_MspDeInit 1 */
  /* USER CODE END TIM8_MspDeInit 1 */
  }
}
void TIM8_UP_TIM13_IRQHandler(void)
{
    HAL_TIM_IRQHandler(&htim8);
}
/**
  * @brief This function handles TIM8 capture compare interrupt.
  */
void TIM8_CC_IRQHandler(void)
{
    HAL_TIM_IRQHandler(&htim8);
}
//捕获状态
//[7]:0,没有成功的捕获;1,成功捕获到一次.
//[6]:0,还没捕获到低电平;1,已经捕获到低电平了.
//[5:0]:捕获低电平后溢出的次数(对于32位定时器来说,1us计数器加1,溢出时间:4294秒)
rt_uint8_t TIM8CH3_CAPTURE_STA = 0; //输入捕获状态
rt_uint16_t TIM8CH3_CAPTURE_VAL;    //输入捕获值(TIM8是16位)
rt_uint16_t tim8ch3_cnt_zero;
rt_uint8_t TIM8CH4_CAPTURE_STA = 0; //输入捕获状态
rt_uint16_t TIM8CH4_CAPTURE_VAL;    //输入捕获值(TIM8是16位)
rt_uint16_t tim8ch4_cnt_zero;
rt_uint8_t TIM8CH2_CAPTURE_STA = 0; //输入捕获状态
rt_uint16_t TIM8CH2_CAPTURE_VAL;    //输入捕获值(TIM8是16位)
rt_uint16_t tim8ch2_cnt_zero;
rt_uint8_t TIM8CH1_CAPTURE_STA = 0; //输入捕获状态
rt_uint16_t TIM8CH1_CAPTURE_VAL;    //输入捕获值(TIM8是16位)
rt_uint16_t tim8ch1_cnt_zero;
//定时器更新中断（计数溢出）中断处理回调函数， 该函数在HAL_TIM_IRQHandler中会被调用
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)//更新中断（溢出）发生时执行
{
    rt_interrupt_enter();
    if((TIM8CH1_CAPTURE_STA & 0X80)==0)//还未成功捕获
     {
         if(TIM8CH1_CAPTURE_STA & 0X40)//已经捕获到高电平了
         {
             if((TIM8CH1_CAPTURE_STA & 0X3F) == 0X3F)//高电平太长了
             {
                 TIM8CH1_CAPTURE_STA |= 0X80;        //标记成功捕获了一次
                 TIM8CH1_CAPTURE_VAL = 0XFFFF;
             }
             else
                 TIM8CH1_CAPTURE_STA ++;
         }
     }
    if((TIM8CH2_CAPTURE_STA & 0X80)==0)//还未成功捕获
    {
        if(TIM8CH2_CAPTURE_STA & 0X40)//已经捕获到高电平了
        {
            if((TIM8CH2_CAPTURE_STA & 0X3F) == 0X3F)//高电平太长了
            {
                TIM8CH2_CAPTURE_STA |= 0X80;        //标记成功捕获了一次
                TIM8CH2_CAPTURE_VAL = 0XFFFF;
            }
            else
                TIM8CH2_CAPTURE_STA ++;
        }
    }
    if((TIM8CH3_CAPTURE_STA & 0X80)==0)//还未成功捕获
    {
        if(TIM8CH3_CAPTURE_STA & 0X40)//已经捕获到高电平了
        {
            if((TIM8CH3_CAPTURE_STA & 0X3F) == 0X3F)//高电平太长了
            {
                TIM8CH3_CAPTURE_STA |= 0X80;        //标记成功捕获了一次
                TIM8CH3_CAPTURE_VAL = 0XFFFF;
            }
            else
                TIM8CH3_CAPTURE_STA ++;
        }
    }
    if((TIM8CH4_CAPTURE_STA & 0X80)==0)//还未成功捕获
    {
        if(TIM8CH4_CAPTURE_STA & 0X40)//已经捕获到高电平了
        {
            if((TIM8CH4_CAPTURE_STA & 0X3F) == 0X3F)//高电平太长了
            {
                TIM8CH4_CAPTURE_STA |= 0X80;        //标记成功捕获了一次
                TIM8CH4_CAPTURE_VAL = 0XFFFF;
            }
            else
                TIM8CH4_CAPTURE_STA ++;
        }
    }
    rt_interrupt_leave();
}
//定时器输入捕获中断处理回调函数，该函数在HAL_TIM_IRQHandler中会被调用
void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim)//捕获中断发生时执行
{
    rt_interrupt_enter();
    if(htim->Channel == HAL_TIM_ACTIVE_CHANNEL_1)//捕获1发生捕获事件
    {
        if((TIM8CH1_CAPTURE_STA & 0X80) == 0)//还未成功捕获
        {
            if(TIM8CH1_CAPTURE_STA & 0X40)      //捕获到一个下降沿
            {
                TIM8CH1_CAPTURE_STA |= 0X80;        //标记成功捕获到一次高电平脉宽
                TIM8CH1_CAPTURE_VAL = TIM8->CCR1;
                TIM8->CCER &= ~(1<<1);//配置TIM8通道2上升沿捕获
            }
            else                                //还未开始,第一次捕获上升沿
            {
                tim8ch1_cnt_zero = TIM8->CCR1;
                TIM8CH1_CAPTURE_STA = 0;
                TIM8CH1_CAPTURE_VAL = 0;
                TIM8CH1_CAPTURE_STA |= 0X40;        //标记捕获到了上升沿
                TIM8->CCER |= 1<<1;//定时器8通道2设置为下降沿捕获
            }
        }
    }
    if(htim->Channel == HAL_TIM_ACTIVE_CHANNEL_2)//捕获2发生捕获事件
    {
        if((TIM8CH2_CAPTURE_STA & 0X80) == 0)//还未成功捕获
        {
            if(TIM8CH2_CAPTURE_STA & 0X40)      //捕获到一个下降沿
            {
                TIM8CH2_CAPTURE_STA |= 0X80;        //标记成功捕获到一次高电平脉宽
                TIM8CH2_CAPTURE_VAL = TIM8->CCR2;
                TIM8->CCER &= ~(1<<5);//配置TIM8通道2上升沿捕获
            }
            else                                //还未开始,第一次捕获上升沿
            {
                tim8ch2_cnt_zero = TIM8->CCR2;
                TIM8CH2_CAPTURE_STA = 0;
                TIM8CH2_CAPTURE_VAL = 0;
                TIM8CH2_CAPTURE_STA |= 0X40;        //标记捕获到了上升沿
                TIM8->CCER |= 1<<5;//定时器8通道2设置为下降沿捕获
            }
        }
    }
    if(htim->Channel == HAL_TIM_ACTIVE_CHANNEL_3)//捕获3发生捕获事件
    {
        if((TIM8CH3_CAPTURE_STA & 0X80) == 0)//还未成功捕获
        {
            if(TIM8CH3_CAPTURE_STA & 0X40)      //捕获到一个下降沿
            {
                TIM8CH3_CAPTURE_STA |= 0X80;        //标记成功捕获到一次高电平脉宽
                TIM8CH3_CAPTURE_VAL = TIM8->CCR3;
                TIM8->CCER &= ~(1<<9);//配置TIM8通道3上升沿捕获
            }
            else                                //还未开始,第一次捕获上升沿
            {
                tim8ch3_cnt_zero = TIM8->CCR3;
                TIM8CH3_CAPTURE_STA = 0;
                TIM8CH3_CAPTURE_VAL = 0;
                TIM8CH3_CAPTURE_STA |= 0X40;        //标记捕获到了上升沿
                TIM8->CCER |= 1<<9;//定时器8通道3设置为下降沿捕获
            }
        }
    }
    if(htim->Channel == HAL_TIM_ACTIVE_CHANNEL_4)//捕获4发生捕获事件
    {
        if((TIM8CH4_CAPTURE_STA & 0X80) == 0)//还未成功捕获
        {
            if(TIM8CH4_CAPTURE_STA & 0X40)      //捕获到一个下降沿
            {
                TIM8CH4_CAPTURE_STA |= 0X80;        //标记成功捕获到一次高电平脉宽
                TIM8CH4_CAPTURE_VAL = TIM8->CCR4;
                TIM8->CCER &= ~(1<<13);//配置TIM8通道3上升沿捕获
            }
            else                                //还未开始,第一次捕获上升沿
            {
                tim8ch4_cnt_zero = TIM8->CCR4;
                TIM8CH4_CAPTURE_STA = 0;
                TIM8CH4_CAPTURE_VAL = 0;
                TIM8CH4_CAPTURE_STA |= 0X40;        //标记捕获到了上升沿
                TIM8->CCER |= 1<<13;//定时器8通道3设置为下降沿捕获
            }
        }
    }
    rt_interrupt_leave();
}
extern float robot_aims_speed;
extern rt_uint8_t mknm4_fx;
void forword_check_speed(rt_uint16_t spedd)
{
    float sed_spd_f = 0;
    if(spedd > 550)
    {
        mknm4_fx = 0x09;
        sed_spd_f = (float)spedd;
        sed_spd_f = sed_spd_f - 550;
        robot_aims_speed = sed_spd_f * 0.001;
    }
    else if(spedd < 450)
    {
        mknm4_fx = 0x06;
        sed_spd_f = (float)spedd;
        sed_spd_f = 450 - sed_spd_f;
        robot_aims_speed = sed_spd_f * 0.001;
    }
    else
    {
        mknm4_fx = 0x00;
        robot_aims_speed = 0.0;
    }
}
void leftright_check_speed(rt_uint16_t lrdata)
{
    float sed_spd_f = 0;
    if(lrdata > 550)
    {
        mknm4_fx = 0x0F;
        sed_spd_f = (float)lrdata;
        sed_spd_f = sed_spd_f - 550;
        robot_aims_speed = sed_spd_f * 0.001;
    }
    else if(lrdata < 450)
    {
        mknm4_fx = 0x00;
        sed_spd_f = (float)lrdata;
        sed_spd_f = 450 - sed_spd_f;
        robot_aims_speed = sed_spd_f * 0.001;
    }
    else
    {
        mknm4_fx = 0x00;
        robot_aims_speed = 0.0;
    }
}
void zhuanxiang_check_speed(rt_uint16_t lrdata)
{
    float sed_spd_f = 0;
    if(lrdata > 550)
    {
        mknm4_fx = 0x00;
        sed_spd_f = (float)lrdata;
        sed_spd_f = sed_spd_f - 550;
        robot_aims_speed = sed_spd_f * 0.0005;
    }
    else if(lrdata < 450)
    {
        mknm4_fx = 0x0f;
        sed_spd_f = (float)lrdata;
        sed_spd_f = 450 - sed_spd_f;
        robot_aims_speed = sed_spd_f * 0.0005;
    }
    else
    {
        mknm4_fx = 0x00;
        robot_aims_speed = 0.0;
    }
}
void forback_leftright(rt_uint16_t fbdata,rt_uint16_t lrdata)
{
    float sed_spd_f = 0;
    if(fbdata > 550)
    {
        if(lrdata > 550)
        {
            mknm4_fx = 0x52;
            sed_spd_f = (float)lrdata;
            sed_spd_f = sed_spd_f - 550;
            robot_aims_speed = sed_spd_f * 0.0005;
            rt_kprintf("1\n");
        }
        else if(lrdata < 450)
        {
            mknm4_fx = 0x58;
            sed_spd_f = (float)lrdata;
            sed_spd_f = 450 - sed_spd_f;
            robot_aims_speed = sed_spd_f * 0.0005;
            rt_kprintf("2\n");
        }
    }
    else if(fbdata < 450)
    {
        if(lrdata > 550)
        {
            mknm4_fx = 0xa1;
            sed_spd_f = (float)lrdata;
            sed_spd_f = sed_spd_f - 550;
            robot_aims_speed = sed_spd_f * 0.0005;
            rt_kprintf("3 = %d\n",lrdata);
        }
        else if(lrdata < 450)
        {
            mknm4_fx = 0xa4;
            sed_spd_f = (float)lrdata;
            sed_spd_f = 450 - sed_spd_f;
            robot_aims_speed = sed_spd_f * 0.0005;
            //rt_kprintf("4 = %d\n",lrdata);
        }
    }
    else
    {
        mknm4_fx = 0x00;
        robot_aims_speed = 0.0;
    }
}
extern rt_uint8_t mknm4_lock_flag;
rt_uint32_t extern_tmp_ch3 = 0;
#define CSB_PRIORITY        15//任务优先级
static char csb_stack[800];
static struct rt_thread csb_thread;
static void csb_entry(void *parameter)
{
    rt_uint8_t print_ct = 0;
    rt_uint32_t tmp_ch4 = 0;
    rt_uint32_t tmp_ch3 = 0;
    rt_uint32_t tmp_ch2 = 0;
    rt_uint32_t tmp_ch1 = 0;
    rt_thread_mdelay(2000);
    MX_TIM8_Init();
    rt_pin_mode(POWER1_CTRL, PIN_MODE_OUTPUT);
    rt_pin_write(POWER1_CTRL, PIN_HIGH);
    while(1)
    {
        rt_thread_mdelay(10);
        if(TIM8CH1_CAPTURE_STA & 0X80)        //成功捕获到了一次高电平
        {
            if((TIM8CH1_CAPTURE_STA & 0X3F) == 0)//还没有溢出过
                tmp_ch1 = TIM8CH1_CAPTURE_VAL - tim8ch1_cnt_zero;
            else
                tmp_ch1 = (0XFFFF - tim8ch1_cnt_zero) + TIM8CH1_CAPTURE_VAL;
            if(tmp_ch1 > 2000)//油门通道
            {
                tmp_ch1 = 2000;
            }
            else if(tmp_ch1 < 1000)
            {
                tmp_ch1 = 1000;
            }
            tmp_ch1 = tmp_ch1 - 1000;
            if(tmp_ch1 < 100)
                tmp_ch1 = 0;
            TIM8CH1_CAPTURE_STA = 0;
        }
        if(TIM8CH2_CAPTURE_STA & 0X80)        //成功捕获到了一次高电平
        {
            if((TIM8CH2_CAPTURE_STA & 0X3F) == 0)//还没有溢出过
                tmp_ch2 = TIM8CH2_CAPTURE_VAL - tim8ch2_cnt_zero;
            else
                tmp_ch2 = (0XFFFF - tim8ch2_cnt_zero) + TIM8CH2_CAPTURE_VAL;
            if(tmp_ch2 > 2000)//油门通道
            {
                tmp_ch2 = 2000;
            }
            else if(tmp_ch2 < 1000)
            {
                tmp_ch2 = 1000;
            }
            tmp_ch2 = tmp_ch2 - 1000;
            if(tmp_ch2 < 100)
                tmp_ch2 = 0;
            TIM8CH2_CAPTURE_STA = 0;
        }
        if(TIM8CH3_CAPTURE_STA & 0X80)        //成功捕获到了一次高电平
        {
            if((TIM8CH3_CAPTURE_STA & 0X3F) == 0)//还没有溢出过
                tmp_ch3 = TIM8CH3_CAPTURE_VAL - tim8ch3_cnt_zero;
            else
                tmp_ch3 = (0XFFFF - tim8ch3_cnt_zero) + TIM8CH3_CAPTURE_VAL;
            if(tmp_ch3 > 2000)//左右通道
            {
                tmp_ch3 = 2000;
            }
            else if(tmp_ch3 < 1000)
            {
                tmp_ch3 = 1000;
            }
            tmp_ch3 = tmp_ch3 - 1000;
            TIM8CH3_CAPTURE_STA = 0;
        }
        if(TIM8CH4_CAPTURE_STA & 0X80)        //成功捕获到了一次高电平
        {
            if((TIM8CH4_CAPTURE_STA & 0X3F) == 0)//还没有溢出过
                tmp_ch4 = TIM8CH4_CAPTURE_VAL - tim8ch4_cnt_zero;
            else
                tmp_ch4 = (0XFFFF - tim8ch4_cnt_zero) + TIM8CH4_CAPTURE_VAL;
            if(tmp_ch4 > 2000)//前后通道
            {
                tmp_ch4 = 2000;
            }
            else if(tmp_ch4 < 1000)
            {
                tmp_ch4 = 1000;
            }
            tmp_ch4 = tmp_ch4 - 1000;
            TIM8CH4_CAPTURE_STA = 0;
        }
        //右手、前ch3-->1000,后ch3-->0，前后走
        if(((tmp_ch3 < 450) || (tmp_ch3 > 550)) && ((tmp_ch2 < 450) || (tmp_ch2 > 550)))
        {
            //forback_leftright(tmp_ch2,tmp_ch3);
            mknm4_lock_flag = 0;
        }
        else if((tmp_ch3 < 450) || (tmp_ch3 > 550))
        {
            //forword_check_speed(tmp_ch3);
            mknm4_lock_flag = 0;
        }
/*
        if(tmp_ch3 < 100)
        {
            mknm4_lock_flag = 0;
            mknm4_fx = 0x0F;
            robot_aims_speed = 0.2;
        }
  */
        if((tmp_ch3 < 200))
        {
            //右手、左ch1-->1000,右ch1-->0，横走
           if((tmp_ch1 < 450) || (tmp_ch1 > 550))
           {
               leftright_check_speed(tmp_ch1);
               mknm4_lock_flag = 0;
           }
           else
           {
               mknm4_lock_flag = 1;
               mknm4_fx = 0x00;
               robot_aims_speed = 0.0;
           }
        }
        else
        {
            mknm4_lock_flag = 1;
            mknm4_fx = 0x00;
            robot_aims_speed = 0.0;
        }
        if(tmp_ch1 == 0 && tmp_ch2 == 0 && tmp_ch3 == 0 && tmp_ch4 == 0)
        {
            mknm4_lock_flag = 1;
            mknm4_fx = 0x00;
            robot_aims_speed = 0.0;
        }
        print_ct ++;
        if(print_ct > 100)
        {
            print_ct = 0;
            rt_kprintf("CH1 = %d,CH2 = %d,CH3 = %d,CH5 = %d\n",tmp_ch1,tmp_ch2,tmp_ch3,tmp_ch4);
        }
        extern_tmp_ch3 = tmp_ch3;
    }
}
static int csb_sample(void)
{
    rt_thread_init(&csb_thread,
    "csbsample",
    csb_entry,
    RT_NULL,
    &csb_stack[0],
    sizeof(csb_stack),
    CSB_PRIORITY,100);
    rt_thread_startup(&csb_thread);
    return 0;
}
INIT_APP_EXPORT(csb_sample);

1 条评论收藏感谢

问 STUDIO ota DAP下载不能跳转

发布于3年前

这个问题官方还没解决吗，同样的程序用st-link下载可以运行，用DAP-link下载连BootLoader都不运行了。感觉是BootLoader被覆盖掉了。

0 条评论收藏感谢

问 can调试的问题，rt_device_write阻塞

发布于4年前

楼主解决了吗，我也遇到同样的问题，can发送很多次后会阻塞在size = rt_device_write(can_dev, 0, &msg1, sizeof(msg1));这里，无法向下执行了。
也不是每次都出现，有时候运行上一个多小时才会出现这个问题，不知道rt_device_write是否可以设置超时时间。

2 条评论收藏感谢