标题: 求助！STM32控制ADF4351锁相环，芯片无输出 [打印本页]

---

作者: TDWFE    时间: 2021-7-25 21:46
标题: 求助！STM32控制ADF4351锁相环，芯片无输出
输入和电源正常，CE使能端高电平，但从CPOUT就没有输出了，换了一次芯片也不好用
代码（从坛子里找的改了改）：

1. //ADF4351.c
   
2. 
   
3. #include "ADF4351.h"
   
4. #include "delay.h"
   
5. #include "stm32g4xx_hal.h"
   
6. 
   
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)
    
14. 
    
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)
    
19. 
    
20. #define ADF4351_RF_OFF        ((uint32_t)0XEC801C)
    
21. 
    
22. #define ADF4351_PD_ON                ((uint32_t)0X10E42)
    
23. #define ADF4351_PD_OFF        ((uint32_t)0X10E02)
    
24. 
    
25. 
    
26. void delay (int length)
    
27. {
    
28.         while (length >0)
    
29.             length--;
    
30. }
    
31. 
    
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. }
    
70. 
    
71. 
    
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;
    
78. 
    
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. }
     
107. 
     
108. 
     
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);               
     
118. 
     
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);               
     
124. 
     
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
     
138. 
     
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
     
145. 
     
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. }
     
176. 
     
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
   
2. 
   
3. #ifndef _ADF4351_H_
   
4. #define _ADF4351_H_
   
5. 
   
6. #include "stm32g474xx.h"
   
7. #include "sys.h"
   
8. 
   
9. #define ADF4351_INPUT_DATA PAin(1)
   
10. 
    
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
    
18. 
    

复制代码

1. //main.c
   
2. 
   
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"
    
24. 
    
25. /* Private includes ----------------------------------------------------------*/
    
26. /* USER CODE BEGIN Includes */
    
27. #include "ADF4351.h"
    
28. #include "delay.h"
    
29. /* USER CODE END Includes */
    
30. 
    
31. /* Private typedef -----------------------------------------------------------*/
    
32. /* USER CODE BEGIN PTD */
    
33. 
    
34. /* USER CODE END PTD */
    
35. 
    
36. /* Private define ------------------------------------------------------------*/
    
37. /* USER CODE BEGIN PD */
    
38. /* USER CODE END PD */
    
39. 
    
40. /* Private macro -------------------------------------------------------------*/
    
41. /* USER CODE BEGIN PM */
    
42. 
    
43. /* USER CODE END PM */
    
44. 
    
45. /* Private variables ---------------------------------------------------------*/
    
46. 
    
47. /* USER CODE BEGIN PV */
    
48. 
    
49. /* USER CODE END PV */
    
50. 
    
51. /* Private function prototypes -----------------------------------------------*/
    
52. void SystemClock_Config(void);
    
53. static void MX_GPIO_Init(void);
    
54. /* USER CODE BEGIN PFP */
    
55. 
    
56. /* USER CODE END PFP */
    
57. 
    
58. /* Private user code ---------------------------------------------------------*/
    
59. /* USER CODE BEGIN 0 */
    
60. 
    
61. /* USER CODE END 0 */
    
62. 
    
63. /**
    
64.   * @brief  The application entry point.
    
65.   * @retval int
    
66.   */
    
67. int main(void)
    
68. {
    
69.   /* USER CODE BEGIN 1 */
    
70. 
    
71.   /* USER CODE END 1 */
    
72. 
    
73.   /* MCU Configuration--------------------------------------------------------*/
    
74. 
    
75.   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
    
76.   HAL_Init();
    
77. 
    
78.   /* USER CODE BEGIN Init */
    
79. 
    
80.   /* USER CODE END Init */
    
81. 
    
82.   /* Configure the system clock */
    
83.   SystemClock_Config();
    
84. 
    
85.   /* USER CODE BEGIN SysInit */
    
86. 
    
87.   /* USER CODE END SysInit */
    
88. 
    
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 */
    
96. 
    
97.   /* Infinite loop */
    
98.   /* USER CODE BEGIN WHILE */
    
99.   while (1)
    
100.   {
     
101.     /* USER CODE END WHILE */
     
102. 
     
103.     /* USER CODE BEGIN 3 */
     
104.   }
     
105.   /* USER CODE END 3 */
     
106. }
     
107. 
     
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};
     
116. 
     
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;
     
144. 
     
145.   if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_4) != HAL_OK)
     
146.   {
     
147.     Error_Handler();
     
148.   }
     
149. }
     
150. 
     
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};
     
159. 
     
160.   /* GPIO Ports Clock Enable */
     
161.   __HAL_RCC_GPIOF_CLK_ENABLE();
     
162.   __HAL_RCC_GPIOA_CLK_ENABLE();
     
163. 
     
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);
     
166. 
     
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);
     
172. 
     
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);
     
179. 
     
180. }
     
181. 
     
182. /* USER CODE BEGIN 4 */
     
183. 
     
184. /* USER CODE END 4 */
     
185. 
     
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. }
     
200. 
     
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 */
     
217. 
     
218. /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
     

复制代码

---

欢迎光临 (http://www.51hei.com/bbs/)

Powered by Discuz! X3.1