基于STM32F100C的LCR测试表

STM129

链接：https://radiokot.ru/circuit/digital/measure/108/
有兴趣的来研究下其是什么个原理

STM129

没人浏览，放上程序看有兴趣的不。一个模拟信号计算处理的程序。

1. /* ------------------------------------------------------------------
   
2. * 2013 RLC Meter V6 / Neekeetos@yahoo.com
   
3. */
   
4. 
   
5. #include "stm32f10x.h"
   
6. #include "stm32f10x_tim.h"
   
7. #include "stm32f10x_gpio.h"
   
8. #include "stm32f10x_dac.h"
   
9. #include "stm32f10x_dma.h"
   
10. #include "stm32f10x_rcc.h"
    
11. #include "string.h"
    
12. #include "math.h"
    
13. #include "misc.h"
    
14. // #include "uart.h"
    
15. #include "n1110.h"
    
16. 
    
17. #define AIRCR_VECTKEY_MASK    ((uint32_t)0x05FA0000)
    
18. 
    
19. #define N 500
    
20. #define DAC_N (N/5)
    
21. #define OSR 40
    
22. #define SINE_OFFSET 900
    
23. 
    
24. #define IRQ_ADC_SAMPLE 1
    
25. #define IRQ_DAC_INVERSE 2
    
26. #define IRQ_DAC_ZERO 4
    
27. 
    
28. #define cordic_1K 0x26DCEDB0
    
29. #define half_pi 0x40000000
    
30. #define MUL 1073741824.000000
    
31. #define CORDIC_NTAB 32
    
32. 
    
33. #define ALPHA 0.05
    
34. #define ALPHA2 0.1
    
35. #define CLOSE_LIMIT 0.05
    
36. #define FLT_LEN 5
    
37. //#define MOHM_LIMIT 0.02
    
38. //#define GOHM_LIMIT 1e6
    
39. 
    
40. #define SHUNT 148.0
    
41. #define CAL_ROUNDS 64
    
42. 
    
43. #define PWR_PIN (GPIOC->IDR & GPIO_Pin_13)
    
44. #define SP_PIN (GPIOB->IDR & GPIO_Pin_8)
    
45. #define REL_PIN (GPIOB->IDR & GPIO_Pin_7)
    
46. 
    
47. #define PWR_BTN 1
    
48. #define SP_BTN 2
    
49. #define REL_BTN 4
    
50. 
    
51. #define PWR_BTNL 0x10
    
52. #define SP_BTNL  0x20
    
53. #define REL_BTNL 0x40
    
54. 
    
55. #define PUSH_MSK 0x000003
    
56. #define PUSH_MAP 0x000001
    
57. #define LPUSH_MSK 0x00001FFF
    
58. #define LPUSH_MAP 0x00000FFF
    
59. 
    
60. int buttons();
    
61. 
    
62. const uint32_t chn[3] ={1,2,7};
    
63. const int dig[]= { 1000000000,100000000,10000000,1000000,100000,10000,1000,100,10,1};
    
64. const char dp[9]= {'f','p','n','u','m',' ','k','M','G'};
    
65. int cordic_ctab [] = {0x20000000, 0x12E4051E, 0x09FB385B, 0x051111D4, 0x028B0D43, 0x0145D7E1, 0x00A2F61E, 0x00517C55, 0x0028BE53, 0x00145F2F, 0x000A2F98, 0x000517CC,
    
66. 0x00028BE6, 0x000145F3, 0x0000A2FA, 0x0000517D, 0x000028BE, 0x0000145F, 0x00000A30, 0x00000518, 0x0000028C, 0x00000146, 0x000000A3, 0x00000051, 0x00000029, 0x00000014,
    
67. 0x0000000A, 0x00000005, 0x00000003, 0x00000001, 0x00000001, 0x00000000, };
    
68. 
    
69. volatile uint32_t irq_request = 0;
    
70. volatile uint32_t irq_status = 0;
    
71. 
    
72. int16_t sine[N+N/4];
    
73. uint32_t dac_buf[DAC_N];
    
74. 
    
75. #define FCNT 5
    
76. 
    
77. const int flist[FCNT]= { 1,9,25,49,97 };
    
78. int __attribute__ ((section (".noinit"))) findex,cstatus;
    
79. 
    
80. volatile uint32_t ch = 0;
    
81. int freq;
    
82. //----------------------------------------------------------------------------
    
83. typedef struct complex_number {
    
84.         float Re;
    
85.         float Im;
    
86. } cplx;
    
87. //----------------------------------------------------------------------------
    
88. cplx mData[3];
    
89. cplx mAcc[3];
    
90. 
    
91. volatile uint16_t adc_dma[N];
    
92. 
    
93. cplx __attribute__ ((section (".noinit"))) Zo[FCNT];
    
94. cplx __attribute__ ((section (".noinit"))) Zs[FCNT];// calibration constants
    
95. cplx R;
    
96. //----------------------------------------------------------------------------
    
97. // res = res / div
    
98. //----------------------------------------------------------------------------
    
99. void cplxDiv(cplx * res, cplx * div)
    
100. {
     
101.         cplx tmp;
     
102.         float mod2 = div->Re*div->Re + div->Im*div->Im;
     
103. 
     
104.         tmp.Re =  ( res->Re * div->Re + res->Im * div->Im ) / mod2;        //(a*c+b*d)/(c*c+d*d);
     
105.         tmp.Im =  ( res->Im * div->Re - res->Re * div->Im ) / mod2; //(b*c-a*d)/(c*c+d*d);
     
106.         res->Re = tmp.Re;
     
107.         res->Im = tmp.Im;
     
108. }
     
109. //----------------------------------------------------------------------------
     
110. // res = res * mul
     
111. //----------------------------------------------------------------------------
     
112. void cplxMul(cplx * res, cplx * mul)
     
113. {
     
114.         cplx tmp;
     
115.         tmp.Re =  ( res->Re * mul->Re - res->Im * mul->Im );// a*c - b*d
     
116.         tmp.Im =  ( res->Re * mul->Im + res->Im * mul->Re );// a*d + b*c
     
117.         res->Re = tmp.Re;
     
118.         res->Im = tmp.Im;
     
119. }
     
120. //----------------------------------------------------------------------------
     
121. int cordic(int theta)
     
122. {
     
123.         int k, tx, ty;
     
124.         int x=cordic_1K,y=0,z=theta;
     
125. 
     
126.         if( ( z >= half_pi ) || ( z < -half_pi) ) z = (half_pi<<1) - z;
     
127. 
     
128.         //n = (n>CORDIC_NTAB) ? CORDIC_NTAB : n;
     
129. 
     
130.         for ( k = 0 ; k < 20; ++k ) // 20bit
     
131.         {
     
132.                 if(z >= 0 )
     
133.                 {
     
134.                         tx = x -  (y>>k) ;
     
135.                         ty = y +  (x>>k) ;
     
136.                         z = z -  cordic_ctab[k];
     
137.                         x = tx; y = ty;
     
138.                 }else{
     
139.                         tx = x +  (y>>k) ;
     
140.                         ty = y -  (x>>k) ;
     
141.                         z = z +  cordic_ctab[k];
     
142.                         x = tx; y = ty;
     
143.                 }
     
144.         }
     
145.         return (y);
     
146.         //*c = x; *s = y;
     
147. }
     
148. //----------------------------------------------------------------------------
     
149. void fillSine(int freq)
     
150. {   int s,i;
     
151. long long pp;
     
152. for(i=0;i<N;i++)
     
153. {
     
154.         pp = ( ((long long )freq * i << 32 ) / N );//<<16;
     
155.         s = cordic((int)pp);
     
156.         s = ((s>>14)+1)>>1;
     
157.         sine[i] = s;
     
158. }
     
159. 
     
160. for(i=0;i<N/4;i++)
     
161. {
     
162.         pp = ( ((long long )freq * i << 32 ) / N );
     
163.         s = cordic((int)pp);
     
164.         s = ((s>>14)+1)>>1;
     
165.         sine[i+N] = s;
     
166. }
     
167. 
     
168. }
     
169. //----------------------------------------------------------------------------
     
170. float absolute(float x)
     
171. {
     
172.         if (x < 0) return (-x);
     
173.         return (x);
     
174. }
     
175. //----------------------------------------------------------------------------
     
176. float square(float x) {
     
177.         float guess = 1;
     
178.         int lim = 100;
     
179. 
     
180.         while( (absolute(guess*guess - x) >= 0.000002 )&&(lim-- >0))
     
181.                 guess = ((x/guess) + guess) * 0.5;
     
182. 
     
183.         return (guess);
     
184. }
     
185. //----------------------------------------------------------------------------
     
186. void  __attribute__ ((noinline)) print(char * str){
     
187.         lcd_putstr(str);
     
188.         //        uart_tx(str,1);// wait
     
189. }
     
190. //----------------------------------------------------------------------------
     
191. void puthex(int inp,short size)
     
192. {
     
193.         char buf[9];
     
194.         int j;
     
195. 
     
196.         for(j=size-1;j>=0;j--)
     
197.         {char dig = (inp&0xf);
     
198.         if(dig<10){buf[j]=0x30+dig;}else{buf[j]=0x41+dig-10;}
     
199.         inp >>=4;
     
200.         }
     
201. 
     
202.         buf[size]=0;
     
203.         print(buf);
     
204. }
     
205. //----------------------------------------------------------------------------
     
206. void sputdec(char * buf,int inp)
     
207. {
     
208.         int ptr = 0;
     
209.         int s,startflag = 1;
     
210.         int digit;
     
211. 
     
212. 
     
213.         for(ptr =0;ptr < 12; ptr++)        buf[ptr]=0;
     
214.         ptr = 0;
     
215. 
     
216.         if(inp<0 ){inp = -inp;buf[ptr++]='-';}
     
217. 
     
218.         for(s = 0;s<10;s++)
     
219.         {
     
220.                 digit =0;
     
221.                 while (inp >= dig[s]){inp-=dig[s];digit++;}
     
222. 
     
223.                 if(digit != 0) startflag =0;
     
224.                 if(s == 9 )startflag =0;
     
225.                 if( startflag == 0 ) buf[ptr++]=0x30+digit;
     
226. 
     
227.         }
     
228. 
     
229.         return;
     
230. }
     
231. //----------------------------------------------------------------------------
     
232. void putdec(int inp)
     
233. {
     
234.         char buf[12];
     
235.         sputdec(buf,inp);
     
236.         print(buf);
     
237. }
     
238. //----------------------------------------------------------------------------
     
239. void  printFloat(int x , int y,float num,char * suffix)
     
240. {
     
241.         char out[20];
     
242.         char nnn[20];
     
243.         int i,dot;
     
244. 
     
245.         out[0] = ' ';
     
246.         if(num < 0 ) { num = -num;out[0]= '-';}
     
247.         if(num > 1e10) num = 1e10;
     
248.         if(num < 1e-15) num = 1e-15;
     
249. 
     
250.         int exp = 19;
     
251. 
     
252.         if(num < 10000.0)
     
253.         {
     
254.                 while(num < 10000.0){ num*= 10.0; exp--;        }
     
255.         }else{
     
256.                 while(num > 99999.4){ num/= 10.0; exp++;        }
     
257.         }
     
258. 
     
259.         dot = (exp+30)%3;
     
260.         exp = (exp)/3;
     
261. 
     
262.         if(exp <0 || exp> 8 )
     
263.         {
     
264.                 for(i = 0; i<6;i++)
     
265.                 {
     
266.                         out[i+1] = '-';
     
267.                 }
     
268.         }else{
     
269. 
     
270.                 sputdec(nnn,num+0.5);
     
271. 
     
272.                 char * optr = &out[1];
     
273.                 for(i = 0; i<6;i++)
     
274.                 {
     
275.                         *optr++ = nnn[i];
     
276.                         if(i==dot){ *optr++  = '.'; }
     
277.                 }
     
278.         }
     
279. 
     
280.         out[7] = dp[exp];
     
281. 
     
282.         for(i = 0; i<6;i++)
     
283.         {
     
284.                 if(suffix[i]== 0 ){out[i+8] = 0;break;}
     
285.                 out[i+8] = suffix[i];
     
286.         }
     
287. 
     
288.         lcd_putnum (x,y,out);
     
289. }
     
290. //----------------------------------------------------------------------------
     
291. void runRound(void) // result in real[3],imag[3]
     
292. {
     
293.         //                GPIOB->BSRR = GPIO_Pin_14;
     
294.         irq_request |= IRQ_ADC_SAMPLE;
     
295.         while( !(irq_status & IRQ_ADC_SAMPLE) ) __NOP();__NOP();
     
296.         irq_status &= ~IRQ_ADC_SAMPLE;
     
297.         //                GPIOB->BRR = GPIO_Pin_14; // reset
     
298. }
     
299. //----------------------------------------------------------------------------
     
300. void measure(cplx * Z , int rounds)
     
301. {
     
302. 
     
303.         cplx I;
     
304. 
     
305.         mAcc[0].Re = 0;mAcc[0].Im = 0;
     
306.         mAcc[1].Re = 0;mAcc[1].Im = 0;
     
307.         mAcc[2].Re = 0;mAcc[2].Im = 0;
     
308. 
     
309.         while(rounds-- >0 )
     
310.         {
     
311.                 runRound();
     
312.                 mAcc[0].Re += mData[0].Re;
     
313.                 mAcc[0].Im += mData[0].Im;
     
314.                 mAcc[1].Re += mData[1].Re;
     
315.                 mAcc[1].Im += mData[1].Im;
     
316.                 mAcc[2].Re += mData[2].Re;
     
317.                 mAcc[2].Im += mData[2].Im;
     
318. 
     
319.         }
     
320. 
     
321.         Z->Re = (mAcc[2].Re - mAcc[0].Re); // V
     
322.         Z->Im = (mAcc[2].Im - mAcc[0].Im);
     
323.         cplxMul(Z,&R);
     
324.         I.Re = (mAcc[0].Re - mAcc[1].Re); // I
     
325.         I.Im = (mAcc[0].Im - mAcc[1].Im);
     
326.         cplxDiv(Z,&I);
     
327. 
     
328. }
     
329. //----------------------------------------------------------------------------
     
330. float filter(int sidx,float new)
     
331. {
     
332.         static float state[10];
     
333.         static int cnt[10];
     
334. 
     
335.         float t = (state[sidx]-new);
     
336.         float sc = CLOSE_LIMIT*state[sidx];
     
337. 
     
338.         if( (t > sc) || ( t < -sc ) )
     
339.         {
     
340.                 if(t > 0 )cnt[sidx]++; else  cnt[sidx]--;
     
341.                 state[sidx] = state[sidx]*(1-ALPHA2)+ new*ALPHA2;
     
342.         }else{
     
343.                 state[sidx] = state[sidx]*(1-ALPHA)+ new*ALPHA;
     
344.                 if(t < 0 )cnt[sidx]++; else  cnt[sidx]--;
     
345.         }
     
346. 
     
347.         if( (cnt[sidx] > 2*FLT_LEN) || (cnt[sidx] < -2*FLT_LEN) )
     
348.         {
     
349.                 state[sidx] = new;
     
350.                 cnt[sidx] = 0;
     
351.                 //if(cnt[sidx]  > 0 ) cnt[sidx] = FLT_LEN; else cnt[sidx] =  -FLT_LEN;
     
352.         }
     
353. 
     
354. 
     
355.         return state[sidx];
     
356. }
     
357. //----------------------------------------------------------------------------
     
358. void powerOff(void)
     
359. {
     
360.         int cnt =0;
     
361. 
     
362.         AFIO->EXTICR[3] = AFIO_EXTICR4_EXTI13_PC;
     
363.         EXTI->FTSR = EXTI_FTSR_TR13;
     
364.         EXTI->IMR = 0;
     
365.         EXTI->EMR = EXTI_EMR_MR13;
     
366.         EXTI->PR = 0x0003FFFF;
     
367. 
     
368.         DAC->CR  =0;
     
369.         ADC1->CR2 =0;
     
370.         GPIOA->CRH &= ~(
     
371.                         GPIO_CRH_CNF9 |GPIO_CRH_MODE9 // usart tx
     
372.                         |GPIO_CRH_CNF10|GPIO_CRH_MODE10 // usart rx
     
373.         );
     
374. 
     
375.         lcd_write(COMMAND, 0xA5); // DAL
     
376.         lcd_write(COMMAND, 0xAE); // turn off display
     
377. 
     
378. 
     
379.         GPIOA->BSRR = GPIO_Pin_3; // ANALOG OFF
     
380.         GPIOA->BRR = GPIO_Pin_15; // BACKLIGHT OFF
     
381. 
     
382.         SCB->SCR |= SCB_SCR_SLEEPDEEP;
     
383.         PWR->CR &= ~(PWR_CR_PDDS|PWR_CR_LPDS);
     
384.         PWR->CR |= PWR_CR_LPDS;
     
385. 
     
386.         while( !(GPIOC->IDR & GPIO_Pin_13) ) ;
     
387. 
     
388.         while(cnt <400000)
     
389.         {
     
390.                 if( !(GPIOC->IDR & GPIO_Pin_13) )cnt++;
     
391.                 else
     
392.                 {
     
393.                         if(cnt>0)cnt = 0; else cnt--;
     
394.                         if(cnt<-100){        EXTI->PR = 0x0003FFFF;__NOP();        __WFE(); }
     
395.                 }
     
396.         }
     
397.         NVIC_SystemReset();
     
398. 
     
399.         //GPIOA->BSRR = GPIO_Pin_15; // BACKLIGHT ON
     
400. 
     
401. }
     
402. //----------------------------------------------------------------------------
     
403. void waitz(float lim)
     
404. {
     
405.         float min = -lim , max = lim;
     
406.         float z;
     
407.         cplx Z;
     
408. 
     
409.         if(lim < 0 ) // minimum
     
410.         {
     
411.                 z = min * 2;
     
412.                 while( z > min )
     
413.                 {
     
414.                         measure(&Z,1);
     
415.                         z = absolute(Z.Re);
     
416.                         if( buttons() & PWR_BTN  ) powerOff();
     
417.                 }
     
418. 
     
419.         }else{
     
420.                 z = 0;
     
421.                 while( z < max*max )
     
422.                 {
     
423.                         measure(&Z,1);
     
424.                         z = (Z.Re*Z.Re+Z.Im*Z.Im);
     
425.                         if( buttons() & PWR_BTN  ) powerOff();
     
426.                 }
     
427.         }
     
428. 
     
429. }
     
430. //----------------------------------------------------------------------------
     
431. void calibrate( void ){
     
432.         cplx Z;
     
433.         irq_request &= ~IRQ_DAC_INVERSE; // normal out
     
434. 
     
435.         lcd_gotoxy(0, 0);print("Open leads      ");        waitz(1000);
     
436. 
     
437.         measure(&Z,6);
     
438.         lcd_gotoxy(0, 0);print("Open cal        ");
     
439.         measure(&Zo[findex],CAL_ROUNDS);
     
440. 
     
441.         lcd_gotoxy(0, 0);print("Close leads      ");waitz(-1);
     
442. 
     
443.         measure(&Z,6);
     
444.         lcd_gotoxy(0, 0);print("Short cal        ");
     
445. 
     
446.         measure(&Zs[findex],CAL_ROUNDS);
     
447. }
     
448. //----------------------------------------------------------------------------
     
449. int buttons()
     
450. {
     
451.         int out = 0;
     
452.         static unsigned int sPWR = 0;
     
453.         static unsigned int sSP = 0;
     
454.         static unsigned int sREL = 0;
     
455. 
     
456.         sPWR<<=1;sSP<<=1;sREL<<=1;
     
457.         sPWR &=0xFFFFF;        sSP &=0xFFFFF;        sREL &=0xFFFFF;
     
458.         if( !PWR_PIN ) { sPWR |= 1;}
     
459.         if( !SP_PIN )  { sSP  |= 1;}
     
460.         if( !REL_PIN ) { sREL |= 1;}
     
461. 
     
462.         if( (sPWR&PUSH_MSK) == PUSH_MAP ) {out|= PWR_BTN;}
     
463.         if( (sSP& PUSH_MSK) == PUSH_MAP ) {out|= SP_BTN;}
     
464.         if( (sREL&PUSH_MSK) == PUSH_MAP ) {out|= REL_BTN;}
     
465. 
     
466.         if( (sPWR&LPUSH_MSK) == LPUSH_MAP ) out|= PWR_BTNL;
     
467.         if( (sSP &LPUSH_MSK) == LPUSH_MAP ) out|= SP_BTNL;
     
468.         if( (sREL&LPUSH_MSK) == LPUSH_MAP ) out|= REL_BTNL;
     
469. 
     
470.         return (out);
     
471. }
     
472. //----------------------------------------------------------------------------
     
473. int main(void) {
     
474.         int bl_status = 1,rsrp = 0,rel = 0,btn,round = 0;
     
475.         cplx Z,base;
     
476.         char s[16];
     
477. 
     
478.         RCC->CFGR &= ~RCC_CFGR_ADCPRE;
     
479.         RCC->CFGR |= RCC_CFGR_ADCPRE_DIV2;// 16M adc
     
480. 
     
481.         RCC->AHBENR |= RCC_AHBENR_DMA1EN;
     
482.         RCC->APB1ENR = RCC_APB1ENR_TIM2EN| RCC_APB1ENR_TIM3EN | RCC_APB1ENR_DACEN | RCC_APB1ENR_PWREN | RCC_APB1ENR_BKPEN;
     
483.         RCC->APB2ENR = RCC_APB2ENR_ADC1EN        |RCC_APB2ENR_IOPAEN        |RCC_APB2ENR_IOPBEN        |RCC_APB2ENR_IOPCEN                //|RCC_APB2ENR_USART1EN
     
484.                         |RCC_APB2ENR_AFIOEN;
     
485. 
     
486.         AFIO->MAPR = AFIO_MAPR_TIM2_REMAP_FULLREMAP|AFIO_MAPR_SWJ_CFG_JTAGDISABLE;
     
487.         SCB->AIRCR = AIRCR_VECTKEY_MASK | NVIC_PriorityGroup_1;
     
488. 
     
489.         NVIC_SetPriority(DMA1_Channel1_IRQn, NVIC_EncodePriority(NVIC_GetPriorityGrouping(),1,1));//adc
     
490.         NVIC_SetPriority(DMA1_Channel4_IRQn, NVIC_EncodePriority(NVIC_GetPriorityGrouping(),0,0));//dac
     
491. 
     
492.         GPIOA->CRL = GPIO_CRL_MODE3_1 // analog switch
     
493.                         ;
     
494.         GPIOA->CRH =
     
495.                         GPIO_CRH_CNF10_0 //usart rx
     
496.                         |GPIO_CRH_CNF9_1|GPIO_CRH_MODE9_1 // usart tx
     
497.                         |GPIO_CRH_MODE15_1 // backlight
     
498.                         ;
     
499.         //        |GPIO_CRH_CNF15_1|GPIO_CRH_MODE15_1 // TIM2 CH1
     
500.         // MCO : |GPIO_CRH_MODE8_0|GPIO_CRH_CNF8_1        RCC->CFGR |= RCC_CFGR_MCO_SYSCLK;
     
501. 
     
502.         GPIOA->BRR = GPIO_Pin_0; // GUARD ON
     
503.         GPIOA->BRR = GPIO_Pin_3; // ANALOG ON
     
504.         GPIOA->BRR = GPIO_Pin_15; // BACKLIGHT OFF
     
505. 
     
506.         GPIOB->CRL =
     
507.                         GPIO_CRL_CNF7_1  // BUTTON 1 PU
     
508.                         |GPIO_CRL_MODE3 //SCK
     
509.                         |GPIO_CRL_MODE4 //MOSI
     
510.                         |GPIO_CRL_MODE5 // CS
     
511.                         |GPIO_CRL_MODE6 //RES
     
512.                         ;
     
513.         GPIOB->CRH =
     
514.                         GPIO_CRH_CNF8_1 // BUTTON 2
     
515.                         |GPIO_CRH_MODE13_1 // diag 1
     
516.                         |GPIO_CRH_MODE14_1 // diag 2
     
517.                         ;
     
518. 
     
519.         GPIOB->BSRR = GPIO_Pin_8| GPIO_Pin_7; // BUTTON 1,2 PU
     
520.         GPIOB->BRR = GPIO_Pin_3|GPIO_Pin_4|GPIO_Pin_5|GPIO_Pin_6
     
521.                         |GPIO_Pin_13|GPIO_Pin_14;// 0 diag 1,2 outputs
     
522. 
     
523.         GPIOC->CRL = 0;
     
524.         GPIOC->CRH = GPIO_CRH_CNF13_1;//GPIO_CRH_CNF13_1; // BUTTON 3
     
525.         GPIOC->BSRR = GPIO_Pin_13;// BUTTON 3 PU
     
526. 
     
527.         TIM2->PSC = 0;
     
528.         TIM2->ARR = 63;///63;
     
529.         TIM2->CR1 = TIM_CR1_ARPE;
     
530.         TIM2->CR2 = TIM_CR2_MMS_2|TIM_CR2_MMS_1; // TRGO trigger = oc3  = DAC TRIGGER
     
531.         TIM2->CCR1 = 46;
     
532.         TIM2->CCR2 = 62;
     
533.         TIM2->CCR3 = 10;
     
534.         TIM2->CCR4 = 0;
     
535.         TIM2->SMCR = 0;
     
536.         TIM2->CCMR1 = TIM_CCMR1_OC1M | TIM_CCMR1_OC1PE|TIM_CCMR1_OC2M | TIM_CCMR1_OC2PE;
     
537.         TIM2->CCMR2 = TIM_CCMR2_OC3M | TIM_CCMR2_OC3PE;//|TIM_CCMR2_OC4M | TIM_CCMR2_OC4PE;
     
538.         TIM2->CCER =  TIM_CCER_CC1E | TIM_CCER_CC2E | TIM_CCER_CC3E ;
     
539.         TIM2->DIER =  TIM_DIER_CC1DE;
     
540.         TIM2->EGR = 0;
     
541. 
     
542.         DAC->CR  = DAC_CR_TEN1|DAC_CR_TEN2|DAC_CR_TSEL2_2|DAC_CR_TSEL1_2  //tim2_trgo
     
543.                         |DAC_CR_BOFF1|DAC_CR_BOFF2
     
544.                         |DAC_CR_WAVE1_1|DAC_CR_MAMP1_1|DAC_CR_MAMP1_0
     
545.                         |DAC_CR_WAVE2_1|DAC_CR_MAMP2_1|DAC_CR_MAMP2_0
     
546.                         ;
     
547. 
     
548.         DMA1_Channel4->CCR = 0;
     
549.         DMA1_Channel4->CPAR = (uint32_t)&DAC->DHR12RD;
     
550.         DMA1_Channel4->CMAR = (uint32_t) dac_buf;//sine;
     
551.         DMA1_Channel4->CNDTR = DAC_N;
     
552.         DMA1_Channel4->CCR = DMA_CCR1_MINC | DMA_CCR1_CIRC | DMA_CCR1_DIR |DMA_CCR1_PL_1|
     
553.                         DMA_MemoryDataSize_Word| DMA_PeripheralDataSize_Word
     
554.                         |DMA_CCR1_HTIE        |DMA_CCR1_TCIE        ;
     
555.         DMA1_Channel4->CCR |= DMA_CCR1_EN;
     
556. 
     
557.         DMA1_Channel1->CCR = 0;
     
558.         DMA1_Channel1->CPAR = (uint32_t)&ADC1->DR;
     
559.         DMA1_Channel1->CMAR = (uint32_t) adc_dma;
     
560.         DMA1_Channel1->CNDTR = N;
     
561.         DMA1_Channel1->CCR = DMA_CCR1_MINC | DMA_CCR1_PL_0| DMA_CCR1_CIRC|
     
562.                         DMA_MemoryDataSize_HalfWord| DMA_PeripheralDataSize_HalfWord
     
563.                         |DMA_CCR1_TCIE |DMA_CCR1_HTIE
     
564.                         ;
     
565.         DMA1_Channel1->CCR |= DMA_CCR1_EN;
     
566. 
     
567. 
     
568.         // TIM2 CH1
     
569.         DMA1_Channel5->CCR = 0;
     
570.         DMA1_Channel5->CPAR = (uint32_t)&ADC1->SQR3;
     
571.         DMA1_Channel5->CMAR = (uint32_t) &ch;
     
572.         DMA1_Channel5->CNDTR = 1;
     
573.         DMA1_Channel5->CCR = DMA_CCR1_CIRC | DMA_CCR1_DIR |DMA_CCR1_PL|
     
574.                         DMA_MemoryDataSize_Word| DMA_PeripheralDataSize_Word        ;
     
575.         DMA1_Channel5->CCR |= DMA_CCR1_EN;
     
576. 
     
577.         NVIC_EnableIRQ(DMA1_Channel1_IRQn);
     
578.         NVIC_EnableIRQ(DMA1_Channel4_IRQn);
     
579. 
     
580.         ADC1->CR1= ADC_CR1_DISCEN;
     
581.         ADC1->CR2= ADC_CR2_EXTSEL_0 | ADC_CR2_EXTSEL_1 | ADC_CR2_EXTTRIG|ADC_CR2_DMA; // tim2 - cc2
     
582.         ADC1->SMPR2=ADC_SMPR2_SMP7_1|ADC_SMPR2_SMP2_1| ADC_SMPR2_SMP1_1| ADC_SMPR2_SMP0_0;
     
583.         ADC1->SQR1 = 0;
     
584.         ADC1->SQR3 = 1;
     
585. 
     
586.         ADC1->CR2 |=ADC_CR2_ADON;
     
587.         ADC1->CR2 |= ADC_CR2_RSTCAL;
     
588.         while ((ADC1->CR2 & ADC_CR2_RSTCAL) == ADC_CR2_RSTCAL)        {;}
     
589.         ADC1->CR2 |= ADC_CR2_CAL;
     
590.         while ((ADC1->CR2 & ADC_CR2_CAL) == ADC_CR2_CAL)        {;}
     
591. 
     
592.         DAC->CR |= DAC_CR_EN1|DAC_CR_EN2;
     
593.         DAC->DHR12R1 = 1000;
     
594.         DAC->DHR12R2 = 1000;
     
595.         DAC->CR |= DAC_CR_DMAEN2;
     
596. 
     
597.         TIM2->CR1 |= TIM_CR1_CEN;
     
598. 
     
599.         lcd_init();
     
600.         GPIOA->BSRR = GPIO_Pin_15; // BACKLIGHT ON
     
601. 
     
602.         lcd_clear();
     
603. 
     
604.         lcd_gotoxy(0,0);lcd_putstr("  RLC ver 6.03  ");
     
605.         lcd_gotoxy(0,2);lcd_putstr("   Neekeetos    ");
     
606.         lcd_gotoxy(0,3);lcd_putstr("   @yahoo.com   ");
     
607.         lcd_gotoxy(0,4);lcd_putstr(" big thanks to  ");
     
608.         lcd_gotoxy(0,5);lcd_putstr(" TESLight, Link ");
     
609.         lcd_gotoxy(0,7);lcd_putstr("for  radiokot.ru");
     
610. 
     
611.         while( buttons()  != 0 );// wait BUTTON release
     
612. 
     
613.         if( (cstatus & 0xFFFFFF00) != 0x80000000 )
     
614.         {
     
615.                 cstatus = 0x80000000;findex = 0;
     
616.         }
     
617. 
     
618.         if(findex <0 || findex >= FCNT ) findex = 0;
     
619.         freq = flist[findex];
     
620.         fillSine(freq);
     
621. 
     
622.         measure(&Z,16);
     
623. 
     
624.         lcd_clear();
     
625. 
     
626.         R.Re = SHUNT;
     
627.         R.Im = 0;
     
628. 
     
629.         while (1)
     
630.         {
     
631. 
     
632.                 btn = buttons();
     
633. 
     
634.                 if( btn & PWR_BTN )        bl_status = !bl_status;
     
635.                 if( btn & SP_BTN )        rsrp = ! rsrp;
     
636.                 if( btn & REL_BTN )                rel = !rel;
     
637. 
     
638. 
     
639.                 if( btn & SP_BTNL ){
     
640.                         findex++;
     
641.                         if(findex>= FCNT ) findex = 0;
     
642.                         freq = flist[findex];
     
643.                         fillSine(freq);
     
644. 
     
645.                         rsrp = ! rsrp;
     
646.                 }
     
647. 
     
648. 
     
649.                 if( btn & REL_BTNL ){        calibrate();rel =0;cstatus |= (1<<findex);}
     
650.                 if( btn & PWR_BTNL )
     
651.                 {
     
652.                         lcd_clear();
     
653.                         lcd_gotoxy(0,4);print(" Bye Bye..");
     
654.                         powerOff();
     
655.                 }
     
656. 
     
657.                 if(bl_status)
     
658.                 {
     
659.                         GPIOA->BSRR = GPIO_Pin_15; // BACKLIGHT ON
     
660.                 }else{
     
661.                         GPIOA->BRR = GPIO_Pin_15; // BACKLIGHT OFF
     
662.                 }
     
663. 
     
664.                 lcd_gotoxy(0,0);lcd_putstr("                ");
     
665. 
     
666. 
     
667.                 sputdec(s,freq);
     
668.                 lcd_gotoxy(0,0);lcd_putstr(s);lcd_putstr("k  ");
     
669. 
     
670.                 if(rsrp){
     
671.                         lcd_gotoxy(13*6,0);lcd_putstr("PAR");
     
672.                 }else{
     
673.                         lcd_gotoxy(13*6,0);lcd_putstr("SER");
     
674.                 }
     
675. 
     
676.                 if(rel) {
     
677.                         lcd_gotoxy(9*6,0);lcd_putstr(">.<");
     
678.                 }else{
     
679.                         lcd_gotoxy(9*6,0);lcd_putstr("   ");
     
680.                 }
     
681. 
     
682.                 if( (cstatus & (1<<findex)))
     
683.                 {
     
684.                         lcd_gotoxy(6*5,0);lcd_putstr("CAL");
     
685.                 }else{
     
686.                         lcd_gotoxy(6*5,0);lcd_putstr("---");
     
687.                 }
     
688. 
     
689. 
     
690.                 measure(&Z,1);
     
691. 
     
692.                 // zx = zom * (zsm-zxm)/(zxm-zom)
     
693. 
     
694. 
     
695.                 if( (cstatus & (1<<findex)))
     
696.                 {
     
697.                         cplx tmp1,tmp2;
     
698.                         tmp1.Re = Zs[findex].Re - Z.Re;
     
699.                         tmp1.Im = Zs[findex].Im - Z.Im;
     
700. 
     
701.                         tmp2.Re = Zo[findex].Re;
     
702.                         tmp2.Im = Zo[findex].Im;
     
703. 
     
704.                         cplxMul(&tmp2,&tmp1);
     
705. 
     
706.                         tmp1.Re = Z.Re - Zo[findex].Re;
     
707.                         tmp1.Im = Z.Im - Zo[findex].Im;
     
708. 
     
709.                         cplxDiv(&tmp2,&tmp1);
     
710. 
     
711.                         Z.Re = tmp2.Re;
     
712.                         Z.Im = tmp2.Im;
     
713.                 }
     
714. 
     
715.                 Z.Re = filter(0,Z.Re);
     
716.                 Z.Im = filter(1,Z.Im);
     
717. 
     
718.                 if(rel)        {
     
719.                         Z.Re -= base.Re;
     
720.                         Z.Im -= base.Im;
     
721.                 }else{
     
722.                         base.Re= Z.Re ;
     
723.                         base.Im = Z.Im;
     
724.                 }
     
725. 
     
726.                 float ls = Z.Im/6.283185307/(freq*1000.0);
     
727.                 float cs = -1/6.283185307/(freq*1000.0)/Z.Im;
     
728.                 float d = Z.Re/Z.Im;
     
729.                 float d2 = d*d;
     
730.                 float q = 1/d;
     
731. 
     
732.                 if( rsrp == 1)
     
733.                 {
     
734.                         ls = ls*(1+d2);
     
735.                         cs = cs/(1+d2);
     
736.                         Z.Re = Z.Re*(1.0+d2)/d2;
     
737.                 }
     
738. 
     
739.                 round++;
     
740.                 if(round>1)
     
741.                 {
     
742.                         round = 0;
     
743. 
     
744.                         printFloat(12,2,Z.Re,"Ohm");
     
745.                         lcd_gotoxy(0,2);lcd_putstr("  ");
     
746.                         lcd_gotoxy(0,3);lcd_putstr("R>");
     
747. 
     
748.                         if(Z.Im > 0)
     
749.                         {
     
750.                                 printFloat(12,4,ls,"H  ");
     
751.                                 lcd_gotoxy(0,4);lcd_putstr("   ");
     
752.                                 lcd_gotoxy(0,5);lcd_putstr("L>");
     
753.                         }else{
     
754.                                 printFloat(12,4,cs,"F  ");
     
755.                                 lcd_gotoxy(0,4);lcd_putstr("   ");
     
756.                                 lcd_gotoxy(0,5);lcd_putstr("C>");
     
757.                         }
     
758. 
     
759.                         int qq = 10000*( 1.0+absolute(d));        if(qq >19999) qq = 19999;
     
760.                         sputdec(s,qq);
     
761.                         lcd_gotoxy(0,7);lcd_putstr("D .");lcd_putstr(&s[1]);lcd_putstr("    ");
     
762. 
     
763.                         qq = absolute(q);        if(qq >9999) qq = 9999;
     
764.                         sputdec(s,qq);
     
765.                         lcd_gotoxy(8*6,7);lcd_putstr("Q ");lcd_putstr(s);lcd_putstr("    ");
     
766. 
     
767.                         lcd_gotoxy(0,1);lcd_putstr("________________");
     
768.                         lcd_gotoxy(0,6);lcd_putstr("----------------");
     
769. 
     
770.                 }
     
771.         }
     
772. }
     
773. 
     
774. void  __attribute__((optimize("-O3"))) DMA1_Channel1_IRQHandler(void)        {
     
775.         static int process = 0;
     
776.         static int j=0,k=0;
     
777.         static long long mreal[3];
     
778.         static long long mimag[3];
     
779.         int i;
     
780. 
     
781. //        GPIOB->BSRR = GPIO_Pin_14; // set
     
782. 
     
783.         if(process > 0)
     
784.         {
     
785.                 i =0 ;
     
786.                 while(i++ < N/2 )
     
787.                 {
     
788.                         int dat = adc_dma[j] - SINE_OFFSET;
     
789.                         mreal[k] += ((int)sine[j+N/4]*dat);
     
790.                         mimag[k] -= ((int)sine[j]*dat);
     
791.                         j++;
     
792.                 }
     
793.                 if(j >= N ) j = 0;
     
794.         }
     
795. 
     
796.         if(! ( DMA1->ISR & DMA_ISR_HTIF1) )        {process++; j =0;}
     
797. 
     
798.         DMA1->IFCR = DMA1_IT_GL1;
     
799. 
     
800.         if(process > OSR )
     
801.         {
     
802.                 process = 0;
     
803. 
     
804.                 k++;if(k > 2) k = 0;
     
805.                 ch = chn[k];
     
806.                 j = 0;
     
807. 
     
808.                 if( (k == 0) && ( irq_request & IRQ_ADC_SAMPLE) )
     
809.                 {
     
810.                         irq_request &= ~IRQ_ADC_SAMPLE;
     
811.                         mData[0].Re = mreal[0];mData[0].Im = mimag[0];
     
812.                         mData[1].Re = mreal[1];mData[1].Im = mimag[1];
     
813.                         mData[2].Re = mreal[2];mData[2].Im = mimag[2];
     
814.                         irq_status |= IRQ_ADC_SAMPLE;
     
815.                 }
     
816. 
     
817.                 mreal[k] = 0;mimag[k] = 0;
     
818. 
     
819.         }
     
820. 
     
821. 
     
822. 
     
823. //        GPIOB->BRR = GPIO_Pin_14; // reset
     
824. }
     
825. 
     
826. void  __attribute__((optimize("-O3")))  DMA1_Channel4_IRQHandler(void){
     
827.         int j;
     
828.         static int max=(N/DAC_N);
     
829.         static uint32_t * dptr = dac_buf;
     
830.         static int sptr = 0;
     
831.         const uint32_t k = (SINE_OFFSET|(SINE_OFFSET<<16));
     
832. 
     
833.         //GPIOB->BSRR = GPIO_Pin_13; // set
     
834. 
     
835.         if(DMA1->ISR & DMA_ISR_HTIF4 ){
     
836.                 dptr = dac_buf;max--;
     
837.                 if(max <= 0 ){
     
838.                         max = (N/DAC_N);
     
839.                         sptr = 0;
     
840.                 }
     
841. 
     
842.         }
     
843.         DMA1->IFCR = DMA1_IT_GL4;
     
844. 
     
845.         j = DAC_N/2;
     
846. 
     
847.         while(j-- > 0)        {
     
848.                 uint32_t sig =   (( sine[sptr])>>7)&0xffff;
     
849.                 *dptr++ = k + sig -  (sig<<16)  ;sptr++;
     
850.         }
     
851.         //GPIOB->BRR = GPIO_Pin_13; // reset
     
852. }

复制代码

风想101

谢谢分享！

STM129

风想101 发表于 2020-4-2 13:53
谢谢分享！

这个可能是个草稿程序，有死循环跳不出来！到620行：measure(&Z,16);就过不了。TIM2->ARR 应该是71而不是63，由于有死循环跳不出来，现在也搞不清这个仪表是个什么个工作原理。
帮分析下程序工作原理吧