drv_dac.c 5.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230
  1. /*
  2. * Copyright (c) 2006-2023, RT-Thread Development Team
  3. *
  4. * SPDX-License-Identifier: Apache-2.0
  5. *
  6. * Change Logs:
  7. * Date Author Notes
  8. * 2020-06-18 thread-liu the first version
  9. * 2020-10-09 thread-liu Porting for stm32h7xx
  10. */
  11. #include <board.h>
  12. #include <rtthread.h>
  13. #if defined(BSP_USING_DAC1) || defined(BSP_USING_DAC2)
  14. #include "drv_config.h"
  15. //#define DRV_DEBUG
  16. #define LOG_TAG "drv.dac"
  17. #include <drv_log.h>
  18. static DAC_HandleTypeDef dac_config[] =
  19. {
  20. #ifdef BSP_USING_DAC1
  21. DAC1_CONFIG,
  22. #endif
  23. #ifdef BSP_USING_DAC2
  24. DAC2_CONFIG,
  25. #endif
  26. };
  27. struct stm32_dac
  28. {
  29. DAC_HandleTypeDef DAC_Handler;
  30. struct rt_dac_device stm32_dac_device;
  31. };
  32. static struct stm32_dac stm32_dac_obj[sizeof(dac_config) / sizeof(dac_config[0])];
  33. static rt_uint32_t stm32_dac_get_channel(rt_uint32_t channel)
  34. {
  35. rt_uint32_t stm32_channel = 0;
  36. switch (channel)
  37. {
  38. case 1:
  39. stm32_channel = DAC_CHANNEL_1;
  40. break;
  41. case 2:
  42. stm32_channel = DAC_CHANNEL_2;
  43. break;
  44. default:
  45. RT_ASSERT(0);
  46. break;
  47. }
  48. return stm32_channel;
  49. }
  50. static rt_err_t stm32_dac_enabled(struct rt_dac_device *device, rt_uint32_t channel)
  51. {
  52. uint32_t dac_channel;
  53. DAC_HandleTypeDef *stm32_dac_handler;
  54. RT_ASSERT(device != RT_NULL);
  55. stm32_dac_handler = device->parent.user_data;
  56. #if defined(SOC_SERIES_STM32MP1) || defined(SOC_SERIES_STM32H7) || defined(SOC_SERIES_STM32L4) || defined(SOC_SERIES_STM32F4)
  57. if ((channel <= 2) && (channel > 0))
  58. {
  59. /* set stm32 dac channel */
  60. dac_channel = stm32_dac_get_channel(channel);
  61. }
  62. else
  63. {
  64. LOG_E("dac channel must be 1 or 2.");
  65. return -RT_ERROR;
  66. }
  67. HAL_DAC_Start(stm32_dac_handler, dac_channel);
  68. #endif
  69. return RT_EOK;
  70. }
  71. static rt_err_t stm32_dac_disabled(struct rt_dac_device *device, rt_uint32_t channel)
  72. {
  73. uint32_t dac_channel;
  74. DAC_HandleTypeDef *stm32_dac_handler;
  75. RT_ASSERT(device != RT_NULL);
  76. stm32_dac_handler = device->parent.user_data;
  77. #if defined(SOC_SERIES_STM32MP1) || defined(SOC_SERIES_STM32H7) || defined(SOC_SERIES_STM32L4) || defined(SOC_SERIES_STM32F4)
  78. if ((channel <= 2) && (channel > 0))
  79. {
  80. /* set stm32 dac channel */
  81. dac_channel = stm32_dac_get_channel(channel);
  82. }
  83. else
  84. {
  85. LOG_E("dac channel must be 1 or 2.");
  86. return -RT_ERROR;
  87. }
  88. HAL_DAC_Stop(stm32_dac_handler, dac_channel);
  89. #endif
  90. return RT_EOK;
  91. }
  92. static rt_uint8_t stm32_dac_get_resolution(struct rt_dac_device *device)
  93. {
  94. DAC_HandleTypeDef *stm32_dac_handler;
  95. RT_ASSERT(device != RT_NULL);
  96. stm32_dac_handler = device->parent.user_data;
  97. (void)stm32_dac_handler;
  98. /* Only has supported DAC_ALIGN_12B_R, so it will return 12 bits */
  99. return 12;
  100. }
  101. static rt_err_t stm32_set_dac_value(struct rt_dac_device *device, rt_uint32_t channel, rt_uint32_t *value)
  102. {
  103. uint32_t dac_channel;
  104. DAC_ChannelConfTypeDef DAC_ChanConf;
  105. DAC_HandleTypeDef *stm32_dac_handler;
  106. RT_ASSERT(device != RT_NULL);
  107. RT_ASSERT(value != RT_NULL);
  108. stm32_dac_handler = device->parent.user_data;
  109. rt_memset(&DAC_ChanConf, 0, sizeof(DAC_ChanConf));
  110. #if defined(SOC_SERIES_STM32MP1) || defined(SOC_SERIES_STM32H7) || defined(SOC_SERIES_STM32L4) || defined(SOC_SERIES_STM32F4)
  111. if ((channel <= 2) && (channel > 0))
  112. {
  113. /* set stm32 dac channel */
  114. dac_channel = stm32_dac_get_channel(channel);
  115. }
  116. else
  117. {
  118. LOG_E("dac channel must be 1 or 2.");
  119. return -RT_ERROR;
  120. }
  121. #endif
  122. #if defined(SOC_SERIES_STM32MP1) || defined(SOC_SERIES_STM32H7) || defined(SOC_SERIES_STM32L4) || defined(SOC_SERIES_STM32F4)
  123. DAC_ChanConf.DAC_Trigger = DAC_TRIGGER_NONE;
  124. DAC_ChanConf.DAC_OutputBuffer = DAC_OUTPUTBUFFER_DISABLE;
  125. #endif
  126. /* config dac out channel*/
  127. if (HAL_DAC_ConfigChannel(stm32_dac_handler, &DAC_ChanConf, dac_channel) != HAL_OK)
  128. {
  129. LOG_D("Config dac out channel Error!\n");
  130. return -RT_ERROR;
  131. }
  132. /* set dac channel out value*/
  133. if (HAL_DAC_SetValue(stm32_dac_handler, dac_channel, DAC_ALIGN_12B_R, *value) != HAL_OK)
  134. {
  135. LOG_D("Setting dac channel out value Error!\n");
  136. return -RT_ERROR;
  137. }
  138. /* start dac */
  139. if (HAL_DAC_Start(stm32_dac_handler, dac_channel) != HAL_OK)
  140. {
  141. LOG_D("Start dac Error!\n");
  142. return -RT_ERROR;
  143. }
  144. return RT_EOK;
  145. }
  146. static const struct rt_dac_ops stm_dac_ops =
  147. {
  148. .disabled = stm32_dac_disabled,
  149. .enabled = stm32_dac_enabled,
  150. .convert = stm32_set_dac_value,
  151. .get_resolution = stm32_dac_get_resolution,
  152. };
  153. static int stm32_dac_init(void)
  154. {
  155. int result = RT_EOK;
  156. /* save dac name */
  157. char name_buf[5] = {'d', 'a', 'c', '0', 0};
  158. int i = 0;
  159. for (i = 0; i < sizeof(dac_config) / sizeof(dac_config[0]); i++)
  160. {
  161. /* dac init */
  162. name_buf[3] = '0';
  163. stm32_dac_obj[i].DAC_Handler = dac_config[i];
  164. #if defined(DAC1)
  165. if (stm32_dac_obj[i].DAC_Handler.Instance == DAC1)
  166. {
  167. name_buf[3] = '1';
  168. }
  169. #endif
  170. #if defined(DAC2)
  171. if (stm32_dac_obj[i].dac_Handler.Instance == DAC2)
  172. {
  173. name_buf[3] = '2';
  174. }
  175. #endif
  176. if (HAL_DAC_Init(&stm32_dac_obj[i].DAC_Handler) != HAL_OK)
  177. {
  178. LOG_E("%s init failed", name_buf);
  179. result = -RT_ERROR;
  180. }
  181. else
  182. {
  183. /* register dac device */
  184. 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)
  185. {
  186. LOG_D("%s init success", name_buf);
  187. }
  188. else
  189. {
  190. LOG_E("%s register failed", name_buf);
  191. result = -RT_ERROR;
  192. }
  193. }
  194. }
  195. return result;
  196. }
  197. INIT_DEVICE_EXPORT(stm32_dac_init);
  198. #endif /* BSP_USING_DAC */