设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › 24小时必答区 › 求助！STM32控制ADF4351锁相环，芯片无输出
返回列表 发新帖
查看: 1774|回复: 0
收起左侧

求助！STM32控制ADF4351锁相环，芯片无输出

[复制链接]
ID:956164 发表于 2021-7-25 21:46 | 显示全部楼层 |阅读模式
输入和电源正常，CE使能端高电平，但从CPOUT就没有输出了，换了一次芯片也不好用
代码（从坛子里找的改了改）：
  1. //ADF4351.c

  3. #include "ADF4351.h"
  4. #include "delay.h"
  5. #include "stm32g4xx_hal.h"

  7. //#define
  8. #define ADF4351_R0                        ((uint32_t)0X2C8018)
  9. #define ADF4351_R1                        ((uint32_t)0X8029)
  10. #define ADF4351_R2                        ((uint32_t)0X10E42)
  11. #define ADF4351_R3                        ((uint32_t)0X4B3)
  12. #define ADF4351_R4                        ((uint32_t)0XEC803C)
  13. #define ADF4351_R5                        ((uint32_t)0X580005)

  15. #define ADF4351_R1_Base        ((uint32_t)0X8001)
  16. #define ADF4351_R4_Base        ((uint32_t)0X8C803C)
  17. #define ADF4351_R4_ON          ((uint32_t)0X8C803C)
  18. #define ADF4351_R4_OFF        ((uint32_t)0X8C883C)

  20. #define ADF4351_RF_OFF        ((uint32_t)0XEC801C)

  22. #define ADF4351_PD_ON                ((uint32_t)0X10E42)
  23. #define ADF4351_PD_OFF        ((uint32_t)0X10E02)


  26. void delay (int length)
  27. {
  28.         while (length >0)
  29.             length--;
  30. }

  32. void WriteToADF4351(uint8_t count, uint8_t *buf)
  33. {
  34.         uint8_t ValueToWrite = 0;
  35.         uint8_t i = 0;
  36.         uint8_t j = 0;
  37.        
  38.         HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_SET);
  39.         delay_us(1);
  40.         HAL_GPIO_WritePin(GPIOA, GPIO_PIN_7, GPIO_PIN_RESET);
  41.         HAL_GPIO_WritePin(GPIOA, GPIO_PIN_5, GPIO_PIN_RESET);
  42.         delay_us(1);
  43.        
  44.         for(i = count; i>0; i--)
  45.         {
  46.                 ValueToWrite = *(buf+i-1);
  47.                 for(j=0; j<8; j++)
  48.                 {
  49.                         if(0x80 == (ValueToWrite & 0x80))
  50.                         {
  51.                                 HAL_GPIO_WritePin(GPIOA, GPIO_PIN_6, GPIO_PIN_SET);
  52.                         }
  53.                         else
  54.                         {
  55.                                 HAL_GPIO_WritePin(GPIOA, GPIO_PIN_6, GPIO_PIN_RESET);
  56.                         }
  57.                         delay_us(1);
  58.                         HAL_GPIO_WritePin(GPIOA, GPIO_PIN_7, GPIO_PIN_SET);
  59.                         delay_us(1);
  60.                         ValueToWrite <<= 1;
  61.                         HAL_GPIO_WritePin(GPIOA, GPIO_PIN_7, GPIO_PIN_RESET);
  62.                 }
  63.         }
  64.         HAL_GPIO_WritePin(GPIOA, GPIO_PIN_1, GPIO_PIN_RESET);
  65.         delay_us(1);
  66.         HAL_GPIO_WritePin(GPIOA, GPIO_PIN_5, GPIO_PIN_SET);
  67.         delay_us(1);
  68.         HAL_GPIO_WritePin(GPIOA, GPIO_PIN_5, GPIO_PIN_RESET);
  69. }


  72. void ReadToADF4351(uint8_t count, uint8_t *buf)
  73. {
  74.         uint8_t m = 0;
  75.         uint8_t l = 0;
  76.         uint8_t iTemp = 0;
  77.         uint8_t RotateData = 0;

  79.         HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_SET);
  80.         delay_us(1);
  81.         HAL_GPIO_WritePin(GPIOA, GPIO_PIN_7, GPIO_PIN_RESET);
  82.         HAL_GPIO_WritePin(GPIOA, GPIO_PIN_5, GPIO_PIN_RESET);
  83.         delay_us(1);
  84.        
  85.         for(m = count; m>0; m--)
  86.         {
  87.                 for(l = 0; l<8; l++)
  88.                 {
  89.                         RotateData <<=1;
  90.                         delay_us(1);
  91.                         iTemp = ADF4351_INPUT_DATA;
  92.                         HAL_GPIO_WritePin(GPIOA, GPIO_PIN_7, GPIO_PIN_SET);
  93.                         if(0x01 == (iTemp&0x01))
  94.                         {
  95.                                 RotateData |= 1;
  96.                         }
  97.                         delay_us(1);
  98.                         HAL_GPIO_WritePin(GPIOA, GPIO_PIN_7, GPIO_PIN_RESET);
  99.                 }
  100.                 *(buf+m-1) = RotateData;
  101.         }
  102.         delay_us(1);
  103.         HAL_GPIO_WritePin(GPIOA, GPIO_PIN_5, GPIO_PIN_SET);
  104.         delay_us(1);
  105.         HAL_GPIO_WritePin(GPIOA, GPIO_PIN_5, GPIO_PIN_RESET);
  106. }


  109. void ADF4351Init(void)
  110. {
  111.         uint8_t buf[4] = {0,0,0,0};
  112.        
  113.         buf[3] = 0x00;
  114.         buf[2] = 0x58;                                //R5
  115.         buf[1] = 0x00;                                //write communication register 0x00580005 to control the progress
  116.         buf[0] = 0x05;                                //to write Register 5 to set digital lock detector
  117.         WriteToADF4351(4,buf);               

  119.         buf[3] = 0x00;                                //R4
  120.         buf[2] = 0xec;                                //(DB23=1)The signal is taken from the VCO directly;(DB22-20:4H)the RF divider is 16;(DB19-12:C8H)R is 200
  121.         buf[1] = 0x80;                                //(DB11=0)VCO powerd up;
  122.         buf[0] = 0x3C;                                //(DB5=1)RF output is enabled;(DB4-3=3H)Output power level is 5
  123.         WriteToADF4351(4,buf);               

  125.         buf[3] = 0x00;
  126.         buf[2] = 0x00;                                //R3
  127.         buf[1] = 0x04;                                //(DB14-3:96H)clock divider value is 150.
  128.         buf[0] = 0xB3;
  129.         WriteToADF4351(4,buf);       
  130.        
  131.         buf[3] = 0x00;                                //R2
  132. //        buf[2] = 0x01;                                //(DB6=1)set PD polarity is positive;(DB7=1)LDP is 6nS;
  133. //        buf[1] = 0x0E;                                //(DB8=0)enable fractional-N digital lock detect;
  134.         buf[2] = 0x00;
  135.         buf[1] = 0x4E;
  136.         buf[0] = 0x42;                                //(DB12-9:7H)set Icp 2.50 mA;
  137.         WriteToADF4351(4,buf);                //(DB23-14:1H)R counter is 1

  139.         buf[3] = 0x00;
  140.         buf[2] = 0x00;                                //R1
  141.         buf[1] = 0x80;                           //(DB14-3:6H)MOD counter is 6;
  142.         buf[0] = 0x29;                           //(DB26-15:6H)PHASE word is 1,neither the phase resync
  143.         WriteToADF4351(4,buf);           //nor the spurious optimization functions are being used
  144.                                                            //(DB27=1)prescaler value is 8/9

  146.         buf[3] = 0x00;
  147.         buf[2] = 0x2c;
  148.         buf[1] = 0x80;                                //R0
  149.         buf[0] = 0x18;                                //(DB14-3:0H)FRAC value is 0;
  150.         WriteToADF4351(4,buf);                //(DB30-15:140H)INT value is 320;
  151.        
  152.        
  153. //        WriteOneRegToADF4351(ADF4351_R0);
  154. //        WriteOneRegToADF4351(ADF4351_R1);
  155. //        WriteOneRegToADF4351(ADF4351_R2);
  156. //        WriteOneRegToADF4351(ADF4351_R3);
  157. //        WriteOneRegToADF4351(ADF4351_R4);
  158. //        WriteOneRegToADF4351(ADF4351_R5);
  159.        
  160. }
  161. void WriteOneRegToADF4351(uint32_t Regster)
  162. {
  163.         uint8_t buf[4] = {0,0,0,0};
  164.         buf[3] = (uint8_t)((Regster>>24)&(0X000000FF));
  165.         buf[2] = (uint8_t)((Regster>>16)&(0X000000FF));
  166.         buf[1] = (uint8_t)((Regster>>8) &(0X000000FF));
  167.         buf[0] = (uint8_t)((Regster)&(0X000000FF));
  168.         WriteToADF4351(4,buf);       
  169. }
  170. void ADF4351_Init_some(void)
  171. {
  172.         WriteOneRegToADF4351(ADF4351_R2);
  173.         WriteOneRegToADF4351(ADF4351_R3);
  174.         WriteOneRegToADF4351(ADF4351_R5);
  175. }

  177. void ADF4351WriteFreq(float Fre)                //        (xx.x) M Hz
  178. {
  179.         uint16_t Fre_temp, N_Mul = 1, Mul_Core = 0;
  180.         uint16_t INT_Fre, Frac_temp, Mod_temp, i;
  181.         uint32_t W_ADF4351_R0 = 0, W_ADF4351_R1 = 0, W_ADF4351_R4 = 0;
  182.         float multiple;
  183.        
  184.         if(Fre < 35.0)
  185.                 Fre = 35.0;
  186.         if(Fre > 4400.0)
  187.                 Fre = 4400.0;
  188.         Mod_temp = 250;
  189.         Fre = ((float)((uint32_t)(Fre*10)))/10;
  190.        
  191.         Fre_temp = Fre;
  192.         for(i = 0; i < 10; i++)
  193.         {
  194.                 if(((Fre_temp*N_Mul) >= 2199.9) && ((Fre_temp*N_Mul) <= 4400.1))
  195.                         break;
  196.                 Mul_Core++;
  197.                 N_Mul = N_Mul*2;
  198.         }
  199.        
  200.         multiple = (Fre*N_Mul)/25;
  201.         INT_Fre = (uint16_t)multiple;
  202. //        if(((uint32_t)(multiple*10000)%10)> 5)
  203. //                multiple += 0.001;
  204.         Frac_temp = ((uint32_t)(multiple*250))%250;
  205.         while(((Frac_temp%5) == 0) && ((Mod_temp%5) == 0))
  206.         {
  207.                 Frac_temp = Frac_temp/5;
  208.                 Mod_temp = Mod_temp/5;
  209.         }
  210.         while(((Frac_temp%2) == 0)&&((Mod_temp%2) == 0))
  211.         {
  212.                 Frac_temp = Frac_temp/2;
  213.                 Mod_temp = Mod_temp/2;
  214.         }
  215.        
  216.         Mul_Core %= 7;
  217.         W_ADF4351_R0 = (INT_Fre<<15)+(Frac_temp<<3);
  218.         W_ADF4351_R1 = ADF4351_R1_Base + (Mod_temp<<3);
  219.         W_ADF4351_R4 = ADF4351_R4_ON + (Mul_Core<<20);
  220.        
  221.        
  222. //        WriteOneRegToADF4351(ADF4351_PD_OFF); //ADF4351_RF_OFF
  223. //        WriteOneRegToADF4351((uint32_t)(ADF4351_R4_OFF + (6<<20)));
  224.         WriteOneRegToADF4351(ADF4351_RF_OFF);
  225.         WriteOneRegToADF4351(W_ADF4351_R1);
  226.         WriteOneRegToADF4351(W_ADF4351_R0);
  227.         WriteOneRegToADF4351(W_ADF4351_R4);
  228. //        WriteOneRegToADF4351(ADF4351_PD_ON);
  229.        
  230. //        WriteOneRegToADF4351((uint32_t)(ADF4351_R4_ON + (Mul_Core<<20)));
  231. }
复制代码

  1. //ADF4351.h

  3. #ifndef _ADF4351_H_
  4. #define _ADF4351_H_

  6. #include "stm32g474xx.h"
  7. #include "sys.h"

  9. #define ADF4351_INPUT_DATA PAin(1)

  11. void ADF4351Init(void);
  12. void ReadToADF4351(uint8_t count, uint8_t *buf);
  13. void WriteToADF4351(uint8_t count, uint8_t *buf);
  14. void WriteOneRegToADF4351(uint32_t Regster);
  15. void ADF4351_Init_some(void);
  16. void ADF4351WriteFreq(float Fre);                //        (xx.x) M Hz
  17. #endif

复制代码

  1. //main.c

  3. /* USER CODE BEGIN Header */
  4. /**
  5.   ******************************************************************************
  6. * @file           : main.c
  7.   * @brief          : Main program body
  8.   ******************************************************************************
  9.   * @attention
  10.   *
  11.   * <h2><center>&copy; Copyright (c) 2021 STMicroelectronics.
  12.   * All rights reserved.</center></h2>
  13.   *
  14.   * This software component is licensed by ST under BSD 3-Clause license,
  15.   * the "License"; You may not use this file except in compliance with the
  16.   * License. You may obtain a copy of the License at:
  17.   *                        opensource.org/licenses/BSD-3-Clause
  18.   *
  19.   ******************************************************************************
  20.   */
  21. /* USER CODE END Header */
  22. /* Includes ------------------------------------------------------------------*/
  23. #include "main.h"

  25. /* Private includes ----------------------------------------------------------*/
  26. /* USER CODE BEGIN Includes */
  27. #include "ADF4351.h"
  28. #include "delay.h"
  29. /* USER CODE END Includes */

  31. /* Private typedef -----------------------------------------------------------*/
  32. /* USER CODE BEGIN PTD */

  34. /* USER CODE END PTD */

  36. /* Private define ------------------------------------------------------------*/
  37. /* USER CODE BEGIN PD */
  38. /* USER CODE END PD */

  40. /* Private macro -------------------------------------------------------------*/
  41. /* USER CODE BEGIN PM */

  43. /* USER CODE END PM */

  45. /* Private variables ---------------------------------------------------------*/

  47. /* USER CODE BEGIN PV */

  49. /* USER CODE END PV */

  51. /* Private function prototypes -----------------------------------------------*/
  52. void SystemClock_Config(void);
  53. static void MX_GPIO_Init(void);
  54. /* USER CODE BEGIN PFP */

  56. /* USER CODE END PFP */

  58. /* Private user code ---------------------------------------------------------*/
  59. /* USER CODE BEGIN 0 */

  61. /* USER CODE END 0 */

  63. /**
  64.   * @brief  The application entry point.
  65.   * @retval int
  66.   */
  67. int main(void)
  68. {
  69.   /* USER CODE BEGIN 1 */

  71.   /* USER CODE END 1 */

  73.   /* MCU Configuration--------------------------------------------------------*/

  75.   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  76.   HAL_Init();

  78.   /* USER CODE BEGIN Init */

  80.   /* USER CODE END Init */

  82.   /* Configure the system clock */
  83.   SystemClock_Config();

  85.   /* USER CODE BEGIN SysInit */

  87.   /* USER CODE END SysInit */

  89.   /* Initialize all configured peripherals */
  90.   MX_GPIO_Init();
  91.   /* USER CODE BEGIN 2 */
  92. delay_us(1);
  93. ADF4351Init();
  94. //ADF4351WriteFreq(400);
  95.   /* USER CODE END 2 */

  97.   /* Infinite loop */
  98.   /* USER CODE BEGIN WHILE */
  99.   while (1)
  100.   {
  101.     /* USER CODE END WHILE */

  103.     /* USER CODE BEGIN 3 */
  104.   }
  105.   /* USER CODE END 3 */
  106. }

  108. /**
  109.   * @brief System Clock Configuration
  110.   * @retval None
  111.   */
  112. void SystemClock_Config(void)
  113. {
  114.   RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  115.   RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  117.   /** Configure the main internal regulator output voltage
  118.   */
  119.   HAL_PWREx_ControlVoltageScaling(PWR_REGULATOR_VOLTAGE_SCALE1_BOOST);
  120.   /** Initializes the RCC Oscillators according to the specified parameters
  121.   * in the RCC_OscInitTypeDef structure.
  122.   */
  123.   RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  124.   RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  125.   RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  126.   RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  127.   RCC_OscInitStruct.PLL.PLLM = RCC_PLLM_DIV6;
  128.   RCC_OscInitStruct.PLL.PLLN = 85;
  129.   RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
  130.   RCC_OscInitStruct.PLL.PLLQ = RCC_PLLQ_DIV2;
  131.   RCC_OscInitStruct.PLL.PLLR = RCC_PLLR_DIV2;
  132.   if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  133.   {
  134.     Error_Handler();
  135.   }
  136.   /** Initializes the CPU, AHB and APB buses clocks
  137.   */
  138.   RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
  139.                               |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  140.   RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  141.   RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  142.   RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
  143.   RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  145.   if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_4) != HAL_OK)
  146.   {
  147.     Error_Handler();
  148.   }
  149. }

  151. /**
  152.   * @brief GPIO Initialization Function
  153.   * @param None
  154.   * @retval None
  155.   */
  156. static void MX_GPIO_Init(void)
  157. {
  158.   GPIO_InitTypeDef GPIO_InitStruct = {0};

  160.   /* GPIO Ports Clock Enable */
  161.   __HAL_RCC_GPIOF_CLK_ENABLE();
  162.   __HAL_RCC_GPIOA_CLK_ENABLE();

  164.   /*Configure GPIO pin Output Level */
  165.   HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_6|GPIO_PIN_7, GPIO_PIN_SET);

  167.   /*Configure GPIO pin : PA1 */
  168.   GPIO_InitStruct.Pin = GPIO_PIN_1;
  169.   GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  170.   GPIO_InitStruct.Pull = GPIO_NOPULL;
  171.   HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  173.   /*Configure GPIO pins : PA4 PA5 PA6 PA7 */
  174.   GPIO_InitStruct.Pin = GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_6|GPIO_PIN_7;
  175.   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  176.   GPIO_InitStruct.Pull = GPIO_NOPULL;
  177.   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
  178.   HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  180. }

  182. /* USER CODE BEGIN 4 */

  184. /* USER CODE END 4 */

  186. /**
  187.   * @brief  This function is executed in case of error occurrence.
  188.   * @retval None
  189.   */
  190. void Error_Handler(void)
  191. {
  192.   /* USER CODE BEGIN Error_Handler_Debug */
  193.   /* User can add his own implementation to report the HAL error return state */
  194.   __disable_irq();
  195.   while (1)
  196.   {
  197.   }
  198.   /* USER CODE END Error_Handler_Debug */
  199. }

  201. #ifdef  USE_FULL_ASSERT
  202. /**
  203.   * @brief  Reports the name of the source file and the source line number
  204.   *         where the assert_param error has occurred.
  205.   * @param  file: pointer to the source file name
  206.   * @param  line: assert_param error line source number
  207.   * @retval None
  208.   */
  209. void assert_failed(uint8_t *file, uint32_t line)
  210. {
  211.   /* USER CODE BEGIN 6 */
  212.   /* User can add his own implementation to report the file name and line number,
  213.      ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  214.   /* USER CODE END 6 */
  215. }
  216. #endif /* USE_FULL_ASSERT */

  218. /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
复制代码
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表