HC32L17x的LL驱动库之dma

最新推荐文章于 2025-03-27 22:46:20 发布
最新推荐文章于 2025-03-27 22:46:20 发布
阅读量319 收藏 1
点赞数
分类专栏： HC32L17x 文章标签： c语言 单片机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Haiguozhe/article/details/129230689
版权 
#include "hc32l1xx_ll_dma.h"

///
//函        数:
//功        能:
//输入参数:
//输出参数:
//说        明:
//
uint8_t LL_DMA_DeInit(DMA_TypeDef* DMAx, uint32_t Channel)
{
    __IO uint32_t* dmac = NULL;
    dmac = &(DMAx->CONFA0);
    Channel <<= 4;
    dmac += Channel;
    WRITE_REG((*dmac), 0);

    dmac = &(DMAx->CONFB0);
    dmac += Channel;
    WRITE_REG((*dmac), 0);
    return 0;
}

///
//函        数:
//功        能:
//输入参数:
//输出参数:
//说        明:
//
uint8_t LL_DMA_Init(DMA_TypeDef* DMAx, uint32_t Channel, LL_DMA_InitTypeDef* DMA_InitStruct)
{
    //---设置优先级
    LL_DMA_SetPrority(DMAx, DMA_InitStruct->Prority);
    //---配置触发请求
    LL_DMA_SetTrigSource(DMAx, Channel, DMA_InitStruct->PeriphRequest);
    //---设置数据块大小
    LL_DMA_SetDataBlockSize(DMAx, Channel, DMA_InitStruct->DataSize);
    //---计算数块个数
    DMA_InitStruct->PeriphRequest = DMA_InitStruct->NbData / DMA_InitStruct->DataSize;
    DMA_InitStruct->NbData = DMA_InitStruct->PeriphRequest;
    //---判断是否有数据
    if ((DMA_InitStruct->NbData % DMA_InitStruct->DataSize)!=0)
    {
        DMA_InitStruct->NbData +=1;
    }
    LL_DMA_SetDataBlockNum(DMAx, Channel, DMA_InitStruct->NbData);
    //---设置传输模式
    LL_DMA_SetTransferMode(DMAx, Channel, DMA_InitStruct->Mode);
    //---设置数据位宽
    LL_DMA_SetDataWidth(DMAx, Channel, DMA_InitStruct->DataWidth);
    //---设置DMA源地址自增模式
    LL_DMA_SetSourceAddrIncreaseMode(DMAx, Channel, DMA_InitStruct->PeriphOrM2MSrcIncMode);
    //---设置DMA目的地址自增模式
    LL_DMA_SetDestinateAddrIncreaseMode(DMAx, Channel, DMA_InitStruct->MemoryOrM2MDstIncMode);
    //---设置DMA源地址自动重载
    LL_DMA_EnableSourceAddrReload(DMAx, Channel);
    //---设置DMA目的地址自动重载
    LL_DMA_EnableDestinateAddrReload(DMAx, Channel);
    //---禁用DMA传输完成配置
    LL_DMA_SetChannelMode(DMAx, Channel,LL_DMA_CHANNEL_SINGLE);
    //---设置源地址
    LL_DMA_SetSourceAddr(DMAx, Channel, DMA_InitStruct->PeriphOrM2MSrcAddress);
    //---设置目的地址
    LL_DMA_SetDestinateAddr(DMAx, Channel, DMA_InitStruct->MemoryOrM2MDstAddress);
    return 0;
}
#ifndef HC32L1XX_LL_DMA_H_
#define HC32L1XX_LL_DMA_H_

#ifdef __cplusplus
extern "C" {
#endif 
    
    #include "hc32l1xx.h"
    ///
    #define LL_DMA_CHANNEL_0                    0
    #define LL_DMA_CHANNEL_1                    1

    #define LL_DMA_PRIO_FIXED                    DMA_CONF_PRIO_FIXED    
    #define LL_DMA_PRIO_CIRCLE                    DMA_CONF_PRIO_CIRCLE

    #define    LL_DMA_HALT_ALL                        DMA_CONF_HALT_ALL
    #define    LL_DMA_HALT_CH0S                    DMA_CONF_HALT_CH0S
    #define    LL_DMA_HALT_CH0D                    DMA_CONF_HALT_CH0D
    #define    LL_DMA_HALT_CH1S                    DMA_CONF_HALT_CH1S
    #define    LL_DMA_HALT_CH1D                    DMA_CONF_HALT_CH1D
    #define    LL_DMA_HALT_NULL                    DMA_CONF_HALT_NULL

    #define LL_DMA_TRIGS_SOFTWARE                DMA_CONFA_TRIGS_SOFTWARE        
    #define LL_DMA_TRIGS_RX_SPI0                DMA_CONFA_TRIGS_RX_SPI0            
    #define LL_DMA_TRIGS_TX_SPI0                DMA_CONFA_TRIGS_TX_SPI0            
    #define LL_DMA_TRIGS_RX_SPI1                DMA_CONFA_TRIGS_RX_SPI1            
    #define LL_DMA_TRIGS_TX_SPI1                DMA_CONFA_TRIGS_TX_SPI1            
    #define LL_DMA_TRIGS_SQR_ADC                DMA_CONFA_TRIGS_SQR_ADC            
    #define LL_DMA_TRIGS_JQR_ADC                DMA_CONFA_TRIGS_JQR_ADC            
    #define LL_DMA_TRIGS_LCD                    DMA_CONFA_TRIGS_LCD                
    #define LL_DMA_TRIGS_RX_UART0                DMA_CONFA_TRIGS_RX_UART0        
    #define LL_DMA_TRIGS_TX_UART0                DMA_CONFA_TRIGS_TX_UART0        
    #define LL_DMA_TRIGS_RX_UART1                DMA_CONFA_TRIGS_RX_UART1        
    #define LL_DMA_TRIGS_TX_UART1                DMA_CONFA_TRIGS_TX_UART1        
    #define LL_DMA_TRIGS_RX_LPUART0                DMA_CONFA_TRIGS_RX_LPUART0        
    #define LL_DMA_TRIGS_TX_LPUART0                DMA_CONFA_TRIGS_TX_LPUART0        
    #define LL_DMA_TRIGS_RX_LPUART1                DMA_CONFA_TRIGS_RX_LPUART1        
    #define LL_DMA_TRIGS_TX_LPUART1                DMA_CONFA_TRIGS_TX_LPUART1        
    #define LL_DMA_TRIGS_DAC                    DMA_CONFA_TRIGS_DAC                
    #define LL_DMA_TRIGS_CAPTURE_CHA_TIM0        DMA_CONFA_TRIGS_CAPTURE_CHA_TIM0
    #define LL_DMA_TRIGS_CAPTURE_CHB_TIM0        DMA_CONFA_TRIGS_CAPTURE_CHB_TIM0  
    #define LL_DMA_TRIGS_CAPTURE_CHA_TIM1        DMA_CONFA_TRIGS_CAPTURE_CHA_TIM1
    #define LL_DMA_TRIGS_CAPTURE_CHB_TIM1        DMA_CONFA_TRIGS_CAPTURE_CHB_TIM1
    #define LL_DMA_TRIGS_CAPTURE_CHA_TIM2        DMA_CONFA_TRIGS_CAPTURE_CHA_TIM2
    #define LL_DMA_TRIGS_CAPTURE_CHB_TIM2        DMA_CONFA_TRIGS_CAPTURE_CHB_TIM2
    #define LL_DMA_TRIGS_CAPTURE_CHA_TIM3        DMA_CONFA_TRIGS_CAPTURE_CHA_TIM3
    #define LL_DMA_TRIGS_CAPTURE_CHB_TIM3        DMA_CONFA_TRIGS_CAPTURE_CHB_TIM3
    #define LL_DMA_TRIGS_CAPTURE_CHA_TIM4        DMA_CONFA_TRIGS_CAPTURE_CHA_TIM4
    #define LL_DMA_TRIGS_CAPTURE_CHB_TIM4        DMA_CONFA_TRIGS_CAPTURE_CHB_TIM4
    #define LL_DMA_TRIGS_CAPTURE_CHA_TIM5        DMA_CONFA_TRIGS_CAPTURE_CHA_TIM5
    #define LL_DMA_TRIGS_CAPTURE_CHB_TIM5        DMA_CONFA_TRIGS_CAPTURE_CHB_TIM5
    #define LL_DMA_TRIGS_CAPTURE_CHA_TIM6        DMA_CONFA_TRIGS_CAPTURE_CHA_TIM6
    #define LL_DMA_TRIGS_CAPTURE_CHB_TIM6        DMA_CONFA_TRIGS_CAPTURE_CHB_TIM6
    #define LL_DMA_TRIGS_RX_UART2                DMA_CONFA_TRIGS_RX_UART2        
    #define LL_DMA_TRIGS_TX_UART2                DMA_CONFA_TRIGS_TX_UART2        
    #define LL_DMA_TRIGS_RX_UART3                DMA_CONFA_TRIGS_RX_UART3        
    #define LL_DMA_TRIGS_TX_UART3                DMA_CONFA_TRIGS_TX_UART3        

    #define LL_DMA_DATA_BLOCK_SIZE_1            1
    #define LL_DMA_DATA_BLOCK_SIZE_2            2
    #define LL_DMA_DATA_BLOCK_SIZE_3            3
    #define LL_DMA_DATA_BLOCK_SIZE_4            4
    #define LL_DMA_DATA_BLOCK_SIZE_5            5
    #define LL_DMA_DATA_BLOCK_SIZE_6            6
    #define LL_DMA_DATA_BLOCK_SIZE_7            7
    #define LL_DMA_DATA_BLOCK_SIZE_8            8
    #define LL_DMA_DATA_BLOCK_SIZE_9            9
    #define LL_DMA_DATA_BLOCK_SIZE_10            10
    #define LL_DMA_DATA_BLOCK_SIZE_11            11
    #define LL_DMA_DATA_BLOCK_SIZE_12            12
    #define LL_DMA_DATA_BLOCK_SIZE_13            13
    #define LL_DMA_DATA_BLOCK_SIZE_14            14
    #define LL_DMA_DATA_BLOCK_SIZE_15            15
    #define LL_DMA_DATA_BLOCK_SIZE_16            16

    #define LL_DMA_MODE_BLOCK                    DMA_CONFB_MODE_BLOCK
    #define LL_DMA_MODE_BURST                    DMA_CONFB_MODE_BURST

    #define LL_DMA_DATA_WIDTH_8BITS                DMA_CONFB_WIDTH_8BITS
    #define LL_DMA_DATA_WIDTH_16BITS            DMA_CONFB_WIDTH_16BITS
    #define LL_DMA_DATA_WIDTH_32BITS            DMA_CONFB_WIDTH_32BITS

    #define LL_DMA_DATA_ADDR_INCREASE            0
    #define LL_DMA_DATA_ADDR_FIXED                1

    #define LL_DMA_CHANNEL_SINGLE                DMA_CONFB_MSK_SINGLE    
    #define LL_DMA_CHANNEL_CONTINUOUS            DMA_CONFB_MSK_CONTINUOUS

    #define LL_DMA_STATE_INIT                    DMA_CONFB_STATE_INIT
    #define LL_DMA_STATE_ADDR                    DMA_CONFB_STATE_ADDR
    #define LL_DMA_STATE_DMA                    DMA_CONFB_STATE_DMA
    #define LL_DMA_STATE_SRC                    DMA_CONFB_STATE_SRC
    #define LL_DMA_STATE_DST                    DMA_CONFB_STATE_DST
    #define LL_DMA_STATE_FIS                    DMA_CONFB_STATE_FIS
    #define LL_DMA_STATE_SUSPEND                DMA_CONFB_STATE_SUSPEND

    ///
    //函        数: 
    //功        能: 
    //输入参    数: 
    //输出参    数: 
    //说        明: 
    //
    static inline void LL_DMA_Enable(DMA_TypeDef* DMAx)
    {
        SET_BIT(DMAx->CONF, DMA_CONF_EN);
    }

    ///
    //函        数: 
    //功        能: 
    //输入参    数: 
    //输出参    数: 
    //说        明: 
    //
    static inline void LL_DMA_Disable(DMA_TypeDef* DMAx)
    {
        CLEAR_BIT(DMAx->CONF, DMA_CONF_EN);
    }

    ///
    //函        数: 
    //功        能: 
    //输入参    数: 
    //输出参    数: 
    //说        明: 
    //
    static inline uint32_t LL_DMA_IsEnabled(DMA_TypeDef* DMAx)
    {
        return (uint32_t)(READ_BIT(DMAx->CONF, DMA_CONF_EN) == DMA_CONF_EN);
    }

    ///
    //函        数: 
    //功        能: 设置优先级
    //输入参    数: 
    //输出参    数: 
    //说        明: 
    //
    static inline void LL_DMA_SetPrority(DMA_TypeDef* DMAx,uint32_t priority)
    {
        MODIFY_REG(DMAx->CONF, DMA_CONF_PRIO, priority);
    }

    ///
    //函        数: 
    //功        能: 获取优先级
    //输入参    数: 
    //输出参    数: 
    //说        明: 
    //
    static inline uint32_t LL_DMA_GetPrority(DMA_TypeDef* DMAx)
    {
        return (uint32_t)(READ_BIT(DMAx->CONF, DMA_CONF_EN)& DMA_CONF_PRIO);
    }


    ///
    //函        数: 
    //功        能: 暂停
    //输入参    数: 
    //输出参    数: 
    //说        明: 
    //
    static inline void LL_DMA_Suspend(DMA_TypeDef* DMAx, uint32_t halt)
    {
        MODIFY_REG(DMAx->CONF, DMA_CONF_HALT, halt);
    }

    ///
    //函        数: 
    //功        能: 
    //输入参    数: 
    //输出参    数: 
    //说        明: 
    //
    static inline void LL_DMA_Resume(DMA_TypeDef* DMAx, uint32_t halt)
    {
        MODIFY_REG(DMAx->CONF, DMA_CONF_HALT, ~halt);
    }

    ///
    //函        数: 
    //功        能: 
    //输入参    数: 
    //输出参    数: 
    //说        明: 
    //
    static inline void LL_DMA_EnableChannel(DMA_TypeDef* DMAx, uint32_t ch)
    {
        __IO uint32_t* dmac = NULL;
        dmac = &(DMAx->CONFA0);
        dmac += (ch << 4);
        SET_BIT((*dmac), DMA_CONFA_ENS);
    }

    ///
    //函        数: 
    //功        能: 
    //输入参    数: 
    //输出参    数: 
    //说        明: 
    //
    static inline void LL_DMA_DisableChannel(DMA_TypeDef* DMAx, uint32_t ch)
    {
        __IO uint32_t* dmac = NULL;
        dmac = &(DMAx->CONFA0);
        dmac += (ch << 4);
        CLEAR_BIT(DMAx->CONF, DMA_CONFA_ENS);
    }

    ///
    //函        数: 
    //功        能: 
    //输入参    数: 
    //输出参    数: 
    //说        明: 
    //
    static inline uint32_t LL_DMA_IsEnabled_Channel(DMA_TypeDef* DMAx, uint32_t ch)
    {
        __IO uint32_t* dmac = NULL;
        dmac = &(DMAx->CONFA0);
        dmac += (ch << 4);
        return (uint32_t)(READ_BIT(DMAx->CONF, DMA_CONFA_ENS) == DMA_CONFA_ENS);
    }

    ///
    //函        数: 
    //功        能: 暂停
    //输入参    数: 
    //输出参    数: 
    //说        明: 
    //
    static inline void LL_DMA_SuspendChannel(DMA_TypeDef* DMAx, uint32_t ch)
    {
        __IO uint32_t* dmac = NULL;
        dmac = &(DMAx->CONFA0);
        dmac += (ch<<4);
        SET_BIT((*dmac), DMA_CONFA_PAS);
    }

    ///
    //函        数: 
    //功        能: 恢复
    //输入参    数: 
    //输出参    数: 
    //说        明: 
    //
    static inline void LL_DMA_ResumeChannel(DMA_TypeDef* DMAx, uint32_t ch)
    {
        __IO uint32_t* dmac = NULL;
        dmac = &(DMAx->CONFA0);
        dmac += (ch << 4);
        CLEAR_BIT((*dmac), DMA_CONFA_PAS);
    }

    ///
    //函        数: 
    //功        能: 软件触发启动
    //输入参    数: 
    //输出参    数: 
    //说        明: 
    //
    static inline void LL_DMA_SoftwareStart(DMA_TypeDef* DMAx,uint32_t ch)
    {
        __IO uint32_t* dmac = NULL;
        dmac = &(DMAx->CONFA0);
        dmac += (ch << 4);
        SET_BIT((*dmac), DMA_CONFA_STS);
    }

    ///
    //函        数: 
    //功        能: 软件触发停止
    //输入参    数: 
    //输出参    数: 
    //说        明: 
    //
    static inline void LL_DMA_SoftwareStop(DMA_TypeDef* DMAx, uint32_t ch)
    {
        __IO uint32_t* dmac = NULL;
        dmac = &(DMAx->CONFA0);
        dmac += (ch << 4);
        CLEAR_BIT((*dmac), DMA_CONFA_STS);
    }

    ///
    //函        数: 
    //功        能: 设置触发源
    //输入参    数: 
    //输出参    数: 
    //说        明: 
    //
    static inline void LL_DMA_SetTrigSource(DMA_TypeDef* DMAx, uint32_t ch, uint32_t trig)
    {
        __IO uint32_t* dmac = NULL;
        dmac = &(DMAx->CONFA0);
        dmac += (ch << 4);
        MODIFY_REG((*dmac), DMA_CONFA_TRIGS, trig);
    }

    ///
    //函        数: 
    //功        能: 设置触发源
    //输入参    数: 
    //输出参    数: 
    //说        明: 
    //
    static inline uint32_t LL_DMA_GetTrigSource(DMA_TypeDef* DMAx,uint32_t ch, uint32_t trig)
    {
        __IO uint32_t* dmac = NULL;
        dmac = &(DMAx->CONFA0);
        dmac += (ch << 4);
        return (uint32_t)(READ_BIT((*dmac), DMA_CONFA_TRIGS) & trig);
    }

    ///
    //函        数: 
    //功        能: 设置触发源
    //输入参    数: 
    //输出参    数: 
    //说        明: 
    //
    static inline void LL_DMA_SetDataBlockSize(DMA_TypeDef* DMAx, uint32_t ch, uint32_t size)
    {
        __IO uint32_t* dmac = NULL;
        dmac = &(DMAx->CONFA0);
        dmac += (ch << 4);
        size -= 1;
        if (size>15)
        {
            size = 0;
        }
        size <<= DMA_CONFA_BCS_POS;
        MODIFY_REG((*dmac), DMA_CONFA_BCS, size);
    }

    ///
    //函        数: 
    //功        能: 设置触发源
    //输入参    数: 
    //输出参    数: 
    //说        明: 
    //
    static inline uint32_t LL_DMA_GetDataBlockSize(DMA_TypeDef* DMAx, uint32_t ch)
    {
        __IO uint32_t* dmac = NULL;
        dmac = &(DMAx->CONFA0);
        dmac += (ch << 4);
        return (uint32_t)(READ_BIT((*dmac), DMA_CONFA_BCS)>> DMA_CONFA_BCS_POS);
    }

    ///
    //函        数: 
    //功        能: 设置触发源
    //输入参    数: 
    //输出参    数: 
    //说        明: 
    //
    static inline void LL_DMA_SetDataBlockNum(DMA_TypeDef* DMAx, uint32_t ch, uint32_t num)
    {
        __IO uint32_t* dmac = NULL;
        dmac = &(DMAx->CONFA0);
        num -= 1;
        dmac += (ch << 4);
        MODIFY_REG((*dmac), DMA_CONFA_TCS, num);
    }

    ///
    //函        数: 
    //功        能: 设置触发源
    //输入参    数: 
    //输出参    数: 
    //说        明: 
    //
    static inline uint32_t LL_DMA_GetDataBlockNum(DMA_TypeDef* DMAx, uint32_t ch)
    {
        __IO uint32_t* dmac = NULL;
        dmac = &(DMAx->CONFA0);
        dmac += (ch << 4);
        return (uint32_t)(READ_BIT((*dmac), DMA_CONFA_TCS)>> DMA_CONFA_TCS_POS);
    }

    ///
    //函        数: 
    //功        能: 设置数据长度
    //输入参    数: 
    //输出参    数: 
    //说        明: 
    //
    static inline void LL_DMA_SetDataLength(DMA_TypeDef* DMAx, uint32_t ch, uint32_t length)
    {
        __IO uint32_t* dmac = NULL;
        uint32_t datablocksize = 0; 
        dmac = &(DMAx->CONFA0);
        dmac += (ch << 4);
        //---计算数据块的大小
        datablocksize= LL_DMA_GetDataBlockSize(DMAx,ch)+1;
        //---计算数据块
        ch = length / datablocksize;
        if ((length % datablocksize)!=0)
        {
            ch += 1;
        }
        ch -= 1;
        //---将数据写入
        MODIFY_REG((*dmac), DMA_CONFA_TCS, ch);
    }

    ///
    //函        数: 
    //功        能: 设置DMA工作模式
    //输入参    数: 
    //输出参    数: 
    //说        明: 
    //
    static inline void LL_DMA_SetTransferMode(DMA_TypeDef* DMAx, uint32_t ch, uint32_t mode)
    {
        __IO uint32_t* dmac = NULL;
        dmac = &(DMAx->CONFB0);
        dmac += (ch << 4);
        MODIFY_REG((*dmac), DMA_CONFB_MODE, mode);
    }

    ///
    //函        数: 
    //功        能: 获取DMA工作模式
    //输入参    数: 
    //输出参    数: 
    //说        明: 
    //
    static inline uint32_t LL_DMA_GetTransferMode(DMA_TypeDef* DMAx, uint32_t ch)
    {
        __IO uint32_t* dmac = NULL;
        dmac = &(DMAx->CONFB0);
        dmac += (ch << 4);
        return (uint32_t)(READ_BIT((*dmac), DMA_CONFB_MODE)& DMA_CONFB_MODE);
    }
    
    ///
    //函        数: 
    //功        能: 设置数据宽度
    //输入参    数: 
    //输出参    数: 
    //说        明: 
    //
    static inline void LL_DMA_SetDataWidth(DMA_TypeDef* DMAx, uint32_t ch, uint32_t width)
    {
        __IO uint32_t* dmac = NULL;
        dmac = &(DMAx->CONFB0);
        dmac += (ch << 4);
        MODIFY_REG((*dmac), DMA_CONFB_WIDTH, width);
    }

    ///
    //函        数: 
    //功        能: 获取数据宽度
    //输入参    数: 
    //输出参    数: 
    //说        明: 
    //
    static inline uint32_t LL_DMA_GetDataWidth(DMA_TypeDef* DMAx, uint32_t ch)
    {
        __IO uint32_t* dmac = NULL;
        dmac = &(DMAx->CONFB0);
        dmac += (ch << 4);
        return (uint32_t)(READ_BIT((*dmac), DMA_CONFB_WIDTH) >> DMA_CONFB_WIDTH_POS);
    }

    ///
    //函        数: 
    //功        能: 设置源地址自增模式
    //输入参    数: 
    //输出参    数: 
    //说        明: 
    //
    static inline void LL_DMA_SetSourceAddrIncreaseMode(DMA_TypeDef* DMAx, uint32_t ch, uint32_t mode)
    {
        __IO uint32_t* dmac = NULL;
        dmac = &(DMAx->CONFB0);
        dmac += (ch << 4);
        mode <<= DMA_CONFB_FS_POS;
        MODIFY_REG((*dmac), DMA_CONFB_FS, mode);
    }

    ///
    //函        数: 
    //功        能: 获取源地址自增模式
    //输入参    数: 
    //输出参    数: 
    //说        明: 
    //
    static inline uint32_t LL_DMA_GetSourceAddrIncreaseMode(DMA_TypeDef* DMAx, uint32_t ch)
    {
        __IO uint32_t* dmac = NULL;
        dmac = &(DMAx->CONFB0);
        dmac += (ch << 4);
        return (uint32_t)(READ_BIT((*dmac), DMA_CONFB_FS) >> DMA_CONFB_FS_POS);
    }

    ///
    //函        数: 
    //功        能: 设置目的地址自增模式
    //输入参    数: 
    //输出参    数: 
    //说        明: 
    //
    static inline void LL_DMA_SetDestinateAddrIncreaseMode(DMA_TypeDef* DMAx, uint32_t ch, uint32_t mode)
    {
        __IO uint32_t* dmac = NULL;
        dmac = &(DMAx->CONFB0);
        dmac += (ch << 4);
        mode <<= DMA_CONFB_FD_POS;
        MODIFY_REG((*dmac), DMA_CONFB_FD, mode);
    }

    ///
    //函        数: 
    //功        能: 获取目的地址自增模式
    //输入参    数: 
    //输出参    数: 
    //说        明: 
    //
    static inline uint32_t LL_DMA_GetDestinateAddrIncreaseMode(DMA_TypeDef* DMAx, uint32_t ch)
    {
        __IO uint32_t* dmac = NULL;
        dmac = &(DMAx->CONFB0);
        dmac += (ch << 4);
        return (uint32_t)(READ_BIT((*dmac), DMA_CONFB_FD) >> DMA_CONFB_FD_POS);
    }

    ///
    //函        数: 
    //功        能: 使能数据块和数据块数量自动重载
    //输入参    数: 
    //输出参    数: 
    //说        明: 
    //
    static inline void LL_DMA_EnableDataBlockReload(DMA_TypeDef* DMAx, uint32_t ch)
    {
        __IO uint32_t* dmac = NULL;
        dmac = &(DMAx->CONFB0);
        dmac += (ch << 4);
        SET_BIT((*dmac), DMA_CONFB_RC);
    }

    ///
    //函        数: 
    //功        能: 使能数据块和数据块数量自动重载
    //输入参    数: 
    //输出参    数: 
    //说        明: 
    //
    static inline void LL_DMA_DisableDataBlockReload(DMA_TypeDef* DMAx, uint32_t ch)
    {
        __IO uint32_t* dmac = NULL;
        dmac = &(DMAx->CONFB0);
        dmac += (ch << 4);
        CLEAR_BIT((*dmac), DMA_CONFB_RC);
    }

    ///
    //函        数: 
    //功        能: 使能源地址自动重载
    //输入参    数: 
    //输出参    数: 
    //说        明: 
    //
    static inline void LL_DMA_EnableSourceAddrReload(DMA_TypeDef* DMAx, uint32_t ch)
    {
        __IO uint32_t* dmac = NULL;
        dmac = &(DMAx->CONFB0);
        dmac += (ch << 4);
        SET_BIT((*dmac), DMA_CONFB_RS);
    }

    ///
    //函        数: 
    //功        能: 不使能源地址自动重载
    //输入参    数: 
    //输出参    数: 
    //说        明: 
    //
    static inline void LL_DMA_DisableSourceAddrReload(DMA_TypeDef* DMAx, uint32_t ch)
    {
        __IO uint32_t* dmac = NULL;
        dmac = &(DMAx->CONFB0);
        dmac += (ch << 4);
        CLEAR_BIT((*dmac), DMA_CONFB_RS);
    }

    ///
    //函        数: 
    //功        能: 使能目的地址自动重载
    //输入参    数: 
    //输出参    数: 
    //说        明: 
    //
    static inline void LL_DMA_EnableDestinateAddrReload(DMA_TypeDef* DMAx, uint32_t ch)
    {
        __IO uint32_t* dmac = NULL;
        dmac = &(DMAx->CONFB0);
        dmac += (ch << 4);
        SET_BIT((*dmac), DMA_CONFB_RD);
    }

    ///
    //函        数: 
    //功        能: 不使能目的地址自动重载
    //输入参    数: 
    //输出参    数: 
    //说        明: 
    //
    static inline void LL_DMA_DisableDestinateAddrReload(DMA_TypeDef* DMAx, uint32_t ch)
    {
        __IO uint32_t* dmac = NULL;
        dmac = &(DMAx->CONFB0);
        dmac += (ch << 4);
        CLEAR_BIT((*dmac), DMA_CONFB_RD);
    }

    ///
    //函        数: 
    //功        能: 使能错误中断
    //输入参    数: 
    //输出参    数: 
    //说        明: 
    //
    static inline void LL_DMA_EnabledIT_Error(DMA_TypeDef* DMAx, uint32_t ch)
    {
        __IO uint32_t* dmac = NULL;
        dmac = &(DMAx->CONFB0);
        dmac += (ch << 4);
        SET_BIT((*dmac), DMA_CONFB_ERR_IE);
    }

    ///
    //函        数: 
    //功        能: 不使能错误中断
    //输入参    数: 
    //输出参    数: 
    //说        明: 
    //
    static inline void LL_DMA_DisableIT_Error(DMA_TypeDef* DMAx, uint32_t ch)
    {
        __IO uint32_t* dmac = NULL;
        dmac = &(DMAx->CONFB0);
        dmac += (ch << 4);
        CLEAR_BIT((*dmac), DMA_CONFB_ERR_IE);
    }

    ///
    //函        数: 
    //功        能: 是否使能传输完成中断
    //输入参    数: 
    //输出参    数: 
    //说        明: 
    //
    static inline uint32_t LL_DMA_IsEnabled_IT_Error(DMA_TypeDef* DMAx, uint32_t ch)
    {
        __IO uint32_t* dmac = NULL;
        dmac = &(DMAx->CONFB0);
        dmac += (ch << 4);
        return (uint32_t)(READ_BIT((*dmac), DMA_CONFB_ERR_IE));
    }

    ///
    //函        数: 
    //功        能: 使能传输完成中断
    //输入参    数: 
    //输出参    数: 
    //说        明: 
    //
    static inline void LL_DMA_EnabledIT_Complete(DMA_TypeDef* DMAx, uint32_t ch)
    {
        __IO uint32_t* dmac = NULL;
        dmac = &(DMAx->CONFB0);
        dmac += (ch << 4);
        SET_BIT((*dmac), DMA_CONFB_FIS_IE);
    }
    
    ///
    //函        数: 
    //功        能: 不使能传输完成中断
    //输入参    数: 
    //输出参    数: 
    //说        明: 
    //
    static inline void LL_DMA_DisableIT_Complete(DMA_TypeDef* DMAx, uint32_t ch)
    {
        __IO uint32_t* dmac = NULL;
        dmac = &(DMAx->CONFB0);
        dmac += (ch << 4);
        CLEAR_BIT((*dmac), DMA_CONFB_FIS_IE);
    }

    ///
    //函        数: 
    //功        能: 是否使能传输完成中断
    //输入参    数: 
    //输出参    数: 
    //说        明: 
    //
    static inline uint32_t LL_DMA_IsEnabled_IT_Complete(DMA_TypeDef* DMAx, uint32_t ch)
    {
        __IO uint32_t* dmac = NULL;
        dmac = &(DMAx->CONFB0);
        dmac += (ch << 4);
        return (uint32_t)(READ_BIT((*dmac), DMA_CONFB_FIS_IE));
    }

    ///
    //函        数: 
    //功        能: 获取传输状态
    //输入参    数: 
    //输出参    数: 
    //说        明: 
    //
    static inline uint32_t LL_DMA_TransferState(DMA_TypeDef* DMAx, uint32_t ch)
    {
        __IO uint32_t* dmac = NULL;
        dmac = &(DMAx->CONFB0);
        dmac += (ch << 4);
        return (uint32_t)(READ_BIT((*dmac), DMA_CONFB_STATE));
    }

    ///
    //函        数：
    //功        能：中断标志
    //输入参    数：
    //输出参    数：
    //说        明：
    //
    static inline uint32_t LL_DMA_IsActiveFlag(DMA_TypeDef* DMAx, uint32_t ch)
    {
        __IO uint32_t* dmac = NULL;
        dmac = &(DMAx->CONFB0);
        dmac += (ch << 4);
        return (uint32_t)(READ_BIT((*dmac), DMA_CONFB_STATE));
    }

    ///
    //函        数：
    //功        能：中断标志
    //输入参    数：
    //输出参    数：
    //说        明：
    //
    static inline uint32_t LL_DMA_IsActiveFlag_Complete(DMA_TypeDef* DMAx, uint32_t ch)
    {
        __IO uint32_t* dmac = NULL;
        dmac = &(DMAx->CONFB0);
        dmac += (ch << 4);
        return (uint32_t)(READ_BIT((*dmac), DMA_CONFB_STATE)&LL_DMA_STATE_FIS);
    }

    ///
    //函        数：
    //功        能：清除中断标志
    //输入参    数：
    //输出参    数：
    //说        明：
    //
    static inline void LL_DMA_ClearFlag(DMA_TypeDef* DMAx, uint32_t ch)
    {
        __IO uint32_t* dmac = NULL;
        dmac = &(DMAx->CONFB0);
        dmac += (ch << 4);
        MODIFY_REG((*dmac), DMA_CONFB_STATE, 0);
    }

    ///
    //函        数: 
    //功        能: 设置DMA通道模式
    //输入参    数: 
    //输出参    数: 
    //说        明: 
    //
    static inline void LL_DMA_SetChannelMode(DMA_TypeDef* DMAx, uint32_t ch, uint32_t mode)
    {
        __IO uint32_t* dmac = NULL;
        dmac = &(DMAx->CONFB0);
        dmac += (ch << 4);
        MODIFY_REG((*dmac), DMA_CONFB_MSK, mode);
    }

    ///
    //函        数: 
    //功        能: 获取DMA通道模式
    //输入参    数: 
    //输出参    数: 
    //说        明: 
    //
    static inline uint32_t LL_DMA_GetChannelMode(DMA_TypeDef* DMAx, uint32_t ch)
    {
        __IO uint32_t* dmac = NULL;
        dmac = &(DMAx->CONFB0);
        dmac += (ch << 4);
        return (uint32_t)(READ_BIT((*dmac), DMA_CONFB_MSK) & DMA_CONFB_MSK);
    }

    ///
    //函        数: 
    //功        能: 设置源地址
    //输入参    数: 
    //输出参    数: 
    //说        明: 
    //
    static inline void LL_DMA_SetSourceAddr(DMA_TypeDef* DMAx, uint32_t ch,uint32_t addr)
    {
        __IO uint32_t* dmac = NULL;
        dmac = &(DMAx->SRCADR0);
        dmac += (ch << 4);
        WRITE_REG((*dmac), addr);
    }

    ///
    //函        数: 
    //功        能: 获取源地址
    //输入参    数: 
    //输出参    数: 
    //说        明: 
    //
    static inline uint32_t LL_DMA_GetSourceAddr(DMA_TypeDef* DMAx, uint32_t ch)
    {
        __IO uint32_t* dmac = NULL;
        dmac = &(DMAx->SRCADR0);
        dmac += (ch << 4);
        return READ_REG((*dmac))& DMA_SRC_ADDR;
    }

    ///
    //函        数: 
    //功        能: 使能目的地址自动重载
    //输入参    数: 
    //输出参    数: 
    //说        明: 
    //
    static inline void LL_DMA_SetDestinateAddr(DMA_TypeDef* DMAx, uint32_t ch, uint32_t addr)
    {
        __IO uint32_t* dmac = NULL;
        dmac = &(DMAx->DSTADR0);
        dmac += (ch << 4);
        WRITE_REG((*dmac),addr);
    }

    ///
    //函        数: 
    //功        能: 不使能目的地址自动重载
    //输入参    数: 
    //输出参    数: 
    //说        明: 
    //
    static inline uint32_t LL_DMA_GetDestinateAddr(DMA_TypeDef* DMAx, uint32_t ch)
    {
        __IO uint32_t* dmac = NULL;
        dmac = &(DMAx->DSTADR0);
        dmac += (ch << 4);
        return READ_REG((*dmac)) & DMA_DST_ADDR;
    }


    typedef struct
    {
        uint32_t Prority;
        uint32_t PeriphRequest;
        uint32_t DataSize;
        uint32_t NbData;
        
        uint32_t Mode; 
        uint32_t DataWidth;
        uint32_t PeriphOrM2MSrcIncMode;  
        uint32_t MemoryOrM2MDstIncMode;   
        uint32_t PeriphOrM2MSrcAddress;
        uint32_t MemoryOrM2MDstAddress;
    } LL_DMA_InitTypeDef;

    //===函数定义
    uint8_t LL_DMA_Init(DMA_TypeDef* DMAx, uint32_t Channel, LL_DMA_InitTypeDef* DMA_InitStruct);
    uint8_t LL_DMA_DeInit(DMA_TypeDef* DMAx, uint32_t Channel);

    ///
#ifdef __cplusplus
}
#endif 

#endif /* HC32L1XX_LL_DMA_H_ */

STM32H7xx 串口DMA发送&接收（LL库）
只要思想不滑坡，想法总比问题多。
06-04 9502
LL库下STM32H7 串口DMA收发实现
基于LL库STM32F103的串口DMA发送
Seamfox的博客
09-23 1468
什么意思呢，就是让DMA进中断的时候不要进行数据的拷贝，也就是传输完成的时候缓冲区中的数据不要有变化，否则会引起数据错乱，这点很关键，在开头引用的一篇文章中指出。注意DMA模式为normal，如果设置为连续模式则一旦开启DMA数据不断传输，如果想把DMA的数据拷贝到缓冲区时DMA传输是不会停止的，开启normal的好处是DMA每初始化一次开启一次，数据传输到串口时用户可以设置传输完成中断进行处理然后再开启DMA。CNDTR寄存器值变为了0，可知DMA发送区长度变为了0，即将缓冲区的数据全部发送到了串口。
STM32F103_LL库+寄存器学习笔记08 - DMA串口发送，开启DMA传输完成中断
最新发布
wallace89的博客
03-27 1073
DMA辅助USART发送与接收能够显著降低CPU负担，尤其在大数据量传输时优势明显。这样可以让CPU腾出更多资源去处理其他任务，同时利用DMA的并行传输能力提高数据传输效率。大概可以这样理解：STM32F1的CPU是一个核，DMA1是第二个核，DMA2是第三个核。掌握DMA的使用后，相当于你的STM32F1芯片从单核变成三核。虽然，DMA只能用于数据的搬运，但是一个计算机系统做的绝大部分的活不就是数据搬运吗？所以，DMA必须学会！必须学会！必须学会！
STM32 LL库 串口DMA发送接收配置教程
qq_40932099的博客
06-24 6532
STM32 LL库 DMA串口收发
华大MCU HC32L130(136)串口DMA接收+高级定时器实现空闲超时接收
04-07
使用华大MCU HC32L130(136)配置串口为DMA接收，通过高级定时器6实现超时空闲帧接收的方式，类似于STM32F103 串口DMA + 空闲中断 实现不定长数据收发。
STM32LL库系列教程【五】——DMA实现ADC单通道采集
m0_47329175的博客
12-07 8178
开发板：野火霸道V1 芯片：stm32f103ZET6 ADC：1 CHANNEL：11 GPIO：PC1 STM32LL库系列教程【一】——安装CubeMx软件 STM32LL库系列教程【二】——点亮LED小灯 STM32LL库系列教程【三】——ADC单通道采集 新建工程步骤 1、打开STM32CubeMx软件 2、选择芯片型号：stm32f103ZETx 3、配置工程属性 4、确认时钟源 5、配置系统时钟 6、打开ADC1的通道11 7、配置结构体 typedef struct { uin.
华大半导体HC32F17x-19x HC32L17x-19x HC32L072-073系列MCU芯片ALTIUM原理图库文件
04-06
华大半导体HC32F17x-19x HC32L17x-19x HC32L072-073系列MCU芯片ALTIUM原理图库文件： HC32F170-LQFP48 HC32F170-LQFP52 HC32F170-QNF32 HC32F170-QNF32_1 HC32F176-LQFP100 HC32F176-LQFP48 HC32F176-LQFP64 HC32...
国产MCU华大半导体HC32L17x系列单片机软硬件设计SDK资料包参考设计原理图应用笔记等资料.zip
11-11
国产MCU华大半导体HC32L17x系列单片机软硬件设计SDK资料包参考设计原理图应用笔记等资料: HC32L176_L170系列数据手册Rev1.3.pdf HC32L17X_L19X管脚功能查询及配置.xlsx HC32L17_L19_F17_F19系列勘误手册.pdf HC32L17...
HC32L(F)17(9)X系列的MCU开发工具用户手册V1.02
08-03
本手册详细介绍了适用于HC32L17x、HC32F17x、HC32L19x以及HC32F19x系列微控制器（MCU）的开发工具，旨在帮助开发者有效地进行程序设计和调试工作。手册覆盖了从基本概念到具体操作的各个环节，为不同经验水平的用户...
HC32L17X_L19X_F17X_F19X系列用户手册v1.11
08-03
本手册是华大半导体为开发者提供的关于HC32L17X、HC32L19X、HC32F17X和HC32F19X系列32位ARM Cortex-M0+微控制器的操作指南。这些微控制器以其超低功耗特性而设计，适用于需要高效能和节能的应用场景。 一、产品特性...
IAR环境下V01_hc32l17x_template【FreeRTOS裸机项目工程】.zip
08-17
5. `system_HC32L17x.c/h` - CMSIS（ Cortex Microcontroller Software Interface Standard）库提供的系统初始化函数。 6. `include`目录 - 包含所有必要的头文件，如芯片驱动、FreeRTOS API等。 7. `linker`或`.icf...
STM32F103的LL库串口1的DMA闲时中断接收+DMA发送数据例程
03-24
使用ST新库Low-layer(LL)开发的串口1的DMA闲时中断接收+DMA发送数据配置例程,主函数会一直usart1会500ms用普通方式按1字节1字节发送数据,当串口1接收到数据IDLE中断后,会用DMA方式将接收到数据发送出去,方便串口助手回环测试
STM32F407 标准库 实现6路串口配置，DMA发送，中断接收
04-12
STM32F407 标准库 实现6路串口配置，DMA发送，中断接收
Stm32f103 c8t6 uart DMA传送 最新固件 STM32Cube_FW_F1_V1.6.0
02-03
Stm32f103 c8t6 uart DMA传送 最新固件 STM32Cube_FW_F1_V1.6.0 测试通过，利用STM32CubeMX 配置硬件资源，非常适合 物联网开 单片机开发 参考
STM32 LL库 串口接收空闲中断接收数据
04-26
STM32 LL库 串口接收空闲中断接收数据 , STM32 cubemx生成工程
STM32LL库编程系列第三讲——USART+DMA通信
weixin_58172114的博客
04-27 1921
仅仅使用串口通信，会频繁进入中断，对CPU资源消耗大，于是使用DMA对数据进行“搬运”，减少对CPU的占用。本文是通过蓝牙模块接入UART5和USART1之间进行数通信，利用DMA搬运接收数据，也可以按照按照本文方式直接配置尾USART1接收和发送。本文逻辑清晰，内容详细，有大量解释语句，方便各位理解底层逻辑。
华大单片机HC32L130X
明哥的博客
08-09 2349
文章目录华大单片机HCL13X系列1.资料获取：2.学习思路：3.客观意见：4.预告5.推荐博客 华大单片机HCL13X系列 1.资料获取： （1）FTP服务器 （2）百度网盘 （3）交流群：164973950 2.学习思路： 看数据手册及用户手册，多跑demo！华大这种类型国产单片机，生态比ST还是差的不是一点半点，基本遇到问题都是靠自己解决，如果有代理商的话可以通过FAE支持解决。但我是比较喜欢自己能百度解决就绝不麻烦人家的。所以学起华大说实话还是比32更困难一点。 3.客观意见： 华大低功耗在同价格产
HC32L17x的LL驱动库之GPIO
childboy的博客
12-02 591
#define FLASH_BASE 0x00000000U #define FLASH_END 0x0001FFFFU #define FLASH_BANK1_END 0x0001FFFFU #define SRAM_BASE 0x20000000U #define SRAM_ENDsss 0x20003FFFU #define PERIPH_BASE
HC32L17x的LL驱动库之ADC
Haiguozhe的博客
10-28 556
#ifndef HC32L1XX_LL_ADC_H_ #define HC32L1XX_LL_ADC_H_ //////////////////////////////////////////////////////////////////////////////////////////// #ifdef __cplusplus extern "C" { #endif ///////////////////////////////////////////////////////////////////.
hc32l17x boot
09-10
HC32L17xx是华大智能运算芯片系列产品中的一员。它是一款高性能、低功耗的单片机集成电路，适用于各种消费电子、工控、仪器仪表、智能家居等领域的应用开发。 HC32L17xx的引导（boot）过程是指单片机在上电或复位后，执行一段特定的程序，用于初始化各个外设和寄存器，并加载用户程序或操作系统。在集成电路中，引导过程非常重要，它能确保系统正常启动并能够顺利执行用户的应用程序。 HC32L17xx的引导过程一般包括以下几个步骤： 1. 上电复位：当芯片上电或复位时，所有寄存器和外设都会被初始化，确保系统处于一个可控的初始状态。 2. 时钟配置：根据系统需求，需要设置CPU时钟和外设时钟的频率和工作模式。 3. 外设初始化：根据具体应用的需要，需要初始化各个外设，如GPIO、UART、SPI等。 4. 加载用户程序：当所有外设初始化完成后，可以将用户程序从外部存储器中加载到内部存储器，并跳转到用户程序的入口地址开始执行。 HC32L17xx提供了丰富的开发工具和参考资料，如集成开发环境、编译工具链、用户手册等，可以帮助开发者快速上手并进行应用开发。通过合理的引导和配置，可以充分发挥HC32L17xx的性能优势，实现各种功能需求，并确保系统的稳定性和可靠性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值