2023蓝桥杯嵌入式14届程序题

这里占空比需要用斜率求

Y = k x + b Y = kx+b Y=kx+b

k = y − y 0 x − x 0 k = \frac{y-y0}{x-x0} k=xx0yy0

b = y 0 − k x 0 b = y0-kx0 b=y0kx0
代入公式:

k = 0.85 − 0.1 3 − 1 = 0.375 k = \frac{0.85-0.1}{3-1}=0.375 k=310.850.1=0.375

0.85 − 0.375 × 3 = − 0.275 0.85-0.375\times3 = -0.275 0.850.375×3=0.275

Y = 0.375 x − 0.275 Y=0.375x-0.275 Y=0.375x0.275

main.c

int main(void)
{
    vHardware_Init();

    while(1)
    {
        vLcd_Display_function();
        vRun_Flag_function();
    }
}

my.h

#ifndef __MY_H
#define __MY_H
#include "main.h"
#include "adc.h"
#include "dma.h"
#include "tim.h"
#include "usart.h"
#include "gpio.h"
#include "lcd.h"


#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>

#define KEY1 HAL_GPIO_ReadPin(GPIOB,GPIO_PIN_0)
#define KEY2 HAL_GPIO_ReadPin(GPIOB,GPIO_PIN_1)
#define KEY3 HAL_GPIO_ReadPin(GPIOB,GPIO_PIN_2)
#define KEY4 HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0)
#define TEST 0	//打印测试

typedef struct
{
    uint8_t HightLight_Flag;	//高亮标志位默认R
    float Adc_Value;	//ADC值
    bool LCD_OVER_FLAG;	//LCD刷新标志位
    uint8_t Key_Down_State[8];	//按键状态
    bool Adc_Over_Flag;	//ADC接收完成标志位
    uint8_t H_or_L_State;	//高低频状态
    bool Fre_5s_Flag;	//频率5s标志位
    uint8_t Lock_State;	//是否锁标志位
    uint8_t Lcd_Dis_Choose_State;	//界面显示状态
} MYDATA_TypeDef;

typedef struct
{
    uint16_t PA1_Fre;	//PA1输出频率
    uint8_t Data_P;	//实时占空比
    float Data_V;	//实时速度
    uint8_t Para_R;	//参数R
    uint8_t Para_K;	//参数K
    uint16_t Recd_N;	//输出模式切换次数
    float Recd_MH;	//输出模式下高频模式速度最大值
    float Recd_ML;	//输出模式下低频模式速度最小值

} PARAMETER_TypeDef;

typedef struct
{
    bool IC_OVER_FLAG;	//计算速度完成标志位
    uint32_t One_Value;	//第1次
    uint32_t Two_Value;	//第2次
    uint32_t Three_Value;	//第3次
    uint32_t Four_Value;	//第4次
    uint16_t Fre_Value;	//频率
    float Duty_Value;	//占空比
    uint8_t IC_RUN_STATE;	//运行状态
} PWMDATA_TypeDef;


extern MYDATA_TypeDef MyData;
extern PARAMETER_TypeDef ParameterData;
extern PWMDATA_TypeDef PwmData;

void vLed_Control2(uint8_t swch, uint8_t num);
void vAdc_Get_function(void);
void vRun_Flag_function(void);
uint8_t ucKey_Scan(void);
void vKey_function(void);
void vHardware_Init(void);
void vLed_Control(uint8_t led_num);
void vLcd_Display_function(void);
#endif

my.c

MYDATA_TypeDef MyData =
{
    .HightLight_Flag = 1,
    .Adc_Value = 0.0,
    .LCD_OVER_FLAG = 0,
    .Key_Down_State = {0},
    .Adc_Over_Flag = 0,
    .H_or_L_State = 1,
    .Fre_5s_Flag = 0,
    .Lock_State = 0,
    .Lcd_Dis_Choose_State = 1,
};

PARAMETER_TypeDef ParameterData =
{
    .PA1_Fre = 4000,
    .Data_P = 0,
    .Data_V = 0,
    .Para_R = 1,
    .Para_K = 1,
    .Recd_N = 0,
    .Recd_MH = 0,
    .Recd_ML = 0,
};

PWMDATA_TypeDef PwmData =
{
	.IC_OVER_FLAG = 0,
    .One_Value = 0,
    .Two_Value = 0,
    .Three_Value = 0,
    .Four_Value = 0,
    .Fre_Value = 0,
    .Duty_Value = 0,
    .IC_RUN_STATE = 0,
};

//全局变量
uint16_t Led_State = 0xFF;	//LED初始状态
uint8_t Key_Up, Key_Down, Key_Value;	//按键相关
uint16_t Key_Time = 0;

//显示数组
char Lcd_dis1_Arr[20] = "\0";
char Lcd_dis2_Arr[20] = "\0";
char Lcd_dis3_Arr[20] = "\0";
char Lcd_dis4_Arr[20] = "\0";
uint8_t R_temp = 1;	//临时变量 用于LCD显示
uint8_t K_temp = 1;	//临时变量
uint32_t ADC_BUFF[10];	//ADC DMA存储数组

void vHardware_Init(void)
{
    LCD_Init();
    LCD_Clear(Black);
    LCD_SetBackColor(Black);
    LCD_SetTextColor(White);
    vLed_Control2(RESET, 0xFF);
    HAL_TIM_Base_Start_IT(&htim6);
    HAL_ADCEx_Calibration_Start(&hadc2, ADC_SINGLE_ENDED);
    HAL_ADC_Start_DMA(&hadc2, (uint32_t *)&ADC_BUFF, 10);
    TIM2->CCR2 = 125;
    HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_2);
    HAL_TIM_IC_Start_IT(&htim3, TIM_CHANNEL_2);
}
void vLed_Control(uint8_t led_num)
{
    uint16_t a = GPIOC->ODR;
    GPIOC->ODR = (uint16_t)led_num << 8;
    HAL_GPIO_WritePin(GPIOD, GPIO_PIN_2, GPIO_PIN_SET);
    HAL_GPIO_WritePin(GPIOD, GPIO_PIN_2, GPIO_PIN_RESET);
    GPIOC->ODR = a;
}

void vLed_Control2(uint8_t swch, uint8_t num)
{
    if(SET == swch)
    {
        HAL_GPIO_WritePin(GPIOC, (uint16_t)num << 8, GPIO_PIN_RESET);
    }
    else
    {
        HAL_GPIO_WritePin(GPIOC, (uint16_t)num << 8, GPIO_PIN_SET);
    }
    HAL_GPIO_WritePin(GPIOD, GPIO_PIN_2, GPIO_PIN_SET);
    HAL_GPIO_WritePin(GPIOD, GPIO_PIN_2, GPIO_PIN_RESET);
}
void vLcd_Display_function(void)
{
    if(MyData.LCD_OVER_FLAG)
    {
        memset(Lcd_dis1_Arr, ' ', sizeof(Lcd_dis1_Arr));
        memset(Lcd_dis2_Arr, ' ', sizeof(Lcd_dis2_Arr));
        memset(Lcd_dis3_Arr, ' ', sizeof(Lcd_dis3_Arr));
        memset(Lcd_dis4_Arr, ' ', sizeof(Lcd_dis4_Arr));
        if(1 == MyData.Lcd_Dis_Choose_State)
        {
            MyData.HightLight_Flag = 1;	//高亮索引初始化
            snprintf(Lcd_dis1_Arr, sizeof(Lcd_dis1_Arr), "        DATA        ");
            LCD_DisplayStringLine(Line1, (uint8_t *)Lcd_dis1_Arr);

            if(1 == MyData.H_or_L_State)	//低 默认上电
            {
                snprintf(Lcd_dis2_Arr, sizeof(Lcd_dis2_Arr), "     M=L            ");
                LCD_DisplayStringLine(Line3, (uint8_t *)Lcd_dis2_Arr);
            }
            else if(2 == MyData.H_or_L_State)	//高
            {
                snprintf(Lcd_dis2_Arr, sizeof(Lcd_dis2_Arr), "     M=H            ");
                LCD_DisplayStringLine(Line3, (uint8_t *)Lcd_dis2_Arr);
            }

            snprintf(Lcd_dis3_Arr, sizeof(Lcd_dis3_Arr), "     P=%d%%          ", ParameterData.Data_P);
            LCD_DisplayStringLine(Line4, (uint8_t *)Lcd_dis3_Arr);

            snprintf(Lcd_dis4_Arr, sizeof(Lcd_dis4_Arr), "     V=%.1f          ", ParameterData.Data_V);
            LCD_DisplayStringLine(Line5, ( uint8_t *)Lcd_dis4_Arr);

            Led_State = (~0x01)&Led_State;	//LED1亮
        }
        else if(2 == MyData.Lcd_Dis_Choose_State)
        {
            snprintf(Lcd_dis1_Arr, sizeof(Lcd_dis1_Arr), "        PARA        ");
            LCD_DisplayStringLine(Line1, (uint8_t *)Lcd_dis1_Arr);

            snprintf(Lcd_dis2_Arr, sizeof(Lcd_dis2_Arr), "     R=%d           ", R_temp);
            snprintf(Lcd_dis3_Arr, sizeof(Lcd_dis3_Arr), "     K=%d           ", K_temp);

            if(1 == MyData.HightLight_Flag)	//高亮R
            {
                LCD_SetTextColor(White);
                LCD_DisplayStringLine(Line3, (uint8_t *)Lcd_dis2_Arr);
                LCD_SetTextColor(Green);
                LCD_DisplayChar(Line3, 319 - (5 * 16), 'R');

                LCD_SetTextColor(White);
                LCD_DisplayStringLine(Line4, (uint8_t *)Lcd_dis3_Arr);
            }
            else if(2 == MyData.HightLight_Flag)	//高亮K
            {
                LCD_SetTextColor(White);
                LCD_DisplayStringLine(Line4, (uint8_t *)Lcd_dis3_Arr);
                LCD_SetTextColor(Green);
                LCD_DisplayChar(Line4, 319 - (5 * 16), 'K');

                LCD_SetTextColor(White);
                LCD_DisplayStringLine(Line3, (uint8_t *)Lcd_dis2_Arr);
            }
            Led_State = (0x01) | Led_State;	//LED1灭
        }
        else if(3 == MyData.Lcd_Dis_Choose_State)
        {
            //退出参数页面,参数生效
            ParameterData.Para_R = R_temp;
            ParameterData.Para_K = K_temp;

            snprintf(Lcd_dis1_Arr, sizeof(Lcd_dis1_Arr), "        RECD        ");
            LCD_DisplayStringLine(Line1, (uint8_t *)Lcd_dis1_Arr);

            snprintf(Lcd_dis2_Arr, sizeof(Lcd_dis2_Arr), "     N=%d            ", ParameterData.Recd_N);
            LCD_DisplayStringLine(Line3, (uint8_t *)Lcd_dis2_Arr);

            snprintf(Lcd_dis3_Arr, sizeof(Lcd_dis3_Arr), "     MH=%.1f           ", ParameterData.Recd_MH);
            LCD_DisplayStringLine(Line4, (uint8_t *)Lcd_dis3_Arr);

            snprintf(Lcd_dis4_Arr, sizeof(Lcd_dis4_Arr), "     ML=%.1f           ", ParameterData.Recd_ML);
            LCD_DisplayStringLine(Line5, (uint8_t *)Lcd_dis4_Arr);
            Led_State = (0x01) | Led_State;	//LED1灭
        }
        vLed_Control(Led_State);
        MyData.LCD_OVER_FLAG = 0;
    }
}
//获取ADC值并且计算占空比
void vAdc_Get_function(void)
{
    uint32_t Adc_temp = 0;
    uint8_t count = 0;
    uint16_t Adc_temp2 = 0;
    double Adc_temp3 = 0.0;
    static double Adc_Old_Value = 0;

    HAL_ADC_Stop_DMA(&hadc2);
    for(uint8_t i = 0; i < 10 - 1; i++)
    {
        count = 0;
        for(uint8_t j = 0; j < 10 - 1 - i; j++)
        {
            if(ADC_BUFF[j] > ADC_BUFF[j + 1])
            {
                uint32_t temp = ADC_BUFF[j];
                ADC_BUFF[j] = ADC_BUFF[j + 1];
                ADC_BUFF[j + 1] = temp;
                count++;
            }
        }
        if(!count)
        {
            break;
        }
    }
    for(uint8_t k = 1; k < 10 - 1; k++)
    {
        Adc_temp += ADC_BUFF[k];
    }
    HAL_ADC_Start_DMA(&hadc2, (uint32_t *)&ADC_BUFF, 10);
    MyData.Adc_Value = (double)(Adc_temp / 8) / 4096 * 3.3f;
    Adc_temp2 = MyData.Adc_Value * 10;	//扩大10倍
    Adc_temp3 = (double)Adc_temp2 / 10;
    //改了频率,记得占空比也要改!!
    if(!MyData.Lock_State)	//解锁状态下
    {
        if((Adc_temp3 >= 0) && (Adc_temp3 <= 1))	//10%占空比
        {
            TIM2->CCR2 = (TIM2->ARR * 0.1);
            ParameterData.Data_P = 10;
        }
        else if(Adc_temp3 >= 3)	//85%占空比
        {
            TIM2->CCR2 = (TIM2->ARR * 0.85);
            ParameterData.Data_P = 85;
        }
        else	//其余情况
        {
            Adc_temp3 = (0.375 * Adc_temp3) - 0.275;
            TIM2->CCR2 = ((TIM2->ARR) * Adc_temp3);
            ParameterData.Data_P = Adc_temp3 * 100;
        }
    }
    MyData.Adc_Over_Flag = 1;
}
uint8_t ucKey_Scan(void)
{
    if((!KEY1) || (!KEY2) || (!KEY3) || (!KEY4))
    {
        if(!KEY1)
            return 1;
        if(!KEY2)
            return 2;
        if(!KEY3)
            return 3;
        if(!KEY4)
            return 4;
    }
    return 0;
}

void vKey_function(void)
{
    static uint8_t Key_Old_Value;

    Key_Value = ucKey_Scan();
    Key_Up = ~Key_Value & (Key_Value ^ Key_Old_Value);
    Key_Down = Key_Value & (Key_Value ^ Key_Old_Value);
    Key_Old_Value = Key_Value;

    if(Key_Down)
    {
        Key_Time = 0;
    }
    if(Key_Time < 20)
    {
        switch(Key_Up)
        {
        case 1:
        {
            MyData.Key_Down_State[0] = 1;
            break;
        }
        case 2:
        {
            MyData.Key_Down_State[1] = 1;
            break;
        }
        case 3:
        {
            MyData.Key_Down_State[2] = 1;
            break;
        }
        case 4:
        {
            MyData.Key_Down_State[3] = 1;
            break;
        }
        default:
            break;
        }
    }
    else
    {
        switch(Key_Value)
        {
        case 1:
        {
            MyData.Key_Down_State[4] = 1;
            break;
        }
        case 2:
        {
            MyData.Key_Down_State[5] = 1;
            break;
        }
        case 3:
        {
            MyData.Key_Down_State[6] = 1;
            break;
        }
        case 4:
        {
            MyData.Key_Down_State[7] = 1;
            break;
        }
        default:
            break;
        }
    }
}
void vRun_Flag_function(void)
{
    static uint8_t choose_Flag = 1;	//R、K切换

    if(MyData.Key_Down_State[0])	//界面切换
    {
        MyData.Key_Down_State[0] = 0;
        MyData.Lcd_Dis_Choose_State++;
        if(MyData.Lcd_Dis_Choose_State > 3)
        {
            MyData.Lcd_Dis_Choose_State = 1;
        }
        LCD_Clear(Black);	//清屏
    }
    if(MyData.Key_Down_State[1])
    {
        MyData.Key_Down_State[1] = 0;
        if((1 == MyData.Lcd_Dis_Choose_State) && (0 == MyData.Fre_5s_Flag))	//数据页面下
        {
            MyData.Fre_5s_Flag = 1;
        }
        else if(2 == MyData.Lcd_Dis_Choose_State)	//参数页面下
        {
            choose_Flag = !choose_Flag;
            if(!choose_Flag)	//选择K
            {
                MyData.HightLight_Flag = 2;

            }
            else	//选择R
            {
                MyData.HightLight_Flag = 1;
            }
        }
        else
        {
            ;
        }
    }
    if(MyData.Key_Down_State[2])
    {
        MyData.Key_Down_State[2] = 0;
        if(2 == MyData.Lcd_Dis_Choose_State)
        {
            if(1 == MyData.HightLight_Flag)
            {
                R_temp++;
                if(R_temp > 10)
                {
                    R_temp = 10;
                }
            }
            if(2 == MyData.HightLight_Flag)
            {
                K_temp++;
                if(K_temp > 10)
                {
                    K_temp = 10;
                }
            }
        }
    }
    if(MyData.Key_Down_State[3])
    {
        MyData.Key_Down_State[3] = 0;
        if(2 == MyData.Lcd_Dis_Choose_State)
        {
            if(1 == MyData.HightLight_Flag)
            {
                R_temp--;
                if(R_temp < 1)
                {
                    R_temp = 1;
                }
            }
            if(2 == MyData.HightLight_Flag)
            {
                K_temp--;
                if(K_temp < 1)
                {
                    K_temp = 1;
                }
            }
        }
        else if(1 == MyData.Lcd_Dis_Choose_State)
        {
            if(MyData.Lock_State)	//锁状态
            {
                MyData.Lock_State = 0;	//解锁
                Led_State = (0x04) | Led_State;	//LED3灭
                vLed_Control(Led_State);
            }
        }
    }
    if(MyData.Key_Down_State[7])	//长按
    {
        MyData.Key_Down_State[7] = 0;
        MyData.Lock_State = 1;	//锁
        Led_State = (~0x04)&Led_State;	//LED3亮
        vLed_Control(Led_State);
    }
    if(MyData.Adc_Over_Flag)
    {
        MyData.Adc_Over_Flag = 0;
#if TEST
        char arr[20];
        snprintf(arr, sizeof(arr), "ADC:%.1f\r\n", MyData.Adc_Value);
        HAL_UART_Transmit(&huart1, (uint8_t *)arr, strlen(arr), 500);
#endif
    }
    if(4 == PwmData.IC_RUN_STATE)	//计算实时速度
    {
        PwmData.Fre_Value = 1000000 / (PwmData.Four_Value - PwmData.Two_Value);
        PwmData.Duty_Value = (float)(PwmData.Four_Value - PwmData.Three_Value) / (float)(PwmData.Four_Value - PwmData.Two_Value) * 100;
        ParameterData.Data_V = (float)(PwmData.Fre_Value * 2 * 3.14 * ParameterData.Para_R) / (float)(100 * ParameterData.Para_K);
#if TEST
        char arr[20];
        snprintf(arr, sizeof(arr), "fre:%d--%.1f\r\n", PwmData.Fre_Value, PwmData.Duty_Value);
        HAL_UART_Transmit(&huart1, (uint8_t *)arr, strlen(arr), 500);
#endif
        PwmData.IC_RUN_STATE = 0;
        HAL_TIM_IC_Start_IT(&htim3, TIM_CHANNEL_2);
		PwmData.IC_OVER_FLAG = 1;	//计算完成标志位
    }
}
void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim)
{
    if(htim == &htim3)
    {
        if(htim->Channel == HAL_TIM_ACTIVE_CHANNEL_2)
        {
            switch(PwmData.IC_RUN_STATE)
            {
            case 0:
            {
                PwmData.One_Value = TIM3->CCR2;
                __HAL_TIM_SET_CAPTUREPOLARITY(&htim3, TIM_CHANNEL_2, TIM_INPUTCHANNELPOLARITY_FALLING);	//下降沿
                PwmData.IC_RUN_STATE = 1;
                break;
            }
            case 1:
            {
                PwmData.Two_Value = TIM3->CCR2;
                __HAL_TIM_SET_CAPTUREPOLARITY(&htim3, TIM_CHANNEL_2, TIM_INPUTCHANNELPOLARITY_RISING);	//上升沿
                PwmData.IC_RUN_STATE = 2;
                break;
            }
            case 2:
            {
                PwmData.Three_Value = TIM3->CCR2;
                __HAL_TIM_SET_CAPTUREPOLARITY(&htim3, TIM_CHANNEL_2, TIM_INPUTCHANNELPOLARITY_FALLING);	//下降沿
                PwmData.IC_RUN_STATE = 3;
                break;
            }
            case 3:
            {
                PwmData.Four_Value = TIM3->CCR2;
                __HAL_TIM_SET_CAPTUREPOLARITY(&htim3, TIM_CHANNEL_2, TIM_INPUTCHANNELPOLARITY_RISING);	//上升沿
                HAL_TIM_IC_Stop_IT(&htim3, TIM_CHANNEL_2);
                __HAL_TIM_SetCounter(&htim3, 0);
                PwmData.IC_RUN_STATE = 4;
                break;
            }
            }
        }
    }
}
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
    static uint8_t Tim_10ms_count = 0;
    static uint8_t Tim_100ms_count = 0;
    static uint8_t Tim_150ms_count = 0;
    static uint16_t Tim_5s_count = 0;
	static uint16_t Tim_2s_count = 0;
	
    if(htim == &htim6)
    {
        Tim_10ms_count++;
        Tim_100ms_count++;
        Tim_150ms_count++;

        if(10 == Tim_10ms_count)
        {
            Tim_10ms_count = 0;
            vKey_function();
        }
        if(100 == Tim_100ms_count)
        {
            Tim_100ms_count = 0;
            MyData.LCD_OVER_FLAG = 1;
            Key_Time++;
        }
        if(150 == Tim_150ms_count)
        {
            Tim_150ms_count = 0;
            vAdc_Get_function();
        }
        if(MyData.Fre_5s_Flag)	//5s计时
        {
            Tim_5s_count++;
            if(5000 == Tim_5s_count)
            {
                Tim_5s_count = 0;
                MyData.Fre_5s_Flag = 0;
                //转换完成
                if(1 == MyData.H_or_L_State)
				{
					MyData.H_or_L_State = 2;
					
				}   
                else if(2 == MyData.H_or_L_State)
				{
					MyData.H_or_L_State = 1;
				}                   
                ParameterData.Recd_N++;	//切换次数加1

            }
            if(0 == (Tim_5s_count % 100))	//50次
            {
                Led_State ^= 2;
                vLed_Control(Led_State);
                if(1 == MyData.H_or_L_State)	//当前为低频---》高
                {
                    ParameterData.PA1_Fre += 80;
                    if(ParameterData.PA1_Fre >= 8000)
                    {
                        ParameterData.PA1_Fre = 8000;
                    }
                    //改了频率,记得占空比也要改!!
                    TIM2->ARR = (1000000.0f / ParameterData.PA1_Fre) - 1;
                    TIM2->CCR2 = (ParameterData.Data_P / 100.0f) * (TIM2->ARR);
                }
                else if(2 == MyData.H_or_L_State)	//当前为高频---》低
                {
                    ParameterData.PA1_Fre -= 80;
                    TIM2->ARR = ParameterData.PA1_Fre - 1;
                    if(ParameterData.PA1_Fre <= 4000)
                    {
                        ParameterData.PA1_Fre = 4000;
                    }
                    //改了频率,记得占空比也要改!!
                    TIM2->ARR = (1000000.0f / ParameterData.PA1_Fre) - 1;
                    TIM2->CCR2 = (ParameterData.Data_P / 100.0f) * (TIM2->ARR);
                }
            }
        }
		if((1 == PwmData.IC_OVER_FLAG) && (0 == MyData.Fre_5s_Flag))	//最大值(高低频切换期间的不算入)
		{
                if(1 == MyData.H_or_L_State)
				{
					if(ParameterData.Recd_ML < ParameterData.Data_V)	//当前速度最大值小于实时速度
					{
						Tim_2s_count++;
						if(Tim_2s_count >= 2000)
						{
							Tim_2s_count = 0;
							ParameterData.Recd_ML = ParameterData.Data_V;
							PwmData.IC_OVER_FLAG = 0;
						}
					}
					else
					{
						Tim_2s_count = 0;
						PwmData.IC_OVER_FLAG = 0;
					}
				}   
                else if(2 == MyData.H_or_L_State)
				{
					if(ParameterData.Recd_MH < ParameterData.Data_V)	//当前速度最大值小于实时速度
					{
						Tim_2s_count++;
						if(Tim_2s_count >= 2000)
						{
							Tim_2s_count = 0;
							ParameterData.Recd_MH = ParameterData.Data_V;
							PwmData.IC_OVER_FLAG = 0;
						}
					}
					else
					{
						Tim_2s_count = 0;
						PwmData.IC_OVER_FLAG = 0;
					}
				} 			
		}
    }
}

实验现象:https://www.bilibili.com/video/BV14a4y1T7pp/?spm_id_from=333.999.0.0&vd_source=5fb3f08926cbdbc6d84b3f2bda38c0b1

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mfbz.cn/a/9498.html

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

Learning C++ No.18【STL No.8】

引言&#xff1a; 北京时间&#xff1a;2023/3/18/21:47&#xff0c;周末&#xff0c;不摆烂&#xff0c;但是欠钱终于还是遭报应了&#xff0c;导致坐牢7小时&#xff08;上午3.5&#xff0c;下午3.5&#xff09;&#xff0c;难受&#xff0c;充分意识到行哥是那么的和蔼可亲…

固定资产管理方案:二维码扫扫便知道

用草料可以批量、简单、低成本地制作固定资产二维码标签。 适用于办公设备、车辆、医疗器械、大型生产设备等需要制作一物一码标签的场景。还能配合报修表单、手机端编辑子码功能共同使用&#xff0c;完成对于固定资产的规范化管理&#xff1a; 用二维码管理公司固定资产1、固定…

【Linux】进程等待进程程序替换

进程等待&进程程序替换进程等待进程程序替换通过进程等待和进程程序替换来理解守护进程进程等待 僵尸进程的产生原因是&#xff1a;子进程先于父进程退出&#xff0c;在子进程退出时会给父进程发送SIGCHILD信号&#xff0c;而父进程接收到这个信号后选择不处理&#xff0c;…

2023年MathorCup数学建模赛题浅析

MathorCup俗称妈杯&#xff0c;是除了美赛国赛外参赛人数首屈一指的比赛&#xff0c;而我们的妈杯今天也如期开赛。今年的妈杯难度&#xff0c;至少在我看来应该是2023年截至目前来讲最难的一场比赛。问题的设置、背景的选取等各个方面都吐露着我要难死你们的想法。难度是恒定的…

世纪末的星期

题目 1、世纪末的星期 曾有邪教称1999年12月31日是世界末日。当然该谣言已经不攻自破。 还有人称今后的某个世纪末的12月31日&#xff0c;如果是星期一则会… 有趣的是&#xff0c;任何一个世纪末的年份的12月31日都不可能是星期一!! 于是&#xff0c;“谣言制造商”又修改为星…

cuda ptx 汇编语言示例:读寄存器

编译 , Ampere 显卡&#xff0c;rtx 3060 3070... nvcc -archsm_86 -o hello hello_ptx.cu 或写成Makefile&#xff1a; hello: hello_sm_id.cunvcc -archsm_86 -o $ $^ #nvcc -archsm_86 -o hello hello_sm_id.cu $ 是指目标 $^ 是指第一个依赖 ^^ hello_ptx.cu #…

WinHex安装与使用

目录 下载WinHex 安装WinHex 查看现成的磁盘文件 手动创建磁盘文件 创建磁盘文件 创建分区 安装引导程序 查看磁盘 下载WinHex 下载链接&#xff1a; WinHex: Hex Editor & Disk Editor, Computer Forensics & Data Recovery Software 安装WinHex 1).下载完…

商贸批发进销存管理软件,仓库条码管理,库存管理。采购入库单,供应商档案管理。

公司发生采购业务&#xff0c;就需要对【供应商】档案进行管理。【供应商】档案包括&#xff1a;编号&#xff0c;名称&#xff0c;地址&#xff0c;电话&#xff0c;负责人&#xff0c;等信息。建立好【供应商】档案电脑存档&#xff0c;方便随时查阅&#xff0c;和统计分析。…

MySQL:安装 MySQL、Navicat、使用 Navicat 连接 MySQL

文章目录Day 01&#xff1a;一、概念1. 数据库 DB2. 数据库管理系统 DBMS3. MySQL二、安装 MySQL三、安装 Navicat Premium 16四、使用 Navicat 连接 MySQL注意&#xff1a;Day 01&#xff1a; 一、概念 1. 数据库 DB 数据库&#xff1a;DB (Database) 数据仓库&#xff0c;…

重磅!阿里版本【ChatGPT】开放测评!

前两天突然爆出惊人消息&#xff1a;阿里版ChatGPT开放测评了&#xff01; 在本月初&#xff0c;已经有诸多关于阿里巴巴即将推出类似ChatGPT产品的传闻。 数日前&#xff0c;首批曝光的天猫精灵“鸟鸟分鸟”脱口秀版GPT基于大型模型的“精简版”&#xff0c;凭借其出色的表现吸…

快看这些wireshark 命令,必须得会!

wireshark捕获命令 捕获器表达式语法&#xff1a; 限定词三类 Type&#xff1a;host、net、prot 指出其后数字或名字的意义&#xff08;主机&#xff0c;网段&#xff0c;端口&#xff09; Direction&#xff1a;src、dst 指出传输方向 &#xff08;源 、目的&#xff09; …

最全Linux环境开发——shell编程

Linux下shell编程 一、什么是shell shell是一个用 C 语言编写的程序&#xff0c;它是用户使用 Linux 的桥梁。Shell 既是一种命令语言&#xff0c;又是一种程序设计语言。 shell 本质上是 linux 命令&#xff0c;一条一条命令组合在一起&#xff0c;实现某一个目的&#xff…

Golang每日一练(leetDay0033) 二叉树专题(2)

目录 97. 交错字符串 Interleaving String &#x1f31f;&#x1f31f; 98. 验证二叉搜索树 Validate Binary Search Tree &#x1f31f;&#x1f31f; 99. 恢复二叉搜索树 Recover Binary Search Tree &#x1f31f;&#x1f31f; &#x1f31f; 每日一练刷题专栏 &am…

DFIG控制6-c:数字控制延时的分析和补偿

DFIG控制6-c&#xff1a;数字控制延时的分析和补偿 本文基于教程的第6部分。 DFIM Tutorial 6 - Dynamic Analysis of Current Loops in a Wind Turbine based on DFIG 教程提到了这本书&#xff1a; S.-K. Sul, Control of Electric Machine Drive Systems. John Wiley &…

好用的待办事项APP有哪些

你是否有这样的感受&#xff0c;这就是随着生活和工作节奏的加快&#xff0c;自己经常会面临各种各样的待办事项需要去完成&#xff0c;例如会议安排、每天的工作计划、学习任务等等。但是我们的大脑记忆是有限的&#xff0c;难免会出现忘记待办事项的情况&#xff0c;为了更好…

外包干了三年,算是废了...

先说一下自己的情况。大专生&#xff0c;19年通过校招进入湖南某软件公司&#xff0c;干了接近3年的测试&#xff0c;今年年上旬&#xff0c;感觉自己不能够在这样下去了&#xff0c;长时间呆在一个舒适的环境会让一个人堕落&#xff01;而我已经在一个企业干了三年&#xff0c…

detr训练自己的数据集

参考链接&#xff1a; https://zhuanlan.zhihu.com/p/490042821?utm_id0 transform结构&#xff1a; 原理&#xff1a;https://blog.csdn.net/weixin_44649780/article/details/126808881?spm1001.2014.3001.5501 图2&#xff1a; DETR使用一个传统的CNN主干来学习一个输入…

Densely Connected Pyramid Dehazing Network

Abstract 提出了一种新的端到端的单幅图像去雾方法&#xff0c;称为稠密连接金字塔去雾网络&#xff08;DCPDN&#xff09;&#xff0c;该方法可以联合学习透射图、大气光照和去雾。通过将大气散射模型直接嵌入到网络中&#xff0c;实现了端到端的学习&#xff0c;从而保证了所…

【使用教程】CANopen一体化伺服电机在汇川H5U PLC上的应用(上)

本文内容主要介绍了立迈胜一体化低压伺服CANopen通信的电机在汇川H5UPLC上的使用&#xff0c;本篇主要讲解环境的搭建以及软件自带的调试功能使电机运动起来。 一、系统构成 本系统主要构成是笔记本电脑、汇川PLC(H5U-1614MTD-A8)、PMM60系列一体化伺服电机(PMM6040B-CANopen)…

Maxon One 春季版本更新动态

2023年3月29日&#xff0c;Maxon&#xff0c;为剪辑师、电影制作人、动态设计师、视觉特效艺术家和各类创作者提供专业软件解决方案的开发商&#xff0c;今天宣布对Maxon One进行全面更新。 Maxon的2023年春季版本在整个产品系列中提供了令人振奋的新功能和工作流程改进&#x…
最新文章