基于stm32的电子称设计 附源码

  使用电阻应变片贴合在形变梁的形变点上，把被测件上的因为重力变化而产生的应变变化转换成电信号，而后通过信号处理电路，进行数据传输。处理电路采用ADS1247芯片，进行信号调理与A/D转换模块和并使用STM32单片机进行控制和数据处理。通过串口通信，将重量数据传输给STC12C5A60S2单片机构建的外围功能模块，实现被测物品重量信息的显示及其他辅助功能。
附有完成的源代码，欢迎各位下载参考。

单片机源程序如下:

1. #include "system.h"
   
2. #include "sht11.h"
   
3. #include "ads1118.h"
   
4. #include "ads1247.h"
   
5. #include "ms5803.h"
   
6. 
   
7. 
   
8. #define RTD_DRDY                (GPIOC->IDR & BIT(9))
   
9. 
   
10. //测试时屏蔽该参数，从而屏蔽设备检测
    
11. //#define NOTEST
    
12. 
    
13. //#define TEST_MODE
    
14. 
    
15. #define FLASH_ADDRESS 0x807f800
    
16. 
    
17. //
    
18. //#define NBLE
    
19. #define BIT(n) (1<<(n))
    
20. 
    
21. #define ADDR 0x2000c000
    
22. #define BUF_SIZE        64                                                                                //滑动滤波队列大小
    
23. #define SQU_SIZE  127                                                                                //中值滤波队列大小
    
24. #define SHIFTERR_THR        20                                                                //误差门限
    
25. #define DESHIFT_TIMSLOT                100                                                //去除漂移间隔时间
    
26. 
    
27. void USART2_Configuration(USART_TypeDef *);
    
28. 
    
29. 
    
30. 
    
31. unsigned char RxBuffer1[40];
    
32. unsigned char RxCounter1;
    
33. 
    
34. unsigned char P2PUart_TestFlag = 0;                        //P2P命令串口测试接收完成标志
    
35. unsigned char Uart3RecFinishFlag = 0;                //串口3接收完成标志
    
36. unsigned char Uart2RecFinishFlag = 0;
    
37. 
    
38. unsigned char RxBuffer2[20];
    
39. unsigned char RxCounter2;
    
40. unsigned char RxBuffer3[20];
    
41. unsigned char RxCounter3;
    
42. 
    
43. 
    
44. 
    
45. signed int Zero_Point = 0;
    
46. signed int Ten_Point = 0;
    
47. signed int Fifty_Point = 0;
    
48. signed int TwoHundred_Point = 0;
    
49. 
    
50. //signed int M_Buf[BUF_SIZE];
    
51. //signed int S_Buf[SQU_SIZE];
    
52. signed int Out_AdcData = 0;
    
53. float Slot = 0;
    
54. 
    
55. unsigned char Uart2_NEmptyFlag = 0;
    
56. unsigned int Uart2_Tim = 0;
    
57. unsigned int Tim = 0;
    
58. 
    
59. extern vu16 ADCConvertedValue[16];
    
60. 
    
61. 
    
62. void Delay_ms(unsigned int Time)
    
63. {
    
64.         unsigned int n;
    
65.         while(Time--)
    
66.                 for(n=0;n<1000;n++);
    
67. }
    
68. 
    
69. 
    
70. 
    
71. 
    
72. 
    
73. void SysTick_IRQHandlar(void)
    
74. {
    
75. 
    
76. }
    
77. 
    
78. 
    
79. 
    
80. 
    
81. unsigned char Str_Cmp(unsigned char *Str1,unsigned char *Str2)
    
82. {
    
83.         while((*Str1) != '\0')
    
84.         {
    
85.                 if(*(Str1++) != *(Str2++))
    
86.                 {
    
87.                         return 0;
    
88.                 }
    
89.         }
    
90.         return 1;
    
91. }
    
92. 
    
93. unsigned char Str_CmpNum(unsigned char *Str1,unsigned char *Str2,unsigned char Num)
    
94. {
    
95.         unsigned char n;
    
96.         for(n=0;n<Num;n++)
    
97.         {
    
98.                 if(*(Str1++) != *(Str2++))
    
99.                 {
    
100.                         return 0;
     
101.                 }
     
102.         }
     
103.         return 1;
     
104. }
     
105. 
     
106. 
     
107. 
     
108. 
     
109. void Quick_Sort(signed int *start,signed char num)
     
110. {
     
111.         signed char i=0,j;
     
112.         j=num;
     
113.        
     
114.         if(num <= 0)
     
115.                 return;
     
116.        
     
117.         while(i != j)
     
118.         {
     
119.                 while(*start <= *(start + j) && i<j)
     
120.                 {
     
121.                         j--;
     
122.                 }
     
123.                 while(*start >= *(start + i) && i<j)
     
124.                 {
     
125.                         i++;
     
126.                 }
     
127.                 if(i<j)
     
128.                 {
     
129.                         *(start+i) ^= *(start+j);
     
130.                         *(start+j) ^= *(start+i);
     
131.                         *(start+i) ^= *(start+j);
     
132.                 }
     
133.         }
     
134.        
     
135.         if(i)
     
136.         {
     
137.                 *start ^= *(start+i);
     
138.                 *(start+i) ^= *start;
     
139.                 *start ^= *(start+i);
     
140.         }
     
141.        
     
142.         Quick_Sort(start,i-1);
     
143.         Quick_Sort(start+i+1,num-i-1);
     
144. }
     
145. 
     
146. 
     
147. signed int Shift_Revise = 0;
     
148. unsigned char DeShift_Tim = 0;
     
149. unsigned char DeShift_Counter = 0;
     
150. signed int Shift_Err = 0;
     
151. signed int Shift_SumErr = 0;
     
152. signed int Shift_LastSum = 0;
     
153. signed char Shift_Err2[10] = {0,0,0,0,0,0,0,0,0,0};
     
154. //signed char Err2_Buf[10];
     
155. 
     
156. signed int Last_Val = 0;
     
157. 
     
158. void De_Shift(void)
     
159. {
     
160.         unsigned char n;
     
161.         signed int temp = 0;
     
162.         Shift_Err = Out_AdcData - Last_Val;
     
163.         Last_Val = Out_AdcData;
     
164.         if((Shift_Err < SHIFTERR_THR) && (Shift_Err > -SHIFTERR_THR))
     
165.         {
     
166.                 Shift_SumErr += Shift_Err;
     
167. //                DeShift_Tim++;
     
168. //                if(DeShift_Tim>10)
     
169. //                {
     
170. //                        DeShift_Tim = 0;
     
171. //                }
     
172. //                Shift_Err2[DeShift_Tim] = Shift_SumErr-Shift_LastSum;
     
173. //                for(n=0;n<10;n++)
     
174. //                {
     
175. //                        temp += Shift_Err2[n];
     
176. //                }
     
177. //                if(temp > 50 || temp < -50)
     
178. //                {
     
179. //                        Shift_SumErr -= temp;
     
180. //                        for(n=0;n<10;n++)
     
181. //                        {
     
182. //                                Shift_Err2[n] = 0;
     
183. //                        }
     
184. //                }
     
185. //                Shift_LastSum = Shift_SumErr;
     
186.         }
     
187.         else
     
188.         {
     
189.                 //DeShift_Tim = 0;
     
190.                 Shift_Revise += Shift_SumErr;
     
191.         }
     
192. //        if(DeShift_Tim > 10)
     
193. //        {
     
194. //                DeShift_Tim = 0;
     
195. //               
     
196. //               
     
197. //                if(Shift_Err2 > 50 || Shift_Err2 < -50)
     
198. //                {
     
199. //                        Shift_SumErr -= Shift_Err2;
     
200. //                }
     
201. //                Shift_LastSum = Shift_SumErr;
     
202. //        }
     
203. //        if(DeShift_Tim > DESHIFT_TIMSLOT)
     
204. //        {
     
205. //                DeShift_Tim = 0;
     
206. //                Shift_Revise = Shift_SumErr;
     
207. //        }
     
208. 
     
209. #ifdef        TEST_MODE
     
210.         printf("Err %d Error2 %d ",Shift_Err,temp);
     
211.         printf("Shift Sum Err is %d ",Shift_SumErr);
     
212. #endif
     
213. }
     
214. 
     
215. 
     
216. 
     
217. 
     
218. void Delay_us(unsigned int nTime)
     
219. {
     
220.         while(nTime--);
     
221. }
     
222. 
     
223. void Save_FlashData(void)
     
224. {
     
225.         unsigned char n;
     
226.         signed int temp,temp1,temp2;
     
227.         temp = TwoHundred_Point-Zero_Point;
     
228.         FLASH_Unlock();
     
229.         FLASH_ErasePage(FLASH_ADDRESS);
     
230.         FLASH_ProgramHalfWord(FLASH_ADDRESS,0xAA55);
     
231.         temp1 = (unsigned int)temp & 0x0000FFFF;
     
232.         FLASH_ProgramHalfWord(FLASH_ADDRESS+2,temp1);
     
233.         temp2 = (((unsigned int)temp) >> 16) & 0x0000ffFF;
     
234.         FLASH_ProgramHalfWord(FLASH_ADDRESS+4,temp2);
     
235.         FLASH_ProgramHalfWord(FLASH_ADDRESS+6,0x33CC);
     
236.         FLASH_Lock();
     
237. #ifdef TEST_MODE
     
238.         printf("Two Handred Data is %d ,Zero_Point is %d ,Temp is %d \r\n",TwoHundred_Point,Zero_Point,temp);
     
239.         printf("temp1 is %d ,temp2 is %d \r\n",temp1,temp2);
     
240.         printf("\r\n....Slot is %f...........\r\n",Slot);
     
241. #endif
     
242. }
     
243. 
     
244. void Read_FlashData(void)
     
245. {
     
246.         u16 temp[4];
     
247.         unsigned int Temp = 0;
     
248.         temp[0] = *(u16*)(FLASH_ADDRESS);
     
249.         temp[1] = *(u16*)(FLASH_ADDRESS + 2);
     
250.         temp[2] = *(u16*)(FLASH_ADDRESS + 4);
     
251.         temp[3] = *(u16*)(FLASH_ADDRESS + 6);
     
252.         if((temp[0] == 0xAA55) && (temp[3] == 0x33CC))
     
253.         {
     
254.                
     
255.                 Temp = (unsigned int)temp[1];
     
256.                 Temp |= (unsigned int)temp[2] << 16;
     
257.                 Slot = (float)(signed int)Temp/(float)200;
     
258.         #ifdef TEST_MODE
     
259.                 printf("Temp1 is %d,Temp2 is %d Temp Data is %d \r\n",temp[1],temp[2],Temp);
     
260.                 printf("Flash Read Successfully....Slot is %f...........\r\n",Slot);
     
261.         #endif
     
262.         }
     
263.         else
     
264.         {
     
265.         #ifdef TEST_MODE
     
266.                 printf("Flash Read Failed...............\r\n");
     
267.         #endif
     
268.         }
     
269. }
     
270. 
     
271. /**
     
272.   * @brief  Main program
     
273.   * @param  None
     
274.   * @retval None
     
275.   */
     
276. int  main (void)
     
277. {
     
278.         unsigned int TIM = 0;
     
279.         unsigned int m,n=0,i;
     
280.         unsigned char off_p,off_n;
     
281.         signed int last_temp,temp,err;
     
282.         signed long OutAdc_Buf=0;
     
283.         unsigned short j=0;
     
284.         signed int *p;
     
285.         double calculate;
     
286.         signed long cal_buf = 0;
     
287.         signed int Sort_Buf[SQU_SIZE];
     
288.         unsigned char Sort_Tim=0;
     
289.         signed int Filtered_Data = 0;
     
290.         signed int Revised_Data = 0;
     
291.        
     
292.        
     
293.         unsigned char Stand_Flag = 0;
     
294.         unsigned char Stand_Tim = 0;
     
295.         signed int Stand_Buf = 0;
     
296.        
     
297. 
     
298.        
     
299.         float Ten_Slope = 0;
     
300.         float Fifty_Slope = 0;
     
301.         float TwoHundred_Slope = 0;
     
302.        
     
303.         unsigned char Init_Counter=60;
     
304.        
     
305.        
     
306. //        signed int disp;
     
307.        
     
308. 
     
309.         RCC_Configuration();
     
310.         NVIC_Configuration();
     
311. 
     
312.         GPIO_Configuration();
     
313.         Delay_ms(50);
     
314.        
     
315.                
     
316.         USART_Configuration(USART1);
     
317. //        USART2_Configuration(USART2);  //配置串口2到控制台
     
318. //        USART_Configuration(USART3);
     
319. 
     
320.         SysTick_SetReload(9000);
     
321.         SysTick_ITConfig(ENABLE);
     
322.         SysTick_CounterCmd(SysTick_Counter_Enable);
     
323. 
     
324. 
     
325. //        adc_init();
     
326.         Delay_ms(50);
     
327.        
     
328. #ifdef NBLE
     
329.         printf("$$$$$$$$44  My Test.... $$$$$$$ \r\n");
     
330. 
     
331. 
     
332. 
     
333.         printf("\n\r ############ www.csgsm.com ############ ("__DATE__ " - " __TIME__ ")\n\r\n\r");
     
334. 
     
335. #endif
     
336. 
     
337. //        EXTI_Configuration();
     
338. 
     
339. #ifdef NBLE
     
340.         printf("################scanning finish####################### \r\n");
     
341. #endif
     
342. 
     
343. #ifdef NBLE
     
344.         printf("################lwIP stack  finish####################### \r\n");
     
345. #endif
     
346. //        ADS1118_Init();
     
347.        
     
348.         LED2(1);
     
349. 
     
350.        
     
351.         watch_dog_config();                 //看门狗测试
     
352. 
     
353.         RTD_Init();
     
354. 
     
355.         p = (signed int *)0x2000c000;
     
356.         //Ms_Reset();
     
357.         //MS5803_Init();
     
358.         //RTD_ContinueStart();
     
359.         cal_buf = 0;
     
360.         for(n=0;n<BUF_SIZE;n++)
     
361.         {
     
362.                 cal_buf += *(p+n);
     
363.         }
     
364.         Read_FlashData();
     
365.         while(1)
     
366.         {
     
367.                
     
368.                 if(!(GPIOC->IDR & BIT(11)))
     
369.                 {
     
370.                         Stand_Flag = 1;
     
371.                 }
     
372.                
     
373. //                if(!(GPIOC->IDR & BIT(12)))
     
374. //                {
     
375. //                        Stand_Flag = 2;
     
376. //                }
     
377. //               
     
378. //                if(!(GPIOD->IDR & BIT(2)))
     
379. //                {
     
380. //                        Stand_Flag = 3;
     
381. //                }
     
382.                
     
383.                 if(!(GPIOB->IDR & BIT(5)))
     
384.                 {
     
385.                         Stand_Flag = 4;
     
386.                 }
     
387.                
     
388.                
     
389.                 n++;
     
390.                 if(n<100)
     
391.                 {
     
392.                         LED1(1);
     
393.                 }
     
394.                 else if(n<200)
     
395.                 {
     
396.                         LED1(0);
     
397.                 }
     
398.                 else
     
399.                 {
     
400.                         n=0;
     
401.                 }
     
402. 
     
403. //        temp = (signed int)RTD_TestOnce();
     
404.                
     
405.                 TIM++;
     
406.                 Sort_Buf[Sort_Tim] = (signed int)RTD_TestOnce();
     
407.                 //test_buf[temp_tim] = disp;
     
408.                 Sort_Tim++;
     
409.                 if(Sort_Tim >= SQU_SIZE)
     
410.                 {
     
411.                         Quick_Sort(Sort_Buf,SQU_SIZE-1);
     
412.                         Sort_Tim = 0;
     
413.                        
     
414.                         cal_buf -= *(p+j);
     
415.                         *(p+j) = Sort_Buf[SQU_SIZE/2];
     
416.                         cal_buf += *(p+j);
     
417.                         j++;
     
418.                         if(j>=BUF_SIZE)
     
419.                         {
     
420.                                 j=0;
     
421.                         }
     
422.                 }
     
423.                
     
424.                 Filtered_Data = cal_buf/BUF_SIZE;
     
425.                
     
426. //                for(k=0;k<BUF_SIZE;k++)
     
427. //                {
     
428. //                        cal_buf += M_Buf[k];
     
429. //                }
     
430.                
     
431.                
     
432.                
     
433.                
     
434.                 OutAdc_Buf += Filtered_Data;
     
435. //                test_buf[TIM-1] = temp;
     
436. //                test = 0;
     
437.                 if(TIM >= 500)
     
438.                 {
     
439.                         if(Init_Counter)
     
440.                         {
     
441.                                 Init_Counter--;
     
442.                                 LED2(Init_Counter%2);
     
443.                                 if(!Init_Counter)
     
444.                                 {
     
445.                                         Stand_Flag = 1;
     
446.                                         LED2(1);
     
447.                                 }
     
448.                         }
     
449. 
     
450.                        
     
451.                         De_Shift();
     
452.                        
     
453.                         Out_AdcData = OutAdc_Buf/500;
     
454.                         OutAdc_Buf = 0;
     
455.                        
     
456.                         Revised_Data = Out_AdcData-Shift_SumErr;
     
457.                        
     
458.                         TIM = 0;
     
459. //                        if(Revised_Data<Ten_Point)
     
460. //                        {
     
461. //                                calculate = ((double)Revised_Data-Zero_Point)/Ten_Slope;
     
462. //                        }
     
463. //                        else if(Revised_Data<Fifty_Point)
     
464. //                        {
     
465. //                                calculate = ((double)Revised_Data-Ten_Point)/Fifty_Slope+10;
     
466. //                        }
     
467. //                        else if(Revised_Data<TwoHundred_Point)
     
468. //                        {
     
469. //                                calculate = ((double)Revised_Data-Fifty_Point)/TwoHundred_Slope+50;
     
470. //                        }
     
471. //                        else
     
472. //                        {
     
473. //                                calculate = ((double)Revised_Data-TwoHundred_Point)/TwoHundred_Slope+200;
     
474. //                        }
     
475.                        
     
476.                         calculate = ((double)Revised_Data-Zero_Point)/Slot;
     
477.                        
     
478.                        
     
479.                        
     
480.                         if(Stand_Flag)
     
481.                         {
     
482.                                 LED2(0);
     
483.                                 Stand_Tim++;
     
484.                                 Stand_Buf += Revised_Data;
     
485.                                
     
486.                                 if(Stand_Tim >= 20)
     
487.                                 {
     
488.                                         switch(Stand_Flag)
     
489.                                         {
     
490.                                                 case 1:                //零点校准
     
491.                                                 {
     
492.                                                         Zero_Point = Stand_Buf/20;
     
493.                                                         Stand_Buf = 0;
     
494.                                                 }break;
     
495. //                                                case 2:                //10克斜率校准
     
496. //                                                {
     
497. //                                                        Ten_Point = Stand_Buf/20;
     
498. //                                                        Ten_Slope = (float)(Ten_Point-Zero_Point)/(float)10;
     
499. ……………………
     
500. 
     
501. …………限于本文篇幅 余下代码请从51黑下载附件…………
     

复制代码

所有资料51hei提供下载:
stm32的电子称程序.rar (4.74 MB, 下载次数: 186)

2017-7-25 23:30 上传

点击文件名下载附件
stm源代码
下载积分: 黑币 -5

想下载学习下

有点难

可以 挺好的资料

可以学习了                  

想要下载学习一下

好资料，非常感谢

“进行信号调理与A/D转换模块和并使用STM32单片机进行控制和数据处理。通过串口通信，将重量数据传输给STC12C5A60S2单片机构建的外围功能模块”   为什么要同时采用stm32和stc12单片机呀。   单独采用stm32解决不了么？

有原理图吗

仿真图哪个版本proteus

liuzhen111 发表于 2020-6-1 23:28
有原理图吗

没有，只有程序