速成记录-蓝桥杯嵌入式

深夜一小时速成。

出BUG了一定不要着急，从初始化配置开始检查，仔细Debug

串口字符串处理

复制字符串

// 从存储区 str2 复制 n 个字节到存储区 str1
void *memcpy(void *str1, const void *str2, size_t n)
// 
void *memmove(void *str1, const void *str2, size_t n) 
char *strcpy(char *dest, const char *src)
// 把 src 所指向的字符串复制到 dest，最多复制 n 个字符。当 src 的长度小于 n 时，dest 的剩余部分将用空字节填充。
char *strncpy(char *dest, const char *src, size_t n)

字符串拼接

char *strcat(char *dest, const char *src)
char *strncat(char *dest, const char *src, size_t n)

清空字符串/缓冲区

// 复制字符 c（一个无符号字符）到参数 str 所指向的字符串的前 n 个字符。
void *memset(void *str, int c, size_t n)

字符串比较

// 把 str1 所指向的字符串和 str2 所指向的字符串进行比较。
int strcmp(const char *str1, const char *str2)

字符串分解

// 分解字符串 str 为一组字符串，delim 为分隔符。
char *strtok(char *str, const char *delim)
// 从字符串读取格式化输入。   
int sscanf(const char *str, const char *format, ...)

提取子串

// 裁剪字符串
void Cut_String(uint8_t * destination_str,uint8_t * source_str,uint8_t location,uint8_t length)
{
    for(int i = 0; i < length; i++)
    {
        destination_str[i] = source_str[location + i];
    }
    destination_str[length] = '\0';
}

// 字符串逻辑检查 0：没问题 1：逻辑问题 2：接收问题 
uint8_t Rx_Check(uint8_t * str)
{
    
}

串口

串口DMA发送一批数据

HAL_UART_Transmit_DMA(&huart1,Tx_Buff,strlen((char *)Tx_Buff));

串口IDLE+DMA接收

// 使能串口IDLE中断
__HAL_UART_ENABLE_IT(&huart1,UART_IT_IDLE);
// 串口DMA接收一批数据
HAL_UART_Receive_DMA(&huart1, Rx_Buff, 255);

/**
  * @brief This function handles DMA1 channel5 global interrupt.
  */
void DMA1_Channel5_IRQHandler(void)
{
  /* USER CODE BEGIN DMA1_Channel5_IRQn 0 */

  /* USER CODE END DMA1_Channel5_IRQn 0 */
  HAL_DMA_IRQHandler(&hdma_usart1_rx);
  /* USER CODE BEGIN DMA1_Channel5_IRQn 1 */

  /* USER CODE END DMA1_Channel5_IRQn 1 */
}

/**
  * @brief This function handles USART1 global interrupt.
  */
void USART1_IRQHandler(void)
{
  /* USER CODE BEGIN USART1_IRQn 0 */
    // 获取中断标志
	if(__HAL_UART_GET_FLAG(&huart1,UART_FLAG_IDLE)!= RESET) 
    {
        __HAL_UART_CLEAR_IDLEFLAG(&huart1); //  清除标志位
        HAL_UART_DMAStop(&huart1); 			//  停止DMA传输，防止
        Data_length=255-__HAL_DMA_GET_COUNTER(&hdma_usart1_rx); // 接收长度
        recv_end_flag = 1;	// 接受完成标志位置1
    }
  /* USER CODE END USART1_IRQn 0 */
  HAL_UART_IRQHandler(&huart1);
  /* USER CODE BEGIN USART1_IRQn 1 */

  /* USER CODE END USART1_IRQn 1 */
}

PWM 输出

// 定时器PWM信号输出
HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_1);
// 设置周期
__HAL_TIM_SET_AUTORELOAD(&htim3,2000-1);
// 设置通道比较值
__HAL_TIM_SET_COMPARE(&htim3,1000);

PWM 输入捕获

float Period_2;
float D_period_2;
float freq_2;
float duty_2;

// 开启定时器捕获中断模式
HAL_TIM_IC_Start_IT(&htim2, TIM_CHANNEL_1);
HAL_TIM_IC_Start_IT(&htim2, TIM_CHANNEL_2);

// 输入捕获中断服务函数
void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim)
{
    if(htim->Instance==TIM2)
    {
        if(htim->Channel==HAL_TIM_ACTIVE_CHANNEL_1)
        {
            Period_1=HAL_TIM_ReadCapturedValue(htim,TIM_CHANNEL_1)+1;
            D_period_1=HAL_TIM_ReadCapturedValue(htim,TIM_CHANNEL_2)+1;
            freq_1=1000000/Period_1;
            // 必须加float
            duty_1=D_period_1/Period_1 * 100;
        }
    }
    
    if(htim->Instance==TIM3)
    {
        if(htim->Channel==HAL_TIM_ACTIVE_CHANNEL_1)
        {
            Period_2=HAL_TIM_ReadCapturedValue(htim,TIM_CHANNEL_1)+1;
            D_period_2=HAL_TIM_ReadCapturedValue(htim,TIM_CHANNEL_2)+1;
            freq_2=1000000/Period_2;
            // 必须加float
            duty_2=D_period_2/Period_2 * 100;
        }
    }
}

ADC

uint16_t Get_ADC1(void)
{
    uint16_t temp;
    HAL_ADC_Start(&hadc1);
    temp=HAL_ADC_GetValue(&hadc1);
    return temp;
}

DAC

void DAC_Out(float Out_value)
{
    uint32_t temp;
    temp=4096*Out_value/3.3f;
    HAL_DAC_SetValue(&hdac1, DAC_CHANNEL_1, DAC_ALIGN_12B_R, temp);
    HAL_DAC_Start(&hdac1,DAC_CHANNEL_1);
}

eeprom

void eeprom_write(unsigned char *pucBuf, unsigned char ucAddr, unsigned char Size)
{
    I2CStart();
    I2CSendByte(0xa0); // д��ַ
    I2CWaitAck();
  
    I2CSendByte(ucAddr); //
    I2CWaitAck();
  
    while(Size--)
    {
          I2CSendByte(*pucBuf++); // ???+??
          I2CWaitAck();
    }

    I2CStop();
    delay1(500);
}

void eeprom_read(unsigned char *pucBuf, unsigned char ucAddr, unsigned char Size)
{
    I2CStart();
    I2CSendByte(0xa0); // ����ַ
    I2CWaitAck();
  
    I2CSendByte(ucAddr); //
    I2CWaitAck();
  
    I2CStart();
    I2CSendByte(0xa1); // ����ַ
    I2CWaitAck();
    while(Size--)
    {
        *pucBuf=I2CReceiveByte(); // ???+??
        pucBuf++;
        if(Size)
          I2CSendAck();
        else
          I2CSendNotAck();
    }
    I2CStop();
}

mcp4017

void mcp4017_write(uint8_t  res_val)
{
    I2CStart();
    I2CSendByte(0x5E);
    I2CWaitAck();

    I2CSendByte(res_val); //
    I2CWaitAck();
    I2CStop();
}


uint8_t  mcp4017_read(void)
{
    uint8_t res_N;
    I2CStart();
    I2CSendByte(0x5f);
    I2CWaitAck();

    res_N=I2CReceiveByte(); //
    I2CSendNotAck();
    I2CStop();

    return res_N;
}

RTC

//RTC相关变量
RTC_TimeTypeDef H_M_S_Time;
RTC_DateTypeDef Y_M_D_Date;
uint8_t Second;

//函数调用
HAL_RTC_GetTime(&hrtc, &H_M_S_Time, RTC_FORMAT_BIN);//读取日期和时间必须同时使用
HAL_RTC_GetDate(&hrtc, &Y_M_D_Date, RTC_FORMAT_BIN);

LCD