当前位置： 首页 > article >正文

STM32移植RT-Thread实现DAC功能

article 2024/11/19 16:37:48
在进行DAC的学习中，发现RT-Thread中没有该外设的驱动，因此需要自己进行相关配置

1.配置RT-Thread Setting中的DAC组件

在这里插入图片描述

2.在HAL库中完成DAC的配置(HAL库起到时钟的作用)

不懂HAL库配置的最好学一下HAL库的编程思想
在这里插入图片描述

3.在board.h中添加宏定义

我的RT-Thread中，没有DAC的宏定义，因此我就在末尾直接添加了一个：#define BSP_USING_DAC1
在这里插入图片描述

4.打开stm32f7xx_hal_config.h文件，接触DAC的注释

在这里插入图片描述

5.DAC驱动代码移植

<1>在/drivers/include/config文件夹下新建dac_config.h

#ifndef __DAC_CONFIG_H__
#define __DAC_CONFIG_H__

#include <rtthread.h>

#ifdef __cplusplus
extern "C" {
#endif

#ifdef BSP_USING_DAC1
#ifndef DAC1_CONFIG
#define DAC1_CONFIG                                                    \
    {                                                                  \
       .Instance                      = DAC1,                          \
    }
#endif /* DAC2_CONFIG */
#endif /* BSP_USING_DAC2 */

#ifdef BSP_USING_DAC2
#ifndef DAC2_CONFIG
#define DAC2_CONFIG                                                    \
    {                                                                  \
       .Instance                      = DAC2,                          \
    }
#endif /* DAC2_CONFIG */
#endif /* BSP_USING_DAC2 */

#ifdef __cplusplus
}
#endif

#endif /* __DAC_CONFIG_H__ */

<2>修改/drivers/include/drv_config.h
在STM32F1系列下增加#include “config/dac_config.h”，代码如下

#if defined(SOC_SERIES_STM32F0)
#include "config/dma_config.h"
#include "config/uart_config.h"
#include "config/spi_config.h"
#include "config/tim_config.h"
#include "config/pwm_config.h"
#include "config/adc_config.h"
#elif defined(SOC_SERIES_STM32F1)
#include "config/dac_config.h" //新增
#include "config/dma_config.h"
#include "config/uart_config.h"
#include "config/spi_config.h"
#include "config/adc_config.h"
#include "config/tim_config.h"
#include "config/sdio_config.h"
#include "config/pwm_config.h"
#include "config/usbd_config.h"
#include "config/pulse_encoder_config.h"

<3>在drivers文件夹下新建drv_dac.c

/*
 * Copyright (c) 2006-2021, RT-Thread Development Team
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date           Author            Notes
 * 2020-06-18     thread-liu        the first version
 * 2020-10-09     thread-liu   Porting for stm32h7xx
 */

#include <board.h>
#include<rtthread.h>
#include<rtdevice.h>

#if defined(BSP_USING_DAC1) || defined(BSP_USING_DAC2)
#include "drv_config.h"

//#define DRV_DEBUG
#define LOG_TAG             "drv.dac"
#include <drv_log.h>

static DAC_HandleTypeDef dac_config[] =
{
#ifdef BSP_USING_DAC1
    DAC1_CONFIG,
#endif

#ifdef BSP_USING_DAC2
    DAC2_CONFIG,
#endif
};

struct stm32_dac
{
    DAC_HandleTypeDef DAC_Handler;
    struct rt_dac_device stm32_dac_device;
};

static struct stm32_dac stm32_dac_obj[sizeof(dac_config) / sizeof(dac_config[0])];

static rt_uint32_t stm32_dac_get_channel(rt_uint32_t channel)
{
    rt_uint32_t stm32_channel = 0;

    switch (channel)
    {
    case  1:
        stm32_channel = DAC_CHANNEL_1;
        break;
    case  2:
        stm32_channel = DAC_CHANNEL_2;
        break;
    default:
        RT_ASSERT(0);
        break;
    }

    return stm32_channel;
}

static rt_err_t stm32_dac_enabled(struct rt_dac_device *device, rt_uint32_t channel)
{
    uint32_t dac_channel;
    DAC_HandleTypeDef *stm32_dac_handler;
    RT_ASSERT(device != RT_NULL);
    stm32_dac_handler = device->parent.user_data;

#if 1
    if ((channel <= 2) && (channel > 0))
    {
        /* set stm32 dac channel */
        dac_channel =  stm32_dac_get_channel(channel);
    }
    else
    {
      LOG_E("dac channel must be 1 or 2.");
      return -RT_ERROR;
    }
    HAL_DAC_Start(stm32_dac_handler, dac_channel);
#endif

    return RT_EOK;
}

static rt_err_t stm32_dac_disabled(struct rt_dac_device *device, rt_uint32_t channel)
{
    uint32_t dac_channel;
    DAC_HandleTypeDef *stm32_dac_handler;
    RT_ASSERT(device != RT_NULL);
    stm32_dac_handler = device->parent.user_data;

#if 1
    if ((channel <= 2) && (channel > 0))
    {
        /* set stm32 dac channel */
        dac_channel =  stm32_dac_get_channel(channel);
    }
    else
    {
      LOG_E("dac channel must be 1 or 2.");
      return -RT_ERROR;
    }
    HAL_DAC_Stop(stm32_dac_handler, dac_channel);
#endif

    return RT_EOK;
}

static rt_err_t stm32_set_dac_value(struct rt_dac_device *device, rt_uint32_t channel, rt_uint32_t *value)
{
    uint32_t dac_channel;
    DAC_ChannelConfTypeDef DAC_ChanConf;
    DAC_HandleTypeDef *stm32_dac_handler;

    RT_ASSERT(device != RT_NULL);
    RT_ASSERT(value != RT_NULL);

    stm32_dac_handler = device->parent.user_data;

    rt_memset(&DAC_ChanConf, 0, sizeof(DAC_ChanConf));

#if 1
    if ((channel <= 2) && (channel > 0))
    {
        /* set stm32 dac channel */
        dac_channel =  stm32_dac_get_channel(channel);
    }
    else
    {
      LOG_E("dac channel must be 1 or 2.");
      return -RT_ERROR;
    }
#endif

#if 1
    DAC_ChanConf.DAC_Trigger      = DAC_TRIGGER_NONE;
    DAC_ChanConf.DAC_OutputBuffer = DAC_OUTPUTBUFFER_DISABLE;
#endif
    /* config dac out channel*/
    if (HAL_DAC_ConfigChannel(stm32_dac_handler, &DAC_ChanConf, dac_channel) != HAL_OK)
    {
        LOG_D("Config dac out channel Error!\n");
        return -RT_ERROR;
    }
    /* set dac channel out value*/
    if (HAL_DAC_SetValue(stm32_dac_handler, dac_channel, DAC_ALIGN_12B_R, *value) != HAL_OK)
    {
        LOG_D("Setting dac channel out value Error!\n");
        return -RT_ERROR;
    }
    /* start dac */
    if (HAL_DAC_Start(stm32_dac_handler, dac_channel) != HAL_OK)
    {
        LOG_D("Start dac Error!\n");
        return -RT_ERROR;
    }

    return RT_EOK;
}

static const struct rt_dac_ops stm_dac_ops =
{
    .disabled = stm32_dac_disabled,
    .enabled  = stm32_dac_enabled,
    .convert  = stm32_set_dac_value,
};

static int stm32_dac_init(void)
{
    int result = RT_EOK;
    /* save dac name */
    char name_buf[5] = {'d', 'a', 'c', '0', 0};
    int i = 0;

    for (i = 0; i < sizeof(dac_config) / sizeof(dac_config[0]); i++)
    {
        /* dac init */
        name_buf[3] = '0';
        stm32_dac_obj[i].DAC_Handler = dac_config[i];
#if defined(DAC1)
        if (stm32_dac_obj[i].DAC_Handler.Instance == DAC1)
        {
            name_buf[3] = '1';
        }
#endif
#if defined(DAC2)
        if (stm32_dac_obj[i].dac_Handler.Instance == DAC2)
        {
            name_buf[3] = '2';
        }
#endif
        if (HAL_DAC_Init(&stm32_dac_obj[i].DAC_Handler) != HAL_OK)
        {
            LOG_E("%s init failed", name_buf);
            result = -RT_ERROR;
        }
        else
        {
            /* register dac device */
            if (rt_hw_dac_register(&stm32_dac_obj[i].stm32_dac_device, name_buf, &stm_dac_ops, &stm32_dac_obj[i].DAC_Handler) == RT_EOK)
            {
                LOG_D("%s init success", name_buf);
            }
            else
            {
                LOG_E("%s register failed", name_buf);
                result = -RT_ERROR;
            }
        }
    }

    return result;
}
INIT_DEVICE_EXPORT(stm32_dac_init);

#endif /* BSP_USING_DAC */

运行代码

#include <rtthread.h>
#include <rtdevice.h>
#include <board.h>

#define DAC_DEV_NAME        "dac1"  /* DAC 设备名称 */
#define DAC_DEV_CHANNEL     1       /* DAC 通道 */
rt_dac_device_t dac_dev;
#define REFER_VOLTAGE       330         /* 参考电压 3.3V,数据精度乘以100保留2位小数*/
#define CONVERT_BITS        (1 << 12)   /* 转换位数为12位 */

void dac_set_vol(rt_uint32_t vol)//1000->1V
{
    rt_uint32_t value;
    double temp=vol;
    temp=temp/1000;
    temp=temp*4095/3.3;
    value=temp;
    rt_dac_write(dac_dev, DAC_DEV_CHANNEL, vol);
}

int main(void)
{
    rt_err_t ret = RT_EOK;

    /* 查找设备 */
    dac_dev = (rt_dac_device_t)rt_device_find(DAC_DEV_NAME);
    if (dac_dev == RT_NULL)
    {
        rt_kprintf("dac sample run failed! can't find %s device!\n", DAC_DEV_NAME);
        return RT_ERROR;
    }

    //使能设备
    ret = rt_dac_enable(dac_dev, DAC_DEV_CHANNEL);

    //设置输出值
    dac_set_vol(300);

    //关闭通道  这里的disable也关闭了，貌似用不了，是不是可以用HAL库的呢？
    //ret = rt_dac_disable(dac_dev, DAC_DEV_CHANNEL);

    return ret;
}
最后

RT-Thread中存在着部分外设没有驱动程序需要我们自己去移植，或者使用HAL库的编程思想去实现


http://www.kler.cn/a/325912.html

相关文章：

  • 一文说清：c++标准库
  • 【分布式技术】分布式缓存技术-旁路缓存模式(Cache Aside Pattern)
  • Qt 之 qwt和QCustomplot对比
  • Gin 框架入门（GO）-1
  • python语言基础-5 进阶语法-5.2 装饰器-5.2.2 简单装饰器
  • sql中的聚合函数
  • Go版数据结构 -【4.1 二叉树】
  • 1688商品API接口：电商数据自动化的新引擎
  • JVM 几种经典的垃圾收集器
  • 解决跨域问题的方法
  • Linux 网络配置 （深入理解）
  • 初识C语言(四)
  • Llama 3.2——同时具备文本和图像处理功能的开源模型
  • 助力降本增效，ByteHouse打造新一代云原生数据仓库
  • 物联网（一）——CMC特刊推荐
  • 使用电子模拟器 Wokwi 运行 ESP32 示例（Arduino IDE、VSCode、ESP32C3）
  • 微信小程序如何使用自定义的字体
  • 产品管理- 互联网产品（5）：运营知识与技能
  • OceanBase技术解析： 执行器中的自适应技术
  • 地图资源下载工具（geodatatool）下载 亚洲 8 米 DEM数据
  • IM开发首选：WebSocket实现分频道广播的设计思路和实现难点分析
  • 如何培养稀缺的创新能力
  • 5.模拟电子技术笔记——放大电路的分析方法
  • 【5米光学卫星（资源一号02D/02E卫星）】
  • PHP常用缓存技术
  • 【xilinx-versal】【Petalinux】创建Petalinux工程