YuanHongbin/hc32f460_boot
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

初始版本

Browse Source
This commit is contained in:
YuanHongbin
2026-04-23 13:49:53 +08:00
parent c1d6ebd38c
commit ac718a463a
257 changed files with 265681 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
hdl/hdl_clk.c
+132
View File
@@ -0,0 +1,132 @@
#include "hdl_clk.h"
/********************************************************************************************************
* @函数名 hdl_xtal_init
* @描述 外部晶振初始化
* @参数 无
* @返回值 无
* @注意 无
********************************************************************************************************/
#if USING_XTAL
static void hdl_xtal_init(void)
{
stc_clock_xtal_init_t stcXtalInit;
/* XTAL 引脚配置 */
GPIO_AnalogCmd(GPIO_PORT_H, GPIO_PIN_00 | GPIO_PIN_01, ENABLE);
(void)CLK_XtalStructInit(&stcXtalInit);
/* 配置XTAL和启用XTAL */
stcXtalInit.u8State = CLK_XTAL_ON;
stcXtalInit.u8Mode = CLK_XTAL_MD_OSC;
stcXtalInit.u8Drv = CLK_XTAL_DRV_ULOW;
stcXtalInit.u8StableTime = CLK_XTAL_STB_2MS;
(void)CLK_XtalInit(&stcXtalInit);
}
#endif
/********************************************************************************************************
* @函数名 hdl_pll_init
* @描述 锁相环倍频初始化
* @参数 无
* @返回值 无
* @注意 无
********************************************************************************************************/
static void hdl_pll_init(void)
{
stc_clock_pll_init_t stcMPLLInit;
(void)CLK_PLLStructInit(&stcMPLLInit);
/* MPLL 配置 */
/* 16MHz/M*N = 16/2*50/2 = 200MHz */
stcMPLLInit.PLLCFGR = 0UL;
stcMPLLInit.PLLCFGR_f.PLLM = (2UL - 1UL);
stcMPLLInit.PLLCFGR_f.PLLN = (50UL - 1UL);
stcMPLLInit.PLLCFGR_f.PLLP = (2UL - 1UL);
stcMPLLInit.PLLCFGR_f.PLLQ = (2UL - 1UL);
stcMPLLInit.PLLCFGR_f.PLLR = (2UL - 1UL);
stcMPLLInit.u8PLLState = CLK_PLL_ON;
stcMPLLInit.PLLCFGR_f.PLLSRC = CLK_PLL_SRC_HRC; /* HRC = 16MHz */
(void)CLK_PLLInit(&stcMPLLInit);
}
/********************************************************************************************************
* @函数名 hdl_clk_init
* @描述 时钟初始化
* @参数 无
* @返回值 无
* @注意 无
********************************************************************************************************/
void hdl_clk_init(void)
{
/* 解除写保护 */
LL_PERIPH_WE(LL_PERIPH_EFM | LL_PERIPH_FCG | LL_PERIPH_GPIO | LL_PERIPH_PWC_CLK_RMU | LL_PERIPH_SRAM);
/* 设置时钟分频 */
CLK_SetClockDiv(CLK_BUS_CLK_ALL, (CLK_HCLK_DIV1 | CLK_EXCLK_DIV2 | CLK_PCLK0_DIV1 | CLK_PCLK1_DIV2 | \
CLK_PCLK2_DIV4 | CLK_PCLK3_DIV4 | CLK_PCLK4_DIV2));
/* SRAM初始化包括读/写等待周期设置 */
SRAM_SetWaitCycle(SRAM_SRAM_ALL, SRAM_WAIT_CYCLE1, SRAM_WAIT_CYCLE1);
SRAM_SetWaitCycle(SRAM_SRAMH, SRAM_WAIT_CYCLE0, SRAM_WAIT_CYCLE0);
/* 闪存读取等待周期设置 */
EFM_SetWaitCycle(EFM_WAIT_CYCLE5);
/* XTAL 初始化 */
// hdl_xtal_init();
/* XTAL32 初始化 */
/* MPLL 初始化 */
hdl_pll_init();
/* enable LRC */
/* enable HRC */
/* 3 cycles for 126MHz ~ 200MHz */
GPIO_SetReadWaitCycle(GPIO_RD_WAIT3);
/* 切换驱动能力 */
PWC_HighSpeedToHighPerformance();
EFM_DataCacheResetCmd(ENABLE);
EFM_DataCacheResetCmd(DISABLE);
/* Enable cache */
EFM_CacheCmd(ENABLE);
/* 使能写保护 */
LL_PERIPH_WP(LL_PERIPH_EFM | LL_PERIPH_GPIO | LL_PERIPH_SRAM);
/* 设置系统时钟源 */
CLK_SetSysClockSrc(CLK_SYSCLK_SRC_PLL);
/* 使能systick */
(void)SysTick_Init(1000U);
}
void hdl_delay_us(uint16_t us)
{
for(int i=0;i<us;i++)
{
for(int j=0;j<35;j++)
{
__NOP();
}
}
}
void hdl_delay_ms(uint16_t ms)
{
for(int i=0;i<ms;i++)
{
for(int j=0;j<13000;j++)
{
__NOP();
}
}
}
hdl/hdl_clk.h
+11
View File
@@ -0,0 +1,11 @@
#ifndef ____HDL_CLK_H_
#define ____HDL_CLK_H_
#include "hc32_ll.h"
#define USING_XTAL (0)
void hdl_clk_init(void);
void hdl_delay_us(uint16_t us);
void hdl_delay_ms(uint16_t ms);
#endif
hdl/hdl_cs5552.c
+267
View File
@@ -0,0 +1,267 @@
#include "hdl_cs5552.h"
static stc_cs5552_t cs5552;
//uint32_t hdl_cs5552_reg_read(uint8_t cmd)
//{
// uint32_t data = 0;
// uint8_t buf[4] = {0};
//
// CLR_CS5552_CS();
//
// hdl_cs5552_write_read_byte(cmd);
//
// for(int i=0;i<4;i++)
// {
// buf[i] = hdl_cs5552_write_read_byte(0x00);
// }
//
// SET_CS5552_CS();
//
// data = (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | (buf[3]);
//
// return data;
//}
void hdl_cs5552_soft_spi_init(void)
{
stc_gpio_init_t stcGpioInit;
LL_PERIPH_WE(LL_PERIPH_GPIO);
(void)GPIO_StructInit(&stcGpioInit);
stcGpioInit.u16PinDir = PIN_DIR_OUT;
stcGpioInit.u16PinDrv = PIN_HIGH_DRV;
(void)GPIO_Init(CS5552_MOSI_PORT, CS5552_MOSI_PIN, &stcGpioInit);
(void)GPIO_Init(CS5552_SCLK_PORT, CS5552_SCLK_PIN, &stcGpioInit);
(void)GPIO_Init(CS5552_CS_PORT, CS5552_CS_PIN, &stcGpioInit);
(void)GPIO_StructInit(&stcGpioInit);
stcGpioInit.u16PinDir = PIN_DIR_IN;
stcGpioInit.u16PullUp = PIN_PU_ON;
(void)GPIO_Init(CS5552_MISO_PORT, CS5552_MISO_PIN, &stcGpioInit);
LL_PERIPH_WP(LL_PERIPH_GPIO);
CLR_CS5552_SCLK();
}
uint8_t hdl_cs5552_write_read_byte(uint8_t w_data)
{
uint8_t r_data = 0;
uint16_t retry = 0;
for(int i=0;i<8;i++)
{
if((w_data&0x80) == 0)
{
CLR_CS5552_DIN();
}else{
SET_CS5552_DIN();
}
hdl_delay_us(1);
SET_CS5552_SCLK();
r_data<<=1;
if(SET == GET_CS5552_DOUT())
{
r_data++;
}
CLR_CS5552_SCLK();
w_data<<=1;
hdl_delay_us(1);
}
return r_data;
}
void hdl_cs5552_reg_write(uint8_t cmd, uint8_t dat_h, uint8_t dat_m, uint8_t dat_l, uint8_t dat_s)
{
CLR_CS5552_CS();
hdl_cs5552_write_read_byte(cmd);
hdl_cs5552_write_read_byte(dat_h);
hdl_cs5552_write_read_byte(dat_m);
hdl_cs5552_write_read_byte(dat_l);
hdl_cs5552_write_read_byte(dat_s);
SET_CS5552_CS();
}
uint32_t hdl_cs5552_reg_read(uint8_t cmd)
{
uint32_t data = 0;
uint8_t buf[4] = {0};
CLR_CS5552_CS();
hdl_cs5552_write_read_byte(cmd);
for(int i=0;i<4;i++)
{
buf[i] = hdl_cs5552_write_read_byte(0x00);
}
SET_CS5552_CS();
data = (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | (buf[3]);
return data;
}
void hdl_cs5552_value_get(int32_t *buf)
{
memcpy(buf, cs5552.buf, sizeof(cs5552.buf));
}
void hdl_cs5552_init(void)
{
uint32_t data = 0;
hdl_cs5552_soft_spi_init();
SET_CS5552_CS();
/* 配置CS5552 */
CLR_CS5552_CS();
hdl_cs5552_write_read_byte(0x00);
hdl_cs5552_write_read_byte(0xA5);
hdl_cs5552_write_read_byte(0xFF);
hdl_cs5552_write_read_byte(0x5A);
SET_CS5552_CS();
hdl_delay_us(100);
hdl_cs5552_reg_write(SYS_CONF0_W, 0x80, 0x00, 0x00, 0x00); //RESET
hdl_delay_us(100);
hdl_cs5552_reg_write(OS_CH0_W, 0x00, 0x00, 0x00, 0x00); //OS_CH0
hdl_cs5552_reg_write(GAIN_CH0_W, 0x02, 0x00, 0x00, 0x00); //GAIN_CH0
hdl_cs5552_reg_write(OS_CH1_W, 0x00, 0x00, 0x00, 0x00); //OS_CH1
hdl_cs5552_reg_write(GAIN_CH1_W, 0x02, 0x00, 0x00, 0x00); //GAIN_CH1
hdl_cs5552_reg_write(CONV_CONF0_W, 0x30, 0x80, 0x00, 0x80); //CONV_CONF0 滤波-256CLK 速率-200Hz PGA-128
hdl_cs5552_reg_write(CONV_CONF1_W, 0x00, 0x00, 0x00, 0x00); //CONV_CONF1
hdl_cs5552_reg_write(SYS_CONF0_W, 0x02, 0x01, 0x00, 0x00); //SYS_CONF0
hdl_cs5552_reg_write(SYS_CONF1_W, 0x08, 0x11, 0x02, 0x10); //SYS_CONF1 内部时钟 内部基准源
hdl_cs5552_reg_write(SYS_CONF2_W, 0x00, 0x52, 0x10, 0x00); //SYS_CONF2
#ifdef HC32_DEBUG
/* 读取通道0设置 */
data = hdl_cs5552_reg_read(OS_CH0_R);
printf("OS_CH0 = %d\r\n", data);
data = hdl_cs5552_reg_read(GAIN_CH0_R);
printf("GAIN_CH0 = %d\r\n", data);
/* 读取通道1设置 */
data = hdl_cs5552_reg_read(OS_CH1_R);
printf("OS_CH1 = %d\r\n", data);
data = hdl_cs5552_reg_read(GAIN_CH1_R);
printf("GAIN_CH1 = %d\r\n", data);
/* 配置CONV */
data = hdl_cs5552_reg_read(CONV_CONF0_R);
printf("CONV_CONF0 = %d\r\n", data);
data = hdl_cs5552_reg_read(CONV_CONF1_R);
printf("CONV_CONF1 = %d\r\n", data);
/* 配置SYS */
data = hdl_cs5552_reg_read(SYS_CONF0_R);
printf("SYS_CONF0 = %d\r\n", data);
data = hdl_cs5552_reg_read(SYS_CONF1_R);
printf("SYS_CONF1 = %d\r\n", data);
data = hdl_cs5552_reg_read(SYS_CONF2_R);
printf("SYS_CONF2 = %d\r\n", data);
#endif
}
void hdl_cs5552_conv_start(void)
{
cs5552.step = CS5552_OFFSET;
}
void hdl_cs5552_proc(void)
{
static uint16_t offset_cnt = 0;
uint32_t ad_value = 0;
switch(cs5552.step)
{
case CS5552_IDLE:
break;
case CS5552_OFFSET:
CLR_CS5552_CS();
if(cs5552.channel_sta == CS5552_CH0)
hdl_cs5552_write_read_byte(SYS_OFFSET_CH0);
if(cs5552.channel_sta == CS5552_CH1)
hdl_cs5552_write_read_byte(SYS_OFFSET_CH1);
cs5552.step = CS5552_OFFSET_READ;
if(offset_cnt > OFFSET_CNT)
{
offset_cnt = 0;
cs5552.step = CS5552_START;
}
break;
case CS5552_OFFSET_READ:
if(RESET == GET_CS5552_DOUT())
{
ad_value = hdl_cs5552_reg_read(0xFF); //获取数据
if((ad_value & 0x1) == 0)
{
cs5552.offset_ch0[offset_cnt] = (ad_value & 0xFFFFFFFE) | 0x0;
}
if((ad_value & 0x1) == 1)
{
cs5552.offset_ch1[offset_cnt] = (ad_value & 0xFFFFFFFE) | 0x0;
}
offset_cnt++;
cs5552.channel_sta = 1-cs5552.channel_sta; //切换通道
cs5552.step = CS5552_OFFSET;
}
break;
case CS5552_START:
CLR_CS5552_CS();
if(cs5552.channel_sta == CS5552_CH0)
hdl_cs5552_write_read_byte(CONV_CH0);
if(cs5552.channel_sta == CS5552_CH1)
hdl_cs5552_write_read_byte(0x90);
cs5552.step = CS5552_READ;
break;
case CS5552_READ:
if(RESET == GET_CS5552_DOUT())
{
ad_value = hdl_cs5552_reg_read(0xFF); //获取数据
if((ad_value & 0x1) == 0)
{
if((ad_value>>22) < 0x3F) //+
cs5552.buf[0] = (ad_value & 0x3FFFFFFE) >> 13;
if((ad_value>>22) > 0xC0) //-
cs5552.buf[0] = ~(0x7FFFF - ((ad_value & 0xFFFFFFFE) >> 13));
}
if((ad_value & 0x1) == 1)
{
if((ad_value>>22) < 0x3F) //+
cs5552.buf[1] = (ad_value & 0x3FFFFFFE) >> 13;
if((ad_value>>22) > 0xC0) //-
cs5552.buf[1] = ~(0x7FFFF - ((ad_value & 0xFFFFFFFE) >> 13));
}
cs5552.channel_sta = 1-cs5552.channel_sta; //切换通道
cs5552.step = CS5552_START;
}
break;
}
}
hdl/hdl_cs5552.h
+110
View File
@@ -0,0 +1,110 @@
#ifndef ____HDL_CS5552_H_
#define ____HDL_CS5552_H_
#include "hc32_ll.h"
#include "hdl_clk.h"
#define CS5552_SPI CM_SPI1
#define CS5552_SPI_CLK FCG1_PERIPH_SPI1
#define CS5552_CS_PORT GPIO_PORT_A
#define CS5552_CS_PIN GPIO_PIN_04
#define CS5552_CS_FUNC GPIO_FUNC_42
#define CS5552_SCLK_PORT GPIO_PORT_A
#define CS5552_SCLK_PIN GPIO_PIN_07
#define CS5552_SCLK_FUNC GPIO_FUNC_43
#define CS5552_MISO_PORT GPIO_PORT_A
#define CS5552_MISO_PIN GPIO_PIN_06
#define CS5552_MISO_FUNC GPIO_FUNC_41
#define CS5552_MOSI_PORT GPIO_PORT_A
#define CS5552_MOSI_PIN GPIO_PIN_05
#define CS5552_MOSI_FUNC GPIO_FUNC_40
#define SET_CS5552_CS() GPIO_SetPins(CS5552_CS_PORT, CS5552_CS_PIN)
#define CLR_CS5552_CS() GPIO_ResetPins(CS5552_CS_PORT, CS5552_CS_PIN)
#define SET_CS5552_DOUT() GPIO_SetPins(CS5552_MISO_PORT, CS5552_MISO_PIN)
#define CLR_CS5552_DOUT() GPIO_ResetPins(CS5552_MISO_PORT, CS5552_MISO_PIN)
#define GET_CS5552_DOUT() GPIO_ReadInputPins(CS5552_MISO_PORT, CS5552_MISO_PIN)
#define SET_CS5552_DIN() GPIO_SetPins(CS5552_MOSI_PORT, CS5552_MOSI_PIN)
#define CLR_CS5552_DIN() GPIO_ResetPins(CS5552_MOSI_PORT, CS5552_MOSI_PIN)
#define SET_CS5552_SCLK() GPIO_SetPins(CS5552_SCLK_PORT, CS5552_SCLK_PIN)
#define CLR_CS5552_SCLK() GPIO_ResetPins(CS5552_SCLK_PORT, CS5552_SCLK_PIN)
#define OS_CH0_R 0x05
#define OS_CH0_W 0x00
#define GAIN_CH0_R 0x0C
#define GAIN_CH0_W 0x09
#define OS_CH1_R 0x14
#define OS_CH1_W 0x11
#define GAIN_CH1_R 0x1D
#define GAIN_CH1_W 0x18
#define CONV_CONF0_R 0x24
#define CONV_CONF0_W 0x21
#define CONV_CONF1_R 0x2D
#define CONV_CONF1_W 0x28
#define SYS_CONF0_R 0x35
#define SYS_CONF0_W 0x30
#define SYS_CONF1_R 0x3C
#define SYS_CONF1_W 0x39
#define SYS_CONF2_R 0x44
#define SYS_CONF2_W 0x41
#define CONV_DATA_R 0x55
#define CONV_CH0 0x81
#define CONV_CH1 0x90
#define SELF_OFFSET_CH0 0x84
#define SELF_OFFSET_CH1 0x95
#define SYS_OFFSET_CH0 0x8B
#define SYS_OFFSET_CH1 0x9A
#define OFFSET_CNT 9
typedef enum
{
CS5552_IDLE,
CS5552_OFFSET,
CS5552_OFFSET_READ,
CS5552_START,
CS5552_READ
}en_cs5552_step;
typedef enum
{
CS5552_CH0,
CS5552_CH1,
}en_cs5552_ch;
typedef struct
{
en_cs5552_step step; //流程
en_cs5552_ch channel_sta; //当前转换通道
int32_t buf[2]; //通道数据
uint32_t offset_ch0[OFFSET_CNT]; //通道0校准值
uint32_t offset_ch1[OFFSET_CNT]; //通道1校准值
}stc_cs5552_t;
void hdl_cs5552_init(void);
uint32_t hdl_cs5552_reg_read(uint8_t cmd);
void hdl_cs5552_value_get(int32_t *buf);
void hdl_cs5552_conv_start(void);
void hdl_cs5552_proc(void);
#endif
hdl/hdl_encoder.c
+88
View File
@@ -0,0 +1,88 @@
#include "hdl_encoder.h"
static volatile uint8_t a_level = 0;
static volatile int16_t encoder_cnt = 0;
static void hdl_encoder_a_callback(void)
{
if (SET == EXTINT_GetExtIntStatus(ENCODER_A_EX_CH)) {
if(RESET == ENCODER_A_GET)
{
a_level = 0;
if(SET == ENCODER_B_GET)
a_level = 1;
}
if(SET == ENCODER_A_GET)
{
if((a_level == 1) && (RESET == ENCODER_B_GET))
{
encoder_cnt++;
}
if((a_level == 0) && (SET == ENCODER_B_GET))
{
encoder_cnt--;
}
}
EXTINT_ClearExtIntStatus(ENCODER_A_EX_CH);
}
}
static void hdl_encoder_b_callback(void)
{
if (SET == EXTINT_GetExtIntStatus(ENCODER_B_EX_CH)) {
// while (PIN_RESET == GPIO_ReadInputPins(KEY10_PORT, KEY10_PIN)) {
// ;
// }
EXTINT_ClearExtIntStatus(ENCODER_B_EX_CH);
}
}
void hdl_encoder_init(void)
{
stc_gpio_init_t stcGpioInit;
stc_extint_init_t stcExtIntInit;
stc_irq_signin_config_t stcIrqSignConfig;
LL_PERIPH_WE(LL_PERIPH_GPIO);
/* 配置引脚 */
(void)GPIO_StructInit(&stcGpioInit);
stcGpioInit.u16PullUp = PIN_PU_ON; //上拉输入
stcGpioInit.u16ExtInt = PIN_EXTINT_ON; //外部中断
(void)GPIO_Init(ENCODER_SW_PORT, ENCODER_SW_PIN, &stcGpioInit);
(void)GPIO_Init(ENCODER_A_PORT, ENCODER_A_PIN, &stcGpioInit);
(void)GPIO_Init(ENCODER_B_PORT, ENCODER_B_PIN, &stcGpioInit);
/* 配置中断 */
(void)EXTINT_StructInit(&stcExtIntInit);
stcExtIntInit.u32Filter = EXTINT_FILTER_ON;
stcExtIntInit.u32FilterClock = EXTINT_FCLK_DIV8;
stcExtIntInit.u32Edge = EXTINT_TRIG_BOTH; //双边沿中断
(void)EXTINT_Init(ENCODER_A_EX_CH, &stcExtIntInit);
(void)EXTINT_Init(ENCODER_B_EX_CH, &stcExtIntInit);
/* 配置中断源 */
stcIrqSignConfig.enIntSrc = ENCODER_A_INT_SRC;
stcIrqSignConfig.enIRQn = ENCODER_A_INT_IRQn;
stcIrqSignConfig.pfnCallback = &hdl_encoder_a_callback;
(void)INTC_IrqSignIn(&stcIrqSignConfig);
NVIC_ClearPendingIRQ(stcIrqSignConfig.enIRQn);
NVIC_SetPriority(stcIrqSignConfig.enIRQn, DDL_IRQ_PRIO_DEFAULT);
NVIC_EnableIRQ(stcIrqSignConfig.enIRQn);
stcIrqSignConfig.enIntSrc = ENCODER_B_INT_SRC;
stcIrqSignConfig.enIRQn = ENCODER_B_INT_IRQn;
stcIrqSignConfig.pfnCallback = &hdl_encoder_b_callback;
(void)INTC_IrqSignIn(&stcIrqSignConfig);
NVIC_ClearPendingIRQ(stcIrqSignConfig.enIRQn);
NVIC_SetPriority(stcIrqSignConfig.enIRQn, DDL_IRQ_PRIO_DEFAULT);
NVIC_EnableIRQ(stcIrqSignConfig.enIRQn);
}
int16_t hdl_encoder_cnt_get(void)
{
return encoder_cnt;
}
hdl/hdl_encoder.h
+30
View File
@@ -0,0 +1,30 @@
#ifndef ____HDL_ENCODER_H_
#define ____HDL_ENCODER_H_
#include "hc32_ll.h"
#define ENCODER_A_PORT GPIO_PORT_H
#define ENCODER_A_PIN GPIO_PIN_02
#define ENCODER_A_EX_CH EXTINT_CH02
#define ENCODER_A_INT_SRC INT_SRC_PORT_EIRQ2
#define ENCODER_A_INT_IRQn INT033_IRQn
#define ENCODER_A_GET GPIO_ReadInputPins(ENCODER_A_PORT, ENCODER_A_PIN)
#define ENCODER_B_PORT GPIO_PORT_C
#define ENCODER_B_PIN GPIO_PIN_13
#define ENCODER_B_EX_CH EXTINT_CH13
#define ENCODER_B_INT_SRC INT_SRC_PORT_EIRQ13
#define ENCODER_B_INT_IRQn INT034_IRQn
#define ENCODER_B_GET GPIO_ReadInputPins(ENCODER_B_PORT, ENCODER_B_PIN)
#define ENCODER_SW_PORT GPIO_PORT_C
#define ENCODER_SW_PIN GPIO_PIN_14
void hdl_encoder_init(void);
int16_t hdl_encoder_cnt_get(void);
#endif
hdl/hdl_flash.c
+203
View File
@@ -0,0 +1,203 @@
/**
*******************************************************************************
* @file iap/iap_ymodem_boot/source/flash.c
* @brief This file provides firmware functions to manage the Flash driver.
@verbatim
Change Logs:
Date Author Notes
2022-03-31 CDT First version
@endverbatim
*******************************************************************************
* Copyright (C) 2022-2023, Xiaohua Semiconductor Co., Ltd. All rights reserved.
*
* This software component is licensed by XHSC under BSD 3-Clause license
* (the "License"); You may not use this file except in compliance with the
* License. You may obtain a copy of the License at:
* opensource.org/licenses/BSD-3-Clause
*
*******************************************************************************
*/
/*******************************************************************************
* Include files
******************************************************************************/
#include "hdl_flash.h"
#include "hdl_clk.h"
/*******************************************************************************
* Local type definitions ('typedef')
******************************************************************************/
/*******************************************************************************
* Local pre-processor symbols/macros ('#define')
******************************************************************************/
/*******************************************************************************
* Global variable definitions (declared in header file with 'extern')
******************************************************************************/
/*******************************************************************************
* Local function prototypes ('static')
******************************************************************************/
/*******************************************************************************
* Local variable definitions ('static')
******************************************************************************/
/*******************************************************************************
* Function implementation - global ('extern') and local ('static')
******************************************************************************/
int32_t hdl_flash_unlock(void)
{
LL_PERIPH_WE(LL_PERIPH_EFM );
/* Wait flash ready. */
while (SET != EFM_GetStatus(EFM_FLAG_RDY)) {
;
}
//½âËøEFM
EFM_FWMC_Cmd(ENABLE);
EFM_CacheCmd(ENABLE);
return LL_OK;
}
int32_t hdl_flash_lock(void){
/* Peripheral registers write protected */
EFM_CacheCmd(DISABLE);
EFM_FWMC_Cmd(DISABLE);
LL_PERIPH_WP(LL_PERIPH_EFM );
return LL_OK;
}
/**
* @brief Check address alignment.
* @param u32Addr Flash address
* @retval An en_result_t enumeration value:
* - LL_OK: Address aligned
* - LL_ERR: Address unaligned
*/
int32_t hdl_flash_check_addralign(uint32_t u32Addr)
{
uint32_t u32Step = FLASH_SECTOR_SIZE;
if (VECT_TAB_STEP > FLASH_SECTOR_SIZE) {
u32Step = VECT_TAB_STEP;
}
if ((u32Addr % u32Step) != 0UL) {
return LL_ERR;
}
return LL_OK;
}
/**
* @brief Erase flash sector.
* @param u32Addr Flash address
* @param u32Size Firmware size (0: current address sector)
* @retval An en_result_t enumeration value:
* - LL_OK: Erase succeeded
* - LL_ERR: Erase timeout
* - LL_ERR_INVD_PARAM: The parameters is invalid.
*/
int32_t hdl_flash_erase_sector(uint32_t u32Addr, uint32_t u32Size)
{
uint32_t i;
uint32_t u32PageNum;
if (u32Addr >= (FLASH_BASE + FLASH_SIZE)) {
return LL_ERR_INVD_PARAM;
}
if (u32Size == 0U) {
return EFM_SectorErase(u32Addr);
} else {
u32PageNum = u32Size / FLASH_SECTOR_SIZE;
if ((u32Size % FLASH_SECTOR_SIZE) != 0UL) {
u32PageNum += 1U;
}
for (i = 0; i < u32PageNum; i++) {
if (LL_OK != EFM_SectorErase(u32Addr + (i * FLASH_SECTOR_SIZE))) {
return LL_ERR;
}
}
}
return LL_OK;
}
/**
* @brief Write data to flash.
* @param u32Addr Flash address
* @param pu8Buff Pointer to the buffer to be written
* @param u32Len Buffer length
* @retval int32_t:
* - LL_OK: Program successful.
* - LL_ERR_INVD_PARAM: The parameters is invalid.
* - LL_ERR_NOT_RDY: EFM if not ready.
* - LL_ERR_ADDR_ALIGN: Address alignment error
*/
int32_t hdl_flash_write_data(uint32_t u32Addr, uint8_t *pu8Buff, uint32_t u32Len)
{
if ((pu8Buff == NULL) || (u32Len == 0U) || ((u32Addr + u32Len) > (FLASH_BASE + FLASH_SIZE))) {
return LL_ERR_INVD_PARAM;
}
if (0UL != (u32Addr % 4U)) {
return LL_ERR_ADDR_ALIGN;
}
return EFM_Program(u32Addr, pu8Buff, u32Len);
}
/**
* @brief Read data from flash.
* @param u32Addr Flash address
* @param pu8Buff Pointer to the buffer to be reading
* @param u32Len Buffer length
* @retval int32_t:
* - LL_OK: Read data succeeded
* - LL_ERR_INVD_PARAM: The parameters is invalid
* - LL_ERR_ADDR_ALIGN: Address alignment error
*/
int32_t hdl_flash_read_data(uint32_t u32Addr, uint8_t *pu8Buff, uint32_t u32Len)
{
uint32_t i;
uint32_t u32WordLength, u8ByteRemain;
uint32_t *pu32ReadBuff;
__IO uint32_t *pu32FlashAddr;
uint8_t *pu8Byte;
__IO uint8_t *pu8FlashAddr;
if ((pu8Buff == NULL) || (u32Len == 0U) || ((u32Addr + u32Len) > (FLASH_BASE + FLASH_SIZE))) {
return LL_ERR_INVD_PARAM;
}
if (0UL != (u32Addr % 4U)) {
return LL_ERR_ADDR_ALIGN;
}
pu32ReadBuff = (uint32_t *)(uint32_t)pu8Buff;
pu32FlashAddr = (uint32_t *)u32Addr;
u32WordLength = u32Len / 4U;
u8ByteRemain = u32Len % 4U;
/* Read data */
for (i = 0UL; i < u32WordLength; i++) {
*(pu32ReadBuff++) = *(pu32FlashAddr++);
}
if (0UL != u8ByteRemain) {
pu8Byte = (uint8_t *)pu32ReadBuff;
pu8FlashAddr = (uint8_t *)pu32FlashAddr;
for (i = 0UL; i < u8ByteRemain; i++) {
*(pu8Byte++) = *(pu8FlashAddr++);
}
}
return LL_OK;
}
/******************************************************************************
* EOF (not truncated)
*****************************************************************************/
hdl/hdl_flash.h
+97
View File
@@ -0,0 +1,97 @@
/**
*******************************************************************************
* @file iap/iap_ymodem_boot/source/flash.h
* @brief This file contains all the functions prototypes of the Flash driver.
@verbatim
Change Logs:
Date Author Notes
2022-03-31 CDT First version
@endverbatim
*******************************************************************************
* Copyright (C) 2022-2025, Xiaohua Semiconductor Co., Ltd. All rights reserved.
*
* This software component is licensed by XHSC under BSD 3-Clause license
* (the "License"); You may not use this file except in compliance with the
* License. You may obtain a copy of the License at:
* opensource.org/licenses/BSD-3-Clause
*
*******************************************************************************
*/
#ifndef __HDL_FLASH_H__
#define __HDL_FLASH_H__
#include "stdint.h"
/* C binding of definitions if building with C++ compiler */
#ifdef __cplusplus
extern "C"
{
#endif
/*******************************************************************************
* Include files
******************************************************************************/
#include "hc32_ll_efm.h"
#include "hc32_ll_SWDT.h"
/*******************************************************************************
* Global type definitions ('typedef')
******************************************************************************/
/*******************************************************************************
* Global pre-processor symbols/macros ('#define')
******************************************************************************/
/* Flash definitions */
#define FLASH_BASE (EFM_START_ADDR)
#define FLASH_SIZE (EFM_END_ADDR + 1U)
#define FLASH_SECTOR_SIZE (EFM_SECTOR_SIZE)
#define FLASH_SECTOR_NUM (64U)
/* SRAM definitions */
#define SRAM_SIZE (0x02F000UL)
/* Vector table */
#define VECT_TAB_STEP (0x000UL)
/* flash rom map ´æ´¢·ÖÇø*/
//boot 16k
#define FLASH_BOOT_BASE (FLASH_BASE)
#define FLASH_BOOT_SIZE (4*FLASH_SECTOR_SIZE)
//app
#define FLASH_APP_BASE (FLASH_BOOT_BASE+ FLASH_BOOT_SIZE)
#define FLASH_APP_SIZE (58*FLASH_SECTOR_SIZE)
//boot info
#define FLASH_BINFO_BASE (FLASH_APP_BASE + FLASH_APP_SIZE)
#define FLASH_BINFO_SIZE (1*FLASH_SECTOR_SIZE)
//user config
#define FLASH_CFG_BASE (FLASH_BINFO_BASE + FLASH_BINFO_SIZE)
#define FLASH_CFG_SIZE (1*FLASH_SECTOR_SIZE)
#define FLASH_CFG_MAGIC (0xa5)
/*******************************************************************************
* Global variable definitions ('extern')
******************************************************************************/
/*******************************************************************************
Global function prototypes (definition in C source)
******************************************************************************/
int32_t hdl_flash_unlock(void);
int32_t hdl_flash_lock(void);
int32_t hdl_flash_check_addralign(uint32_t u32Addr);
int32_t hdl_flash_erase_sector(uint32_t u32Addr, uint32_t u32Size);
int32_t hdl_flash_write_data(uint32_t u32Addr, uint8_t *pu8Buff, uint32_t u32Len);
int32_t hdl_flash_read_data(uint32_t u32Addr, uint8_t *pu8Buff, uint32_t u32Len);
#ifdef __cplusplus
}
#endif
#endif /* __FLASH_H__ */
/*******************************************************************************
* EOF (not truncated)
******************************************************************************/
hdl/hdl_lcd.c
+494
View File
@@ -0,0 +1,494 @@
#include "hdl_lcd.h"
static volatile uint8_t enTxCompleteFlag = 0;
lcd_dma_callback_t lcd_dma_cbs = NULL;
lcd_timer_callback_t lcd_timer_cbs = NULL;
static void hdl_lcd_dma_tcpl_callback(void)
{
enTxCompleteFlag = SET;
if(lcd_dma_cbs)
{
lcd_dma_cbs();
}
DMA_ClearTransCompleteStatus(LCD_DMA_UNIT, LCD_DMA_TX_INT_CH);
}
static void hdl_lcd_timer_callback(void)
{
if(lcd_timer_cbs)
{
lcd_timer_cbs();
}
TMR0_ClearStatus(LCD_TIM_UINT, LCD_TIM_CH_FLAG);
}
void hdl_lcd_timer_config(void)
{
stc_tmr0_init_t stcTmr0Init;
stc_irq_signin_config_t stcIrqSignConfig;
LL_PERIPH_WE(LL_PERIPH_GPIO | LL_PERIPH_EFM | LL_PERIPH_FCG | LL_PERIPH_PWC_CLK_RMU | LL_PERIPH_SRAM);
/* Enable timer0 and AOS clock */
FCG_Fcg2PeriphClockCmd(LCD_TIM_CLK, ENABLE);
FCG_Fcg0PeriphClockCmd(FCG0_PERIPH_AOS, ENABLE);
/* TIMER0 configuration */
(void)TMR0_StructInit(&stcTmr0Init);
stcTmr0Init.u32ClockSrc = TMR0_CLK_SRC_INTERN_CLK; //内部时钟
stcTmr0Init.u32ClockDiv = TMR0_CLK_DIV64; //2分频
stcTmr0Init.u32Func = TMR0_FUNC_CMP; //输出比较
stcTmr0Init.u16CompareValue = (uint16_t)LCD_TIME_CMP_VALUE;
(void)TMR0_Init(LCD_TIM_UINT, LCD_TIM_CH, &stcTmr0Init);
hdl_delay_ms(1U);
TMR0_HWStopCondCmd(LCD_TIM_UINT, LCD_TIM_CH, ENABLE);
hdl_delay_ms(1U);
TMR0_IntCmd(LCD_TIM_UINT, LCD_TIM_CH_INT, ENABLE);
/* Interrupt configuration */
stcIrqSignConfig.enIntSrc = LCD_TIM_INT_SRC;
stcIrqSignConfig.enIRQn = LCD_TIM_IRQn;
stcIrqSignConfig.pfnCallback = &hdl_lcd_timer_callback;
(void)INTC_IrqSignIn(&stcIrqSignConfig);
NVIC_ClearPendingIRQ(stcIrqSignConfig.enIRQn);
NVIC_SetPriority(stcIrqSignConfig.enIRQn, DDL_IRQ_PRIO_DEFAULT);
NVIC_EnableIRQ(stcIrqSignConfig.enIRQn);
TMR0_Start(LCD_TIM_UINT, LCD_TIM_CH);
LL_PERIPH_WP(LL_PERIPH_EFM | LL_PERIPH_FCG | LL_PERIPH_SRAM);
}
void hdl_lcd_config(void)
{
stc_spi_init_t stcSpiInit;
stc_dma_init_t stcDmaInit;
stc_irq_signin_config_t stcIrqSignConfig;
stc_gpio_init_t stcGpioInit;
LL_PERIPH_WE(LL_PERIPH_GPIO | LL_PERIPH_EFM | LL_PERIPH_FCG | LL_PERIPH_PWC_CLK_RMU | LL_PERIPH_SRAM);
/* 引脚设置 */
GPIO_SetDebugPort(GPIO_PIN_TRST,DISABLE);
(void)GPIO_StructInit(&stcGpioInit);
stcGpioInit.u16PinDrv = PIN_HIGH_DRV;
(void)GPIO_Init(LCD_SCL_PORT, LCD_SCL_PIN, &stcGpioInit);
(void)GPIO_Init(LCD_SDA_PORT, LCD_SDA_PIN, &stcGpioInit);
GPIO_SetFunc(LCD_SCL_PORT, LCD_SCL_PIN, LCD_SCL_FUNC);
GPIO_SetFunc(LCD_SDA_PORT, LCD_SDA_PIN, LCD_SDA_FUNC);
stcGpioInit.u16PinDir = PIN_DIR_OUT;
(void)GPIO_Init(LCD_RES_PORT, LCD_RES_PIN, &stcGpioInit);
(void)GPIO_Init(LCD_DC_PORT, LCD_DC_PIN, &stcGpioInit);
/* SPI配置 */
FCG_Fcg1PeriphClockCmd(LCD_SPI_CLK, ENABLE);
SPI_StructInit(&stcSpiInit);
stcSpiInit.u32WireMode = SPI_3_WIRE;
stcSpiInit.u32TransMode = SPI_SEND_ONLY;
stcSpiInit.u32MasterSlave = SPI_MASTER;
stcSpiInit.u32Parity = SPI_PARITY_INVD;
stcSpiInit.u32SpiMode = SPI_MD_3;
stcSpiInit.u32BaudRatePrescaler = SPI_BR_CLK_DIV2;
stcSpiInit.u32DataBits = SPI_DATA_SIZE_8BIT;
stcSpiInit.u32FirstBit = SPI_FIRST_MSB;
stcSpiInit.u32FrameLevel = SPI_1_FRAME;
(void)SPI_Init(LCD_SPI_UINT, &stcSpiInit);
/* DMA配置 */
FCG_Fcg0PeriphClockCmd(LCD_DMA_CLK, ENABLE);
(void)DMA_StructInit(&stcDmaInit);
stcDmaInit.u32BlockSize = 1UL;
stcDmaInit.u32TransCount = 1;
stcDmaInit.u32DataWidth = DMA_DATAWIDTH_8BIT; //数据位宽
stcDmaInit.u32SrcAddrInc = DMA_SRC_ADDR_INC; //源地址自增
stcDmaInit.u32DestAddrInc = DMA_DEST_ADDR_FIX; //目标地址固定
stcDmaInit.u32SrcAddr = (uint32_t)(0);
stcDmaInit.u32DestAddr = (uint32_t)(&LCD_SPI_UINT->DR);
stcDmaInit.u32IntEn = DMA_INT_ENABLE;
if (LL_OK != DMA_Init(LCD_DMA_UNIT, LCD_DMA_TX_CH, &stcDmaInit)) {
for (;;) {
}
}
AOS_SetTriggerEventSrc(LCD_DMA_TX_TRIG_CH, LCD_SPI_TX_EVT_SRC); //DMA发送触发源
/* DMA 中断配置 */
DMA_TransCompleteIntCmd(LCD_DMA_UNIT, DMA_INT_BTC_CH0, DISABLE);
stcIrqSignConfig.enIntSrc = LCD_DMA_TX_INT_SRC;
stcIrqSignConfig.enIRQn = LCD_DMA_TX_IRQ_NUM;
stcIrqSignConfig.pfnCallback = &hdl_lcd_dma_tcpl_callback;
(void)INTC_IrqSignIn(&stcIrqSignConfig);
NVIC_ClearPendingIRQ(stcIrqSignConfig.enIRQn);
NVIC_SetPriority(stcIrqSignConfig.enIRQn, DDL_IRQ_PRIO_14);
NVIC_EnableIRQ(stcIrqSignConfig.enIRQn);
LL_PERIPH_WP(LL_PERIPH_EFM | LL_PERIPH_FCG | LL_PERIPH_SRAM);
DMA_Cmd(LCD_DMA_UNIT, ENABLE);
DMA_ChCmd(LCD_DMA_UNIT, LCD_DMA_TX_CH, ENABLE);
}
static void hdl_lcd_write_byte(uint8_t dat)
{
SPI_Cmd(LCD_SPI_UINT, ENABLE);
while (RESET == SPI_GetStatus(LCD_SPI_UINT, SPI_FLAG_TX_BUF_EMPTY)){}
SPI_WriteData(LCD_SPI_UINT, (uint32_t)dat);
while (RESET == SPI_GetStatus(LCD_SPI_UINT, SPI_FLAG_IDLE)){}
SPI_Cmd(LCD_SPI_UINT, DISABLE);
}
void hdl_lcd_send(uint8_t *data, uint16_t len)
{
LCD_DC_SET();//写数据
enTxCompleteFlag = RESET;
DMA_SetSrcAddr(LCD_DMA_UNIT, LCD_DMA_TX_CH, (uint32_t)(data)); // 重新设置源地址和发送的数据
DMA_SetTransCount(LCD_DMA_UNIT, LCD_DMA_TX_CH, len); //设置传输次数,传输一次，计数器减到0停止
DMA_ChCmd(LCD_DMA_UNIT, LCD_DMA_TX_CH, ENABLE); //使能DMA1通道
SPI_Cmd(LCD_SPI_UINT, ENABLE); //使能SPI
while (RESET == enTxCompleteFlag) {
}
SPI_Cmd(LCD_SPI_UINT, DISABLE); //失能SPI
}
void hdl_lcd_dma_callback_register(lcd_dma_callback_t pCBS)
{
if(lcd_dma_cbs == 0)
{
lcd_dma_cbs = pCBS;
}
}
void hdl_lcd_timer_callback_register(lcd_timer_callback_t pCBS)
{
if(lcd_timer_cbs == 0)
{
lcd_timer_cbs = pCBS;
}
}
/******************************************************************************
函数说明：LCD写入数据
入口数据：dat 写入的数据
返回值： 无
******************************************************************************/
void LCD_WR_DATA8(uint8_t dat)
{
LCD_DC_SET();//写数据
hdl_lcd_write_byte(dat);
}
/******************************************************************************
函数说明：LCD写入数据
入口数据：dat 写入的数据
返回值： 无
******************************************************************************/
void LCD_WR_DATA(uint16_t dat)
{
LCD_DC_SET();//写数据
hdl_lcd_write_byte(dat>>8);
hdl_lcd_write_byte(dat);
}
/******************************************************************************
函数说明：LCD写入命令
入口数据：dat 写入的命令
返回值： 无
******************************************************************************/
void LCD_WR_REG(uint8_t dat)
{
LCD_DC_CLR();//写命令
hdl_lcd_write_byte(dat);
}
/******************************************************************************
函数说明：设置起始和结束地址
入口数据：x1,x2 设置列的起始和结束地址
y1,y2 设置行的起始和结束地址
返回值： 无
******************************************************************************/
void LCD_Address_Set(uint16_t x1,uint16_t y1,uint16_t x2,uint16_t y2)
{
LCD_WR_REG(0x2a);//列地址设置
LCD_WR_DATA(x1);
LCD_WR_DATA(x2);
LCD_WR_REG(0x2b);//行地址设置
LCD_WR_DATA(y1);
LCD_WR_DATA(y2);
LCD_WR_REG(0x2c);//储存器写
}
void hdl_lcd_fill(uint16_t x1,uint16_t y1,uint16_t x2,uint16_t y2, uint8_t *color)
{
LCD_Address_Set(x1,y1,x2,y2);//设置显示范围
hdl_lcd_send(color, (x2-x1+1)*(y2-y1+1)*2);
}
void LCD_DrawPoint(uint16_t x,uint16_t y,uint16_t color)
{
LCD_Address_Set(x,y,x,y);//设置光标位置
LCD_WR_DATA(color);
}
void hdl_lcd_init(void)
{
hdl_lcd_config();
hdl_lcd_timer_config();
LCD_RES_CLR();//复位
hdl_delay_ms(100);
LCD_RES_SET();
hdl_delay_ms(100);
LCD_WR_REG(0xEF);
LCD_WR_REG(0xEB);
LCD_WR_DATA8(0x14);
LCD_WR_REG(0xFE);
LCD_WR_REG(0xEF);
LCD_WR_REG(0xEB);
LCD_WR_DATA8(0x14);
LCD_WR_REG(0x84);
LCD_WR_DATA8(0x40);
LCD_WR_REG(0x85);
LCD_WR_DATA8(0xFF);
LCD_WR_REG(0x86);
LCD_WR_DATA8(0xFF);
LCD_WR_REG(0x87);
LCD_WR_DATA8(0xFF);
LCD_WR_REG(0x88);
LCD_WR_DATA8(0x0A);
LCD_WR_REG(0x89);
LCD_WR_DATA8(0x21);
LCD_WR_REG(0x8A);
LCD_WR_DATA8(0x00);
LCD_WR_REG(0x8B);
LCD_WR_DATA8(0x80);
LCD_WR_REG(0x8C);
LCD_WR_DATA8(0x01);
LCD_WR_REG(0x8D);
LCD_WR_DATA8(0x01);
LCD_WR_REG(0x8E);
LCD_WR_DATA8(0xFF);
LCD_WR_REG(0x8F);
LCD_WR_DATA8(0xFF);
LCD_WR_REG(0xB6);
LCD_WR_DATA8(0x00);
LCD_WR_DATA8(0x20);
LCD_WR_REG(0x36);
if(USE_HORIZONTAL==0)LCD_WR_DATA8(0x08);
else if(USE_HORIZONTAL==1)LCD_WR_DATA8(0xC8);
else if(USE_HORIZONTAL==2)LCD_WR_DATA8(0x68);
else LCD_WR_DATA8(0xA8);
LCD_WR_REG(0x3A);
LCD_WR_DATA8(0x05);
LCD_WR_REG(0x90);
LCD_WR_DATA8(0x08);
LCD_WR_DATA8(0x08);
LCD_WR_DATA8(0x08);
LCD_WR_DATA8(0x08);
LCD_WR_REG(0xBD);
LCD_WR_DATA8(0x06);
LCD_WR_REG(0xBC);
LCD_WR_DATA8(0x00);
LCD_WR_REG(0xFF);
LCD_WR_DATA8(0x60);
LCD_WR_DATA8(0x01);
LCD_WR_DATA8(0x04);
LCD_WR_REG(0xC3);
LCD_WR_DATA8(0x13);
LCD_WR_REG(0xC4);
LCD_WR_DATA8(0x13);
LCD_WR_REG(0xC9);
LCD_WR_DATA8(0x22);
LCD_WR_REG(0xBE);
LCD_WR_DATA8(0x11);
LCD_WR_REG(0xE1);
LCD_WR_DATA8(0x10);
LCD_WR_DATA8(0x0E);
LCD_WR_REG(0xDF);
LCD_WR_DATA8(0x21);
LCD_WR_DATA8(0x0c);
LCD_WR_DATA8(0x02);
LCD_WR_REG(0xF0);
LCD_WR_DATA8(0x45);
LCD_WR_DATA8(0x09);
LCD_WR_DATA8(0x08);
LCD_WR_DATA8(0x08);
LCD_WR_DATA8(0x26);
LCD_WR_DATA8(0x2A);
LCD_WR_REG(0xF1);
LCD_WR_DATA8(0x43);
LCD_WR_DATA8(0x70);
LCD_WR_DATA8(0x72);
LCD_WR_DATA8(0x36);
LCD_WR_DATA8(0x37);
LCD_WR_DATA8(0x6F);
LCD_WR_REG(0xF2);
LCD_WR_DATA8(0x45);
LCD_WR_DATA8(0x09);
LCD_WR_DATA8(0x08);
LCD_WR_DATA8(0x08);
LCD_WR_DATA8(0x26);
LCD_WR_DATA8(0x2A);
LCD_WR_REG(0xF3);
LCD_WR_DATA8(0x43);
LCD_WR_DATA8(0x70);
LCD_WR_DATA8(0x72);
LCD_WR_DATA8(0x36);
LCD_WR_DATA8(0x37);
LCD_WR_DATA8(0x6F);
LCD_WR_REG(0xED);
LCD_WR_DATA8(0x1B);
LCD_WR_DATA8(0x0B);
LCD_WR_REG(0xAE);
LCD_WR_DATA8(0x77);
LCD_WR_REG(0xCD);
LCD_WR_DATA8(0x63);
LCD_WR_REG(0x70);
LCD_WR_DATA8(0x07);
LCD_WR_DATA8(0x07);
LCD_WR_DATA8(0x04);
LCD_WR_DATA8(0x0E);
LCD_WR_DATA8(0x0F);
LCD_WR_DATA8(0x09);
LCD_WR_DATA8(0x07);
LCD_WR_DATA8(0x08);
LCD_WR_DATA8(0x03);
LCD_WR_REG(0xE8);
LCD_WR_DATA8(0x34);
LCD_WR_REG(0x62);
LCD_WR_DATA8(0x18);
LCD_WR_DATA8(0x0D);
LCD_WR_DATA8(0x71);
LCD_WR_DATA8(0xED);
LCD_WR_DATA8(0x70);
LCD_WR_DATA8(0x70);
LCD_WR_DATA8(0x18);
LCD_WR_DATA8(0x0F);
LCD_WR_DATA8(0x71);
LCD_WR_DATA8(0xEF);
LCD_WR_DATA8(0x70);
LCD_WR_DATA8(0x70);
LCD_WR_REG(0x63);
LCD_WR_DATA8(0x18);
LCD_WR_DATA8(0x11);
LCD_WR_DATA8(0x71);
LCD_WR_DATA8(0xF1);
LCD_WR_DATA8(0x70);
LCD_WR_DATA8(0x70);
LCD_WR_DATA8(0x18);
LCD_WR_DATA8(0x13);
LCD_WR_DATA8(0x71);
LCD_WR_DATA8(0xF3);
LCD_WR_DATA8(0x70);
LCD_WR_DATA8(0x70);
LCD_WR_REG(0x64);
LCD_WR_DATA8(0x28);
LCD_WR_DATA8(0x29);
LCD_WR_DATA8(0xF1);
LCD_WR_DATA8(0x01);
LCD_WR_DATA8(0xF1);
LCD_WR_DATA8(0x00);
LCD_WR_DATA8(0x07);
LCD_WR_REG(0x66);
LCD_WR_DATA8(0x3C);
LCD_WR_DATA8(0x00);
LCD_WR_DATA8(0xCD);
LCD_WR_DATA8(0x67);
LCD_WR_DATA8(0x45);
LCD_WR_DATA8(0x45);
LCD_WR_DATA8(0x10);
LCD_WR_DATA8(0x00);
LCD_WR_DATA8(0x00);
LCD_WR_DATA8(0x00);
LCD_WR_REG(0x67);
LCD_WR_DATA8(0x00);
LCD_WR_DATA8(0x3C);
LCD_WR_DATA8(0x00);
LCD_WR_DATA8(0x00);
LCD_WR_DATA8(0x00);
LCD_WR_DATA8(0x01);
LCD_WR_DATA8(0x54);
LCD_WR_DATA8(0x10);
LCD_WR_DATA8(0x32);
LCD_WR_DATA8(0x98);
LCD_WR_REG(0x74);
LCD_WR_DATA8(0x10);
LCD_WR_DATA8(0x85);
LCD_WR_DATA8(0x80);
LCD_WR_DATA8(0x00);
LCD_WR_DATA8(0x00);
LCD_WR_DATA8(0x4E);
LCD_WR_DATA8(0x00);
LCD_WR_REG(0x98);
LCD_WR_DATA8(0x3e);
LCD_WR_DATA8(0x07);
LCD_WR_REG(0x35);
LCD_WR_REG(0x21);
LCD_WR_REG(0x11);
hdl_delay_ms(120);
LCD_WR_REG(0x29);
hdl_delay_ms(20);
}
hdl/hdl_lcd.h
+99
View File
@@ -0,0 +1,99 @@
#ifndef ____HDL_LCD_H_
#define ____HDL_LCD_H_
#include "hc32_ll.h"
#include "hdl_clk.h"
#include "lvgl.h"
/* lcd刷屏定时器处理 */
#define LCD_TIM_UINT CM_TMR0_1
#define LCD_TIM_CLK FCG2_PERIPH_TMR0_1
#define LCD_TIM_CH TMR0_CH_B
#define LCD_TIM_TRIG_CH AOS_TMR0
#define LCD_TIM_CH_INT TMR0_INT_CMP_B
#define LCD_TIM_CH_FLAG TMR0_FLAG_CMP_B
#define LCD_TIM_INT_SRC INT_SRC_TMR0_1_CMP_B
#define LCD_TIM_IRQn INT007_IRQn
#define LCD_TIME_CMP_VALUE (1563)
#define USE_HORIZONTAL 0 //设置横屏或者竖屏显示 0或1为竖屏 2或3为横屏
#define LCD_W 240
#define LCD_H 240
#define LCD_SPI_UINT CM_SPI3
#define LCD_SPI_CLK FCG1_PERIPH_SPI3
#define LCD_SPI_TX_EVT_SRC EVT_SRC_SPI3_SPTI
#define LCD_SCL_PORT GPIO_PORT_B
#define LCD_SCL_PIN GPIO_PIN_07
#define LCD_SCL_FUNC GPIO_FUNC_43
#define LCD_SDA_PORT GPIO_PORT_B
#define LCD_SDA_PIN GPIO_PIN_06
#define LCD_SDA_FUNC GPIO_FUNC_40
#define LCD_DMA_UNIT CM_DMA1
#define LCD_DMA_CLK (FCG0_PERIPH_DMA1 | FCG0_PERIPH_AOS)
#define LCD_DMA_TX_CH DMA_CH0
#define LCD_DMA_TX_TRIG_CH AOS_DMA1_0
#define LCD_DMA_TX_INT_CH DMA_INT_TC_CH0
#define LCD_DMA_TX_INT_SRC INT_SRC_DMA1_TC0
#define LCD_DMA_TX_IRQ_NUM INT006_IRQn
#define LCD_RES_PORT GPIO_PORT_B
#define LCD_RES_PIN GPIO_PIN_05
#define LCD_DC_PORT GPIO_PORT_B
#define LCD_DC_PIN GPIO_PIN_04
#define LCD_RES_SET() GPIO_SetPins(LCD_RES_PORT, LCD_RES_PIN)
#define LCD_RES_CLR() GPIO_ResetPins(LCD_RES_PORT, LCD_RES_PIN)
#define LCD_DC_SET() GPIO_SetPins(LCD_DC_PORT, LCD_DC_PIN)
#define LCD_DC_CLR() GPIO_ResetPins(LCD_DC_PORT, LCD_DC_PIN)
#define LCD_SCLK_Clr() GPIO_ResetPins(GPIO_PORT_B,GPIO_PIN_07)//SCL=SCLK
#define LCD_SCLK_Set() GPIO_SetPins(GPIO_PORT_B,GPIO_PIN_07)
#define LCD_MOSI_Clr() GPIO_ResetPins(GPIO_PORT_B,GPIO_PIN_06)//SDA=MOSI
#define LCD_MOSI_Set() GPIO_SetPins(GPIO_PORT_B,GPIO_PIN_06)
//画笔颜色
#define WHITE 0xFFFF
#define BLACK 0x0000
#define BLUE 0x001F
#define BRED 0XF81F
#define GRED 0XFFE0
#define GBLUE 0X07FF
#define RED 0xF800
#define MAGENTA 0xF81F
#define GREEN 0x07E0
#define CYAN 0x7FFF
#define YELLOW 0xFFE0
#define BROWN 0XBC40 //棕色
#define BRRED 0XFC07 //棕红色
#define GRAY 0X8430 //灰色
#define DARKBLUE 0X01CF //深蓝色
#define LIGHTBLUE 0X7D7C //浅蓝色
#define GRAYBLUE 0X5458 //灰蓝色
#define LIGHTGREEN 0X841F //浅绿色
#define LGRAY 0XC618 //浅灰色(PANNEL),窗体背景色
#define LGRAYBLUE 0XA651 //浅灰蓝色(中间层颜色)
#define LBBLUE 0X2B12 //浅棕蓝色(选择条目的反色)
typedef void (*lcd_dma_callback_t)(void);
typedef void (*lcd_timer_callback_t)(void);
void hdl_lcd_init(void);
void hdl_lcd_send(uint8_t *data, uint16_t len);
void LCD_Address_Set(uint16_t x1,uint16_t y1,uint16_t x2,uint16_t y2);
void LCD_DrawPoint(uint16_t x,uint16_t y,uint16_t color);
void hdl_lcd_fill(uint16_t x1,uint16_t y1,uint16_t x2,uint16_t y2, uint8_t *color);
void hdl_lcd_dma_callback_register(lcd_dma_callback_t pCBS);
void hdl_lcd_timer_callback_register(lcd_timer_callback_t pCBS);
#endif
hdl/hdl_led.c
+40
View File
@@ -0,0 +1,40 @@
#include "hdl_led.h"
#define LED_PORT (GPIO_PORT_H)
#define LED_PIN (GPIO_PIN_02)
void hdl_led_init(void){
LL_PERIPH_WE(LL_PERIPH_GPIO);
stc_gpio_init_t stcGpioInit={0};
//GPIO_StructInit(&stcGpioInit);
stcGpioInit.u16PinDir = PIN_DIR_OUT;
stcGpioInit.u16PinState = PIN_STAT_SET;
stcGpioInit.u16PinDrv = PIN_HIGH_DRV;
(void)GPIO_Init( LED_PORT ,LED_PIN, &stcGpioInit);
LL_PERIPH_WP(LL_PERIPH_GPIO);
}
void hdl_led_on(hdl_led_id_t id){
GPIO_SetPins(LED_PORT ,LED_PIN );
}
void hdl_led_off(hdl_led_id_t id){
GPIO_ResetPins(LED_PORT ,LED_PIN);
}
void hdl_led_toggle(hdl_led_id_t id){
GPIO_ResetPins(LED_PORT ,LED_PIN);
}
hdl/hdl_led.h
+26
View File
@@ -0,0 +1,26 @@
#ifndef _HDL_LED_H_
#define _HDL_LED_H_
#include "hc32_ll.h"
#include "stdint.h"
typedef enum
{
HDL_LED_ID_0,
HDL_LED_ID_MAX,
}hdl_led_id_t;
typedef struct
{
uint8_t port;
uint16_t pin;
}hdl_led_t;
extern void hdl_led_init(void);
extern void hdl_led_on(hdl_led_id_t id);
extern void hdl_led_off(hdl_led_id_t id);
extern void hdl_led_toggle(hdl_led_id_t id);
#endif
hdl/hdl_pwm.c
+89
View File
@@ -0,0 +1,89 @@
#include "hdl_pwm.h"
/*unit 0.01us*/
static void TmrAConfig(uint32_t t)
{
stc_clock_freq_t sysFrq;
CLK_GetClockFreq(&sysFrq);
uint32_t peroid = 1.0 *sysFrq.u32Pclk1Freq / t;
stc_tmra_init_t stcTmraInit;
stc_tmra_pwm_init_t stcPwmInit;
/* 1. Enable TimerA peripheral clock. */
FCG_Fcg2PeriphClockCmd(TMRA_PERIPH_CLK, ENABLE);
/* 2. Set a default initialization value for stcTmraInit. */
(void)TMRA_StructInit(&stcTmraInit);
/* 3. Modifies the initialization values depends on the application. */
stcTmraInit.sw_count.u8CountMode = TMRA_MD;
stcTmraInit.sw_count.u8CountDir = TMRA_DIR;
stcTmraInit.u32PeriodValue = (peroid-1);
(void)TMRA_Init(TMRA_UNIT, &stcTmraInit);
/* 4. Set the comparison reference value. */
#if (APP_FUNC == APP_FUNC_NORMAL_SINGLE_PWM)
(void)TMRA_PWM_StructInit(&stcPwmInit);
stcPwmInit.u32CompareValue = 0;
stcPwmInit.u16PeriodMatchPolarity = TMRA_PWM_HIGH;
GPIO_SetFunc(TMRA_PWM_PORT, TMRA_PWM_PIN, TMRA_PWM_PIN_FUNC);
(void)TMRA_PWM_Init(TMRA_UNIT, TMRA_PWM_CH, &stcPwmInit);
TMRA_PWM_OutputCmd(TMRA_UNIT, TMRA_PWM_CH, ENABLE);
#endif
}
void hdl_pwm_init(int frq){
/* MCU Peripheral registers write unprotected. */
LL_PERIPH_WE(LL_PERIPH_GPIO | LL_PERIPH_FCG | LL_PERIPH_PWC_CLK_RMU);
/* Configures TimerA. */
TmrAConfig( frq);
/* MCU Peripheral registers write protected. */
LL_PERIPH_WP(LL_PERIPH_GPIO | LL_PERIPH_FCG | LL_PERIPH_PWC_CLK_RMU);
}
void hdl_pwm_enable(void){
/* Starts TimerA. */
TMRA_Start(TMRA_UNIT);
}
void hdl_pwm_disable(void){
/* Starts TimerA. */
TMRA_Stop(TMRA_UNIT);
}
void hdl_pwm_set_duty(int duty){
uint32_t period = TMRA_GetPeriodValue(TMRA_UNIT)+1;
uint32_t val = duty*0.01*period;
if(val <1){
val =1;
}
if(val >period){
val =period;
}
TMRA_Stop(TMRA_UNIT);
TMRA_SetCountValue(TMRA_UNIT,0);
TMRA_SetCompareValue(TMRA_UNIT,TMRA_PWM_CH,val-1);
TMRA_Start(TMRA_UNIT);
}
hdl/hdl_pwm.h
+26
View File
@@ -0,0 +1,26 @@
#ifndef ____HDL_PWM_H_
#define ____HDL_PWM_H_
#include "hc32_ll.h"
#define TMRA_UNIT (CM_TMRA_1)
#define TMRA_PERIPH_CLK (FCG2_PERIPH_TMRA_1)
#define TMRA_PWM_CH (TMRA_CH1)
#define TMRA_PWM_PORT (GPIO_PORT_A)
#define TMRA_PWM_PIN (GPIO_PIN_08)
#define TMRA_PWM_PIN_FUNC (GPIO_FUNC_4)
#define TMRA_MD (TMRA_MD_SAWTOOTH)
#define TMRA_DIR (TMRA_DIR_UP)
void hdl_pwm_init(int frq);
void hdl_pwm_enable(void);
void hdl_pwm_disable(void);
void hdl_pwm_set_duty(int duty);
#endif
hdl/hdl_spi.c
+216
View File
@@ -0,0 +1,216 @@
#include "hdl_spi.h"
void hdl_spi1_init(void)
{
stc_spi_init_t stcSpiInit;
stc_gpio_init_t stcGpioInit;
LL_PERIPH_WE(LL_PERIPH_GPIO | LL_PERIPH_EFM | LL_PERIPH_FCG | LL_PERIPH_PWC_CLK_RMU | LL_PERIPH_SRAM);
/* 配置SPI引脚 */
(void)GPIO_StructInit(&stcGpioInit);
stcGpioInit.u16PinDrv = PIN_HIGH_DRV;
stcGpioInit.u16PinDrv = PIN_HIGH_DRV;
(void)GPIO_Init(SPI1_SCLK_PORT, SPI1_SCLK_PIN, &stcGpioInit);
(void)GPIO_Init(SPI1_MOSI_PORT, SPI1_MOSI_PIN, &stcGpioInit);
(void)GPIO_Init(SPI1_MISO_PORT, SPI1_MISO_PIN, &stcGpioInit);
GPIO_SetFunc(SPI1_SCLK_PORT, SPI1_SCLK_PIN, SPI1_SCLK_FUNC);
GPIO_SetFunc(SPI1_MOSI_PORT, SPI1_MOSI_PIN, SPI1_MOSI_FUNC);
GPIO_SetFunc(SPI1_MISO_PORT, SPI1_MISO_PIN, SPI1_MISO_FUNC);
/* 配置SPI参数 */
SPI_StructInit(&stcSpiInit);
FCG_Fcg1PeriphClockCmd(SPI1_CLOCK, ENABLE);
stcSpiInit.u32WireMode = SPI_3_WIRE; //3线SPI
stcSpiInit.u32TransMode = SPI_FULL_DUPLEX; //全双工
stcSpiInit.u32MasterSlave = SPI_MASTER; //主机
stcSpiInit.u32ModeFaultDetect = SPI_MD_FAULT_DETECT_DISABLE; // 禁用模式故障检测
stcSpiInit.u32Parity = SPI_PARITY_INVD; //无奇偶校验
stcSpiInit.u32SpiMode = SPI_MD_3; //SPI模式3
stcSpiInit.u32BaudRatePrescaler = SPI_BR_CLK_DIV64; //预分频
stcSpiInit.u32DataBits = SPI_DATA_SIZE_8BIT; //数据宽度
stcSpiInit.u32FirstBit = SPI_FIRST_MSB; //MSB高位有效
(void)SPI_Init(SPI1_INSTANCE, &stcSpiInit);
SPI_Cmd(SPI1_INSTANCE, ENABLE);
LL_PERIPH_WP(LL_PERIPH_EFM | LL_PERIPH_FCG | LL_PERIPH_SRAM);
}
uint8_t hdl_spi1_txrx(uint8_t w_data)
{
uint8_t r_data = 0;
uint16_t retry = 0;
while (RESET == SPI_GetStatus(SPI1_INSTANCE, SPI_FLAG_TX_BUF_EMPTY))
{
retry++;
if(retry > 200)
{
return 0;
}
}
SPI_WriteData(SPI1_INSTANCE, (uint32_t)w_data);
while (RESET == SPI_GetStatus(SPI1_INSTANCE, SPI_FLAG_RX_BUF_FULL))
{
retry++;
if(retry > 200)
{
return 0;
}
}
r_data = SPI_ReadData(SPI1_INSTANCE);
return r_data;
}
void hdl_spi2_init(void)
{
stc_spi_init_t stcSpiInit;
stc_gpio_init_t stcGpioInit;
LL_PERIPH_WE(LL_PERIPH_GPIO | LL_PERIPH_EFM | LL_PERIPH_FCG | LL_PERIPH_PWC_CLK_RMU | LL_PERIPH_SRAM);
/* 配置SPI引脚 */
(void)GPIO_StructInit(&stcGpioInit);
stcGpioInit.u16PinDrv = PIN_HIGH_DRV;
stcGpioInit.u16PinDrv = PIN_HIGH_DRV;
(void)GPIO_Init(SPI2_SCLK_PORT, SPI2_SCLK_PIN, &stcGpioInit);
(void)GPIO_Init(SPI2_MOSI_PORT, SPI2_MOSI_PIN, &stcGpioInit);
(void)GPIO_Init(SPI2_MISO_PORT, SPI2_MISO_PIN, &stcGpioInit);
GPIO_SetFunc(SPI2_SCLK_PORT, SPI2_SCLK_PIN, SPI2_SCLK_FUNC);
GPIO_SetFunc(SPI2_MOSI_PORT, SPI2_MOSI_PIN, SPI2_MOSI_FUNC);
GPIO_SetFunc(SPI2_MISO_PORT, SPI2_MISO_PIN, SPI2_MISO_FUNC);
/* 配置SPI参数 */
SPI_StructInit(&stcSpiInit);
FCG_Fcg1PeriphClockCmd(SPI2_CLOCK, ENABLE);
stcSpiInit.u32WireMode = SPI_3_WIRE; //3线SPI
stcSpiInit.u32TransMode = SPI_FULL_DUPLEX; //全双工
stcSpiInit.u32MasterSlave = SPI_MASTER; //主机
stcSpiInit.u32ModeFaultDetect = SPI_MD_FAULT_DETECT_DISABLE; // 禁用模式故障检测
stcSpiInit.u32Parity = SPI_PARITY_INVD; //无奇偶校验
stcSpiInit.u32SpiMode = SPI_MD_3; //SPI模式3
stcSpiInit.u32BaudRatePrescaler = SPI_BR_CLK_DIV64; //预分频
stcSpiInit.u32DataBits = SPI_DATA_SIZE_8BIT; //数据宽度
stcSpiInit.u32FirstBit = SPI_FIRST_MSB; //MSB高位有效
(void)SPI_Init(SPI2_INSTANCE, &stcSpiInit);
SPI_Cmd(SPI2_INSTANCE, ENABLE);
LL_PERIPH_WP(LL_PERIPH_EFM | LL_PERIPH_FCG | LL_PERIPH_SRAM);
}
uint8_t hdl_spi2_txrx(uint8_t w_data)
{
uint8_t r_data = 0;
uint16_t retry = 0;
while (RESET == SPI_GetStatus(SPI2_INSTANCE, SPI_FLAG_TX_BUF_EMPTY))
{
retry++;
if(retry > 200)
{
return 0;
}
}
SPI_WriteData(SPI2_INSTANCE, (uint32_t)w_data);
while (RESET == SPI_GetStatus(SPI2_INSTANCE, SPI_FLAG_RX_BUF_FULL))
{
retry++;
if(retry > 200)
{
return 0;
}
}
r_data = SPI_ReadData(SPI2_INSTANCE);
return r_data;
}
void hdl_spi3_init(void)
{
stc_spi_init_t stcSpiInit;
stc_gpio_init_t stcGpioInit;
LL_PERIPH_WE(LL_PERIPH_GPIO | LL_PERIPH_EFM | LL_PERIPH_FCG | LL_PERIPH_PWC_CLK_RMU | LL_PERIPH_SRAM);
/* 配置SPI引脚 */
(void)GPIO_StructInit(&stcGpioInit);
stcGpioInit.u16PinDrv = PIN_HIGH_DRV;
stcGpioInit.u16PinDrv = PIN_HIGH_DRV;
(void)GPIO_Init(SPI3_SCLK_PORT, SPI3_SCLK_PIN, &stcGpioInit);
(void)GPIO_Init(SPI3_MOSI_PORT, SPI3_MOSI_PIN, &stcGpioInit);
(void)GPIO_Init(SPI3_MISO_PORT, SPI3_MISO_PIN, &stcGpioInit);
GPIO_SetFunc(SPI3_SCLK_PORT, SPI3_SCLK_PIN, SPI3_SCLK_FUNC);
GPIO_SetFunc(SPI3_MOSI_PORT, SPI3_MOSI_PIN, SPI3_MOSI_FUNC);
GPIO_SetFunc(SPI3_MISO_PORT, SPI3_MISO_PIN, SPI3_MISO_FUNC);
/* 配置SPI参数 */
SPI_StructInit(&stcSpiInit);
FCG_Fcg1PeriphClockCmd(SPI3_CLOCK, ENABLE);
stcSpiInit.u32WireMode = SPI_3_WIRE; //3线SPI
stcSpiInit.u32TransMode = SPI_FULL_DUPLEX; //全双工
stcSpiInit.u32MasterSlave = SPI_MASTER; //主机
stcSpiInit.u32ModeFaultDetect = SPI_MD_FAULT_DETECT_DISABLE; // 禁用模式故障检测
stcSpiInit.u32Parity = SPI_PARITY_INVD; //无奇偶校验
stcSpiInit.u32SpiMode = SPI_MD_3; //SPI模式3
stcSpiInit.u32BaudRatePrescaler = SPI_BR_CLK_DIV64; //预分频
stcSpiInit.u32DataBits = SPI_DATA_SIZE_8BIT; //数据宽度
stcSpiInit.u32FirstBit = SPI_FIRST_MSB; //MSB高位有效
(void)SPI_Init(SPI3_INSTANCE, &stcSpiInit);
SPI_Cmd(SPI3_INSTANCE, ENABLE);
LL_PERIPH_WP(LL_PERIPH_EFM | LL_PERIPH_FCG | LL_PERIPH_SRAM);
}
uint8_t hdl_spi3_txrx(uint8_t w_data)
{
uint8_t r_data = 0;
uint16_t retry = 0;
while (RESET == SPI_GetStatus(SPI3_INSTANCE, SPI_FLAG_TX_BUF_EMPTY))
{
retry++;
if(retry > 200)
{
return 0;
}
}
SPI_WriteData(SPI3_INSTANCE, (uint32_t)w_data);
while (RESET == SPI_GetStatus(SPI3_INSTANCE, SPI_FLAG_RX_BUF_FULL))
{
retry++;
if(retry > 200)
{
return 0;
}
}
r_data = SPI_ReadData(SPI3_INSTANCE);
return r_data;
}
hdl/hdl_spi.h
+80
View File
@@ -0,0 +1,80 @@
#ifndef __HDL_SPI_H_
#define __HDL_SPI_H_
#include "hc32_ll.h"
#include "hdl_clk.h"
//logic spi1
#define SPI1_CLOCK FCG1_PERIPH_SPI1
#define SPI1_INSTANCE CM_SPI1
#define SPI1_SCLK_FUNC GPIO_FUNC_43
#define SPI1_SCLK_PORT GPIO_PORT_A
#define SPI1_SCLK_PIN GPIO_PIN_00
#define SPI1_MISO_FUNC GPIO_FUNC_41
#define SPI1_MISO_PORT GPIO_PORT_A
#define SPI1_MISO_PIN GPIO_PIN_02
#define SPI1_MOSI_FUNC GPIO_FUNC_40
#define SPI1_MOSI_PORT GPIO_PORT_A
#define SPI1_MOSI_PIN GPIO_PIN_03
//logic spi2
#define SPI2_CLOCK FCG1_PERIPH_SPI4
#define SPI2_INSTANCE CM_SPI4
#define SPI2_SCLK_FUNC GPIO_FUNC_47
#define SPI2_SCLK_PORT GPIO_PORT_B
#define SPI2_SCLK_PIN GPIO_PIN_13
#define SPI2_MISO_FUNC GPIO_FUNC_45
#define SPI2_MISO_PORT GPIO_PORT_B
#define SPI2_MISO_PIN GPIO_PIN_14
#define SPI2_MOSI_FUNC GPIO_FUNC_44
#define SPI2_MOSI_PORT GPIO_PORT_B
#define SPI2_MOSI_PIN GPIO_PIN_15
//logic spi3
#define SPI3_CLOCK FCG1_PERIPH_SPI3
#define SPI3_INSTANCE CM_SPI3
#define SPI3_SCLK_PORT GPIO_PORT_B
#define SPI3_SCLK_PIN GPIO_PIN_06
#define SPI3_SCLK_FUNC GPIO_FUNC_43
#define SPI3_MISO_PORT GPIO_PORT_B
#define SPI3_MISO_PIN GPIO_PIN_07
#define SPI3_MISO_FUNC GPIO_FUNC_41
#define SPI3_MOSI_PORT GPIO_PORT_B
#define SPI3_MOSI_PIN GPIO_PIN_08
#define SPI3_MOSI_FUNC GPIO_FUNC_40
void hdl_spi1_init(void);
uint8_t hdl_spi1_txrx(uint8_t w_data);
void hdl_spi2_init(void);
uint8_t hdl_spi2_txrx(uint8_t w_data);
void hdl_spi3_init(void);
uint8_t hdl_spi3_txrx(uint8_t w_data);
#endif
hdl/hdl_spi4.c
+71
View File
@@ -0,0 +1,71 @@
#include "hdl_spi4.h"
void hdl_spi4_init(void)
{
stc_spi_init_t stcSpiInit;
stc_gpio_init_t stcGpioInit;
LL_PERIPH_WE(LL_PERIPH_GPIO | LL_PERIPH_EFM | LL_PERIPH_FCG | LL_PERIPH_PWC_CLK_RMU | LL_PERIPH_SRAM);
/* 配置SPI引脚 */
(void)GPIO_StructInit(&stcGpioInit);
stcGpioInit.u16PinDrv = PIN_HIGH_DRV;
stcGpioInit.u16PinDrv = PIN_HIGH_DRV;
(void)GPIO_Init(SPI4_SCLK_PORT, SPI4_SCLK_PIN, &stcGpioInit);
(void)GPIO_Init(SPI4_MOSI_PORT, SPI4_MOSI_PIN, &stcGpioInit);
(void)GPIO_Init(SPI4_MISO_PORT, SPI4_MISO_PIN, &stcGpioInit);
GPIO_SetFunc(SPI4_SCLK_PORT, SPI4_SCLK_PIN, SPI4_SCLK_FUNC);
GPIO_SetFunc(SPI4_MOSI_PORT, SPI4_MOSI_PIN, SPI4_MOSI_FUNC);
GPIO_SetFunc(SPI4_MISO_PORT, SPI4_MISO_PIN, SPI4_MISO_FUNC);
/* 配置SPI参数 */
SPI_StructInit(&stcSpiInit);
FCG_Fcg1PeriphClockCmd(SPI4_CLOCK, ENABLE);
stcSpiInit.u32WireMode = SPI_3_WIRE; //3线SPI
stcSpiInit.u32TransMode = SPI_FULL_DUPLEX; //全双工
stcSpiInit.u32MasterSlave = SPI_MASTER; //主机
stcSpiInit.u32ModeFaultDetect = SPI_MD_FAULT_DETECT_DISABLE; // 禁用模式故障检测
stcSpiInit.u32Parity = SPI_PARITY_INVD; //无奇偶校验
stcSpiInit.u32SpiMode = SPI_MD_3; //SPI模式3
stcSpiInit.u32BaudRatePrescaler = SPI_BR_CLK_DIV64; //预分频
stcSpiInit.u32DataBits = SPI_DATA_SIZE_8BIT; //数据宽度
stcSpiInit.u32FirstBit = SPI_FIRST_MSB; //MSB高位有效
(void)SPI_Init(SPI4_INSTANCE, &stcSpiInit);
SPI_Cmd(SPI4_INSTANCE, ENABLE);
LL_PERIPH_WP(LL_PERIPH_EFM | LL_PERIPH_FCG | LL_PERIPH_SRAM);
}
uint8_t hdl_spi4_txrx(uint8_t w_data)
{
uint8_t r_data = 0;
uint16_t retry = 0;
while (RESET == SPI_GetStatus(SPI4_INSTANCE, SPI_FLAG_TX_BUF_EMPTY))
{
retry++;
if(retry > 200)
{
return 0;
}
}
SPI_WriteData(SPI4_INSTANCE, (uint32_t)w_data);
while (RESET == SPI_GetStatus(SPI4_INSTANCE, SPI_FLAG_RX_BUF_FULL))
{
retry++;
if(retry > 200)
{
return 0;
}
}
r_data = SPI_ReadData(SPI4_INSTANCE);
return r_data;
}
hdl/hdl_spi4.h
+29
View File
@@ -0,0 +1,29 @@
#ifndef __HDL_SPI4_H_
#define __HDL_SPI4_H_
#include "hc32_ll.h"
#include "hdl_clk.h"
//logic spi4
#define SPI4_CLOCK FCG1_PERIPH_SPI1
#define SPI4_INSTANCE CM_SPI1
#define SPI4_SCLK_PORT GPIO_PORT_A
#define SPI4_SCLK_PIN GPIO_PIN_03
#define SPI4_SCLK_FUNC GPIO_FUNC_43
#define SPI4_MISO_PORT GPIO_PORT_A
#define SPI4_MISO_PIN GPIO_PIN_01
#define SPI4_MISO_FUNC GPIO_FUNC_41
#define SPI4_MOSI_PORT GPIO_PORT_A
#define SPI4_MOSI_PIN GPIO_PIN_04
#define SPI4_MOSI_FUNC GPIO_FUNC_40
void hdl_spi4_init(void);
uint8_t hdl_spi4_txrx(uint8_t w_data);
#endif
hdl/hdl_usart.c
+210
View File
@@ -0,0 +1,210 @@
#include "stdio.h"
#include <string.h>
#include <stdarg.h>
#include <stdlib.h>
#include <stdbool.h>
#include "hdl_usart.h"
//定义数据获取回调函数
static hdl_debug_uart_rx_cb_t debug_rx_callback_cbs;
static com_rx_callback com_rx_callback_cbs;
//接收中断
static void COM_Rx_IrqCallback(void);
static void COM_RxErr_IrqCallback(void);
static void INTC_IrqInstalHandler(const stc_irq_signin_config_t* pstcConfig, uint32_t u32Priority)
{
if (NULL != pstcConfig)
{
(void)INTC_IrqSignIn(pstcConfig);
NVIC_ClearPendingIRQ(pstcConfig->enIRQn);
NVIC_SetPriority(pstcConfig->enIRQn, u32Priority);
NVIC_EnableIRQ(pstcConfig->enIRQn);
}
}
//调试串口
static void DEBUG_RxErr_IrqCallback(void)
{
(void)USART_ReadData(DEBUG_UART);
USART_ClearStatus(DEBUG_UART, (USART_FLAG_PARITY_ERR | USART_FLAG_FRAME_ERR | USART_FLAG_OVERRUN));
}
static void DEBUG_Rx_IrqCallback(void)
{
uint8_t r_data = 0;
r_data = USART_ReadData(DEBUG_UART);
if (debug_rx_callback_cbs)
{
debug_rx_callback_cbs(r_data);
}
}
void hdl_debug_uart_rx_reg(hdl_debug_uart_rx_cb_t pCBS)
{
if (debug_rx_callback_cbs == 0)
{
debug_rx_callback_cbs = pCBS;
}
}
void hdl_debug_uart_init(void)
{
stc_usart_uart_init_t stcUartInit;
debug_rx_callback_cbs = 0;
LL_PERIPH_WE(
LL_PERIPH_GPIO |
LL_PERIPH_FCG |
LL_PERIPH_PWC_CLK_RMU |
LL_PERIPH_EFM |
LL_PERIPH_SRAM
);
GPIO_SetDebugPort(GPIO_PIN_TRST, DISABLE);
GPIO_SetFunc(DEBUG_UART_RX_PORT, DEBUG_UART_RX_PIN, DEBUG_UART_RX_GPIO_FUNC);
GPIO_SetFunc(DEBUG_UART_TX_PORT, DEBUG_UART_TX_PIN, DEBUG_UART_TX_GPIO_FUNC);
FCG_Fcg1PeriphClockCmd(DEBUG_UART_CLK, ENABLE);
(void)USART_UART_StructInit(&stcUartInit);
stcUartInit.u32ClockDiv = USART_CLK_DIV1;
stcUartInit.u32Baudrate = 115200UL;
stcUartInit.u32OverSampleBit = USART_OVER_SAMPLE_8BIT;
USART_UART_Init(DEBUG_UART, &stcUartInit, NULL);
//接收中断配置
stc_irq_signin_config_t stcIrqSigninConfig;
stcIrqSigninConfig.enIRQn = DEBUG_UART_INT_EI_IRQ;
stcIrqSigninConfig.enIntSrc = DEBUG_UART_INT_EI;
stcIrqSigninConfig.pfnCallback = &DEBUG_RxErr_IrqCallback;
INTC_IrqInstalHandler(&stcIrqSigninConfig, DDL_IRQ_PRIO_DEFAULT);
stcIrqSigninConfig.enIRQn = DEBUG_UART_INT_RI_IRQ;
stcIrqSigninConfig.enIntSrc = DEBUG_UART_INT_RI;
stcIrqSigninConfig.pfnCallback = &DEBUG_Rx_IrqCallback;
INTC_IrqInstalHandler(&stcIrqSigninConfig, DDL_IRQ_PRIO_DEFAULT);
LL_PERIPH_WP(
LL_PERIPH_GPIO |
LL_PERIPH_FCG |
LL_PERIPH_PWC_CLK_RMU |
LL_PERIPH_EFM |
LL_PERIPH_SRAM
);
USART_FuncCmd(DEBUG_UART, (USART_TX | USART_RX | USART_INT_RX), ENABLE);
//USART_FuncCmd(DEBUG_UART, (USART_TX | USART_RX ), ENABLE);
}
void hdl_debug_uart_putc(uint8_t ch)
{
while (USART_GetStatus(DEBUG_UART, USART_FLAG_TX_EMPTY) == RESET);
USART_WriteData(DEBUG_UART, ch);
}
int hdl_debug_uart_getc(int *ch)
{
if(USART_GetStatus(DEBUG_UART, USART_FLAG_RX_FULL) ==SET){
*ch = USART_ReadData(DEBUG_UART);
return 0;
}else{
return -1;
}
}
//通信模块串口初始化
void hdl_com_uart_init(void)
{
stc_usart_uart_init_t stcUartInit={0};
stc_irq_signin_config_t stcIrqSigninConfig;
com_rx_callback_cbs = 0;
LL_PERIPH_WE(LL_PERIPH_GPIO | LL_PERIPH_FCG | LL_PERIPH_PWC_CLK_RMU | \
LL_PERIPH_EFM | LL_PERIPH_SRAM);
GPIO_SetFunc(COM_RX_PORT, COM_RX_PIN, COM_RX_GPIO_FUNC);
GPIO_SetFunc(COM_TX_PORT, COM_TX_PIN, COM_TX_GPIO_FUNC);
FCG_Fcg1PeriphClockCmd(COM_UART_CLK, ENABLE);
(void)USART_UART_StructInit(&stcUartInit);
stcUartInit.u32ClockDiv = USART_CLK_DIV1;
stcUartInit.u32Baudrate = 500000UL;
stcUartInit.u32OverSampleBit = USART_OVER_SAMPLE_8BIT;
USART_UART_Init(COM_UART, &stcUartInit, NULL);
//接收中断配置
stcIrqSigninConfig.enIRQn = COM_INT_EI_IRQ;
stcIrqSigninConfig.enIntSrc = COM_INT_EI;
stcIrqSigninConfig.pfnCallback = &COM_RxErr_IrqCallback;
INTC_IrqInstalHandler(&stcIrqSigninConfig, DDL_IRQ_PRIO_DEFAULT);
stcIrqSigninConfig.enIRQn = COM_INT_RI_IRQ;
stcIrqSigninConfig.enIntSrc = COM_INT_RI;
stcIrqSigninConfig.pfnCallback = &COM_Rx_IrqCallback;
INTC_IrqInstalHandler(&stcIrqSigninConfig, DDL_IRQ_PRIO_DEFAULT);
USART_FuncCmd(COM_UART, (USART_TX | USART_RX | USART_INT_RX), ENABLE);
LL_PERIPH_WP(LL_PERIPH_GPIO | LL_PERIPH_FCG | LL_PERIPH_PWC_CLK_RMU | \
LL_PERIPH_EFM | LL_PERIPH_SRAM);
}
//通信发送数据
void hdl_com_uart_send(uint8_t* w_buf, uint16_t len)
{
uint8_t i;
for (i = 0; i < len; i++)
{
USART_WriteData(COM_UART, w_buf[i]);
while (USART_GetStatus(COM_UART, USART_FLAG_TX_CPLT) == RESET);
}
}
//通信回调函数注册
void hdl_com_uart_rx_register(com_rx_callback pCBS)
{
if (com_rx_callback_cbs == 0)
{
com_rx_callback_cbs = pCBS;
}
}
//通信接收中断
static void COM_Rx_IrqCallback(void)
{
uint8_t r_data = 0;
r_data = USART_ReadData(COM_UART);
if (com_rx_callback_cbs)
{
com_rx_callback_cbs(r_data);
}
}
static void COM_RxErr_IrqCallback(void)
{
(void)USART_ReadData(COM_UART);
USART_ClearStatus(COM_UART, (USART_FLAG_PARITY_ERR | USART_FLAG_FRAME_ERR | USART_FLAG_OVERRUN));
}
hdl/hdl_usart.h
+60
View File
@@ -0,0 +1,60 @@
#ifndef _HDL_USART_H_
#define _HDL_USART_H_
#include "hc32_ll.h"
#define DEBUG_UART (CM_USART1)
#define DEBUG_UART_CLK (FCG1_PERIPH_USART1)
#define DEBUG_UART_RX_PORT (GPIO_PORT_A) /* PA11: USART2_RX */
#define DEBUG_UART_RX_PIN (GPIO_PIN_11)
#define DEBUG_UART_RX_GPIO_FUNC (GPIO_FUNC_33)
#define DEBUG_UART_TX_PORT (GPIO_PORT_A) /* PA12: USART2_TX */
#define DEBUG_UART_TX_PIN (GPIO_PIN_12)
#define DEBUG_UART_TX_GPIO_FUNC (GPIO_FUNC_32)
#define DEBUG_UART_INT_EI (INT_SRC_USART1_EI)
#define DEBUG_UART_INT_EI_IRQ (INT000_IRQn)
#define DEBUG_UART_INT_RI (INT_SRC_USART1_RI)
#define DEBUG_UART_INT_RI_IRQ (INT001_IRQn)
typedef void (*hdl_debug_uart_rx_cb_t)(uint8_t data);
void hdl_debug_uart_init(void);
int hdl_debug_uart_getc(int *ch);
void hdl_debug_uart_putc(uint8_t ch);
void hdl_debug_uart_rx_reg(hdl_debug_uart_rx_cb_t pCBS);
#define COM_UART (CM_USART2)
#define COM_UART_CLK (FCG1_PERIPH_USART2)
#define COM_RX_PORT (GPIO_PORT_A)
#define COM_RX_PIN (GPIO_PIN_10)
#define COM_RX_GPIO_FUNC (GPIO_FUNC_37)
#define COM_TX_PORT (GPIO_PORT_A)
#define COM_TX_PIN (GPIO_PIN_08)
#define COM_TX_GPIO_FUNC (GPIO_FUNC_36)
#define COM_INT_EI (INT_SRC_USART2_EI)
#define COM_INT_EI_IRQ (INT011_IRQn)
#define COM_INT_RI (INT_SRC_USART2_RI)
#define COM_INT_RI_IRQ (INT012_IRQn)
typedef void (*com_rx_callback)(uint8_t data);
void hdl_com_uart_init(void);
void hdl_com_uart_rx_register(com_rx_callback pCBS);
void hdl_com_uart_send(uint8_t *w_buf,uint16_t len);
#endif
hdl/hdl_usb.c
+51
View File
@@ -0,0 +1,51 @@
#include "hdl_usb.h"
static void USB_IRQ_Handler(void)
{
extern void USBD_IRQHandler(uint8_t busid);
USBD_IRQHandler(0);
}
void hdl_usb_init(void)
{
stc_clock_pllx_init_t stcUpllInit;
stc_gpio_init_t stcGpioCfg;
stc_irq_signin_config_t stcIrqRegiConf;
LL_PERIPH_WE(LL_PERIPH_EFM | LL_PERIPH_FCG | LL_PERIPH_GPIO | LL_PERIPH_PWC_CLK_RMU | LL_PERIPH_SRAM);
/* 时钟配置 */
(void)CLK_PLLxStructInit(&stcUpllInit);
stcUpllInit.u8PLLState = CLK_PLLX_ON;
stcUpllInit.PLLCFGR = 0UL;
stcUpllInit.PLLCFGR_f.PLLM = (4UL - 1UL);
stcUpllInit.PLLCFGR_f.PLLN = (84UL - 1UL);
stcUpllInit.PLLCFGR_f.PLLR = (7UL - 1UL);
stcUpllInit.PLLCFGR_f.PLLQ = (7UL - 1UL);
stcUpllInit.PLLCFGR_f.PLLP = (7UL - 1UL); //48M
(void)CLK_PLLxInit(&stcUpllInit);
CLK_SetUSBClockSrc(CLK_USBCLK_PLLXP);
/* 引脚配置 */
(void)GPIO_StructInit(&stcGpioCfg);
stcGpioCfg.u16PinAttr = PIN_ATTR_ANALOG;
(void)GPIO_Init(USB_DM_PORT, USB_DM_PIN, &stcGpioCfg);
(void)GPIO_Init(USB_DP_PORT, USB_DP_PIN, &stcGpioCfg);
// GPIO_SetFunc(USB_DM_PORT, USB_DM_PIN, GPIO_FUNC_10);
// GPIO_SetFunc(USB_DP_PORT, USB_DP_PIN, GPIO_FUNC_10);
// GPIO_SetFunc(USB_VBUS_PORT, USB_VBUS_PIN, GPIO_FUNC_10); /* VBUS */
FCG_Fcg1PeriphClockCmd(FCG1_PERIPH_USBFS, ENABLE);
/* 中断配置 */
stcIrqRegiConf.enIRQn = INT030_IRQn;
stcIrqRegiConf.enIntSrc = INT_SRC_USBFS_GLB;
stcIrqRegiConf.pfnCallback = &USB_IRQ_Handler; // 添加中断函数
(void)INTC_IrqSignIn(&stcIrqRegiConf);
NVIC_ClearPendingIRQ(stcIrqRegiConf.enIRQn);
NVIC_SetPriority(stcIrqRegiConf.enIRQn, DDL_IRQ_PRIO_15);
NVIC_EnableIRQ(stcIrqRegiConf.enIRQn);
LL_PERIPH_WP(LL_PERIPH_EFM | LL_PERIPH_FCG | LL_PERIPH_SRAM);
}
hdl/hdl_usb.h
+18
View File
@@ -0,0 +1,18 @@
#ifndef ____HDL_USB_H_
#define ____HDL_USB_H_
#include "hc32_ll.h"
#include "hdl_clk.h"
#define USB_DP_PORT (GPIO_PORT_A)
#define USB_DP_PIN (GPIO_PIN_12)
#define USB_DM_PORT (GPIO_PORT_A)
#define USB_DM_PIN (GPIO_PIN_11)
#define USB_VBUS_PORT (GPIO_PORT_A)
#define USB_VBUS_PIN (GPIO_PIN_09)
#define USB_SOF_PORT (GPIO_PORT_A)
#define USB_SOF_PIN (GPIO_PIN_08)
void hdl_usb_init(void);
#endif