MSP430 single chip microcomputer makes intelligent digital multimeter circuit diagram + program

灞波儿奔

MSP430 single chip microcomputer makes intelligent digital multimeter circuit diagram + program [Copy link]

For those who want to make a multimeter,
the circuit diagram is as follows:

The microcontroller source program is as follows:

1. /*
2. * Simple low power multimeter
3. */
4. #include <msp430g2553.h>
5. #include "LCD12864P.h"
7. unsigned int ADC_flag,ADC_flag1,shua_xin;
8. unsigned int ADC_data[8],ADC_result[8],mser,song,liang_cheng = 0,s,wen_pt,pt100 = 0,zu_zhi = 0;
10. unsigned int data0,data1,data2,data3,data4,data5,data6,data7;
12. //double data0,data1,data2,data3,data4,data5,data6,data7;
13. unsigned int table[]={0x00,0x02,0x01,0x04,0x08,0xEF,0xdf,0xcf,0x80}; //Range selection [1] DC 10V [2] DC 1V [3] Resistance value 10k
15. /*
16. *initialization
17. */
18. void int_t()
19. {
21. WDTCTL = WDT_MDLY_8; // Initialization setting of watchdog timer
22. IE1 |= WDTIE;
23. Ini_Lcd(); //lcd initialization
24. BCSCTL1 = CALBC1_8MHZ;
25. DCOCTL = CALDCO_8MHZ;
26. /*
27. P1DIR &= BIT3+BIT4; /////////Set the key port as input
28. P1REN |= BIT3+BIT4; ////////Turn on the pull-up resistor to generate a trigger edge from high level to low level
29. P1IE |= 0X18; //////////Set key port interrupt
30. P1IES |= 0X18; ////////////Falling edge interrupt. The interrupt is triggered only when the hand is released.
31. */
32. P1DIR &= BIT3; /////////Set the key port as input
33. P1REN |= BIT3; ////////Turn on the pull-up resistor to generate a trigger edge from high level to low level
34. P1IE |= 0X08; //////////Set key port interrupt
35. P1IES |= 0X08; ////////////Falling edge interrupt. The interrupt is triggered only when the hand is released.
37. P2DIR &= ~(BIT2+BIT3+BIT4+BIT5); /////////Set the function selection key to input 1. DC voltage 2. AC voltage 3. Resistance range 4. Capacitance measurement
39. P1DIR |= BIT5 + BIT6 + BIT7 ; // Set the expansion port to output
41. _EINT(); //Enable interrupts. This is an internal process supported by the C compiler.
43. }
44. /*
45. * Key delay program
46. */
47. void delay(unsigned int n) //Function with parameters and return value
48. {
49. unsigned int i;
50. unsigned int j;
51. for(i=n;i>0;i--)
52. for(j=100;j>0;j--)
53. _nop();
54. }
55. /****************************************************** *************
56. * Name: ADC()
57. *Function: AD setting conversion interrupt
58. *************************************************** ******************/
60. void ADC()
61. {
62. P1SEL |= BIT0 + BIT1 + BIT2 + BIT4; //+ BIT3; //+ BIT4 + BIT5 + BIT6 + BIT7; //Set to analog input
63. ADC10AE0 |= BIT0 + BIT1 + BIT2 + BIT4; // + BIT3; // + BIT4 + BIT5 + BIT6 + BIT7; // Open channels A1/A2/A4/A5/A6/A7
64. ADC10CTL0|=ADC10ON+MSC+ADC10SHT_2+ADC10IE; //Turn on ADC conversion, enable ADC10, set the frequency to 16 cycles, and enable interrupts
65. ADC10CTL0 |=SREF_1 + REFON + REF2_5V; //Open the internal reference voltage to 2.5V and enable interrupts
66. ADC10CTL1|=CONSEQ_3+INCH_7; //Use dual (4) channels, circular acquisition mode
67. ADC10DTC1|=0x08; //Continuously sample each channel once
68. _BIS_SR(GIE);
69. }
70. /*
71. *Function: AD data processing
72. */
73. void ADC_DATA()
74. {
75. unsigned char i;
76. ADC10CTL0&=~ENC;
77. while(ADC10CTL1&ADC10BUSY); //Check if AD is busy
78. ADC10CTL0|=ENC+ADC10SC; //Start ADC
79. ADC10SA=(unsigned int)ADC_result; //Get the first address of ADC_result[]. First, sample A1 and A0, and put them into ADC_result[0] and ADC_result[1], and repeat the cycle.
80. for(i=0;i<8;i++)
81. {
82. ADC_data =0;
83. ADC_data =ADC_result ;
84. // ADC_data = (ADC_data * 25) / 1023; // Convert ADC to actual voltage value
85. }
86. }
87. /*
88. * Programming of expansion chip 595
89. */
90. void kuo_zhan(unsigned int dat)
91. {
92. unsigned int i;
93. for(i=0;i<8;i++)
94. {
95. if((dat<<i)&0x80)
96. P1OUT|=BIT5;
97. else
98. P1OUT &= ~BIT5;
99. P1OUT &= ~BIT7;
100. _NOP();
101. P1OUT |= BIT7;
102. _NOP();
103. }
104. P1OUT &= ~BIT6;
105. _NOP();
106. P1OUT |= BIT6;
107. _NOP();
108. }
109. /*
110. * DC voltage detection
111. */
112. void zhi_liu()
113. {
114. unsigned int song_chao;
116. lcd_pos(1,0);
117. Disp_HZ("★Low power multimeter★",8);
119. lcd_pos(2,0);
120. Disp_HZ("DC voltage",4);
122. lcd_pos(3,0);
123. Disp_HZ("Measurement range",4);
125. lcd_pos(4,0);
126. Disp_HZ("Measurement voltage",4);
128. if(liang_cheng == 1) //Data processing when the range is 10v
129. {
130. kuo_zhan(table[1]); //Open 10v channel
131. song_chao = data0*5.8585*0.002443*100; //
132. if(ADC_flag1 == 1)
133. {
134. ADC_flag1 = 0;
135. lcd_pos(3,5);
136. Disp_SZ(10/10);
137. Disp_SZ(10%10);
138. lcd_pos(3,6);
139. Disp_HZ("V",1);
141. lcd_pos(4,5);
142. Disp_SZ(song_chao/1000);
143. Disp_SZ(song_chao%1000/100);
144. Disp_SZ(song_chao%100/10);
145. Disp_SZ(song_chao%10);
147. lcd_pos(4,7);
148. Disp_HZ("V",1);
149. }
150. }
151. else if(liang_cheng == 2) //Data processing when the range is 10v
152. {
153. kuo_zhan(table[2]); //Open 10v channel
154. song_chao = data0*1.9825*0.002443*1000; //
155. if(ADC_flag1 == 1)
156. {
157. ADC_flag1 = 0;
158. lcd_pos(3,5);
159. Disp_SZ(01/10);
160. Disp_SZ(01%10);
161. lcd_pos(3,6);
162. Disp_HZ("V",1);
164. lcd_pos(4,5);
165. Disp_SZ(song_chao/1000);
166. Disp_SZ(song_chao%1000/100);
167. Disp_SZ(song_chao%100/10);
168. Disp_SZ(song_chao%10);
170. lcd_pos(4,7);
171. Disp_HZ("V",1);
172. }
173. }
174. else if(liang_cheng == 3) //Data processing when the range is 10v
175. {
176. kuo_zhan(table[3]); //Open 10v channel
177. song_chao = data0*0.0891*0.002443*1000; //
178. if(ADC_flag1 == 1)
179. {
180. ADC_flag1 = 0;
181. lcd_pos(3,4);
182. Disp_SZ(01/10);
183. Disp_HZ(".",1);
184. Disp_SZ(01%10);
185. lcd_pos(3,6);
186. Disp_HZ("V",1);
188. lcd_pos(4,5);
189. Disp_SZ(song_chao/1000);
190. Disp_SZ(song_chao%1000/100);
191. Disp_SZ(song_chao%100/10);
192. Disp_SZ(song_chao%10);
194. lcd_pos(4,7);
195. Disp_HZ("V",1);
196. }
197. }
198. }
199. /*
200. * AC voltage detection
201. */
202. void jiao_liu()
203. {
204. unsigned int chao_song;
206. lcd_pos(1,0);
207. Disp_HZ("★Low power multimeter★",8);
209. lcd_pos(2,0);
210. Disp_HZ("AC voltage",4);
212. lcd_pos(3,0);
213. Disp_HZ("Measurement range",4);
215. lcd_pos(4,0);
216. Disp_HZ("Measurement voltage",4);
218. if(liang_cheng == 1) //Data processing when the range is 10v
219. {
220. chao_song = data1*3.5*0.002443*100; //
221. if(ADC_flag1 == 1)
222. {
223. ADC_flag1 = 0;
224. lcd_pos(3,4);
225. Disp_SZ(10/10);
226. Disp_SZ(10%10);
227. lcd_pos(3,6);
228. Disp_HZ("V",1);
230. lcd_pos(4,5);
231. Disp_SZ(chao_song/1000);
232. Disp_SZ(chao_song%1000/100);
233. Disp_SZ(chao_song%100/10);
234. Disp_SZ(chao_song%10);
236. lcd_pos(4,7);
237. Disp_HZ("V",1);
238. }
239. }
240. else if(liang_cheng == 2) //Data processing when the range is 10v
241. {
242. chao_song = data1*3.5*0.002443*1000; //
243. if(ADC_flag1 == 1)
244. {
245. ADC_flag1 = 0;
246. lcd_pos(3,4);
247. Disp_SZ(01/10);
248. Disp_SZ(01%10);
249. lcd_pos(3,6);
250. Disp_HZ("V",1);
252. lcd_pos(4,5);
253. Disp_SZ(chao_song/1000);
254. Disp_SZ(chao_song%1000/100);
255. Disp_SZ(chao_song%100/10);
256. Disp_SZ(chao_song%10);
258. lcd_pos(4,7);
259. Disp_HZ("V",1);
260. }
261. }
262. }
263. /*
264. * Resistance voltage detection
265. */
266. void dian_zu()
267. {
268. lcd_pos(1,0);
269. Disp_HZ("★Low power multimeter★",8);
271. lcd_pos(2,0);
272. Disp_HZ("Resistance voltage",4);
274. lcd_pos(3,0);
275. Disp_HZ("Measurement range",4);
277. lcd_pos(4,0);
278. Disp_HZ("Measurement voltage",4);
280. if(liang_cheng == 1) //Data processing when the range is 10v
281. {
282. kuo_zhan(table[5]);
283. if(ADC_flag1 == 1)
284. {
285. zu_zhi = (data2*1.3125*10); //100 ohm data processing
287. ADC_flag1 = 0;
288. lcd_pos(3,5);
289. Disp_SZ(10/10);
290. Disp_SZ(10%10);
291. lcd_pos(3,6);
292. Disp_HZ("K",1);
293. lcd_pos(4,5);
294. Disp_SZ(zu_zhi/1000);
295. Disp_SZ(zu_zhi%1000/100);
296. Disp_SZ(zu_zhi%100/10);
297. Disp_SZ(zu_zhi%10);
299. lcd_pos(4,7);
300. Disp_HZ("V",1);
301. }
302. }
303. else if(liang_cheng == 2) //Data processing when the range is 10v
304. {
305. kuo_zhan(table[6]);
306. if(ADC_flag1 == 1)
307. {
308. zu_zhi = ((data2*0.00125438)/(1-data2*0.00125438))*1870;; //100 ohm data processing
310. ADC_flag1 = 0;
311. lcd_pos(3,5);
312. Disp_SZ(01/10);
313. Disp_SZ(01%10);
314. lcd_pos(3,6);
315. Disp_HZ("K",1);
316. lcd_pos(4,5);
317. Disp_SZ(zu_zhi/1000);
318. Disp_SZ(zu_zhi%1000/100);
319. Disp_SZ(zu_zhi%100/10);
320. Disp_SZ(zu_zhi%10);
322. lcd_pos(4,7);
323. Disp_HZ("V",1);
324. }
325. }
326. else if(liang_cheng == 3) //Data processing when the range is 10v
327. {
328. kuo_zhan(table[7]);
329. if(ADC_flag1 == 1)
330. {
331. zu_zhi = ((data2*0.001244895)/(1-data2*0.001244895))*4950; //10K ohm data processing
333. ADC_flag1 = 0;
334. lcd_pos(3,5);
335. Disp_SZ(100%1000/100);
336. Disp_SZ(100%100/10);
337. Disp_SZ(100%10);
338. lcd_pos(3,7);
339. Disp_HZ("Ω",1);
340. lcd_pos(4,5);
341. Disp_SZ(zu_zhi/1000);
342. Disp_SZ(zu_zhi%1000/100);
343. Disp_SZ(zu_zhi%100/10);
344. Disp_SZ(zu_zhi%10);
346. lcd_pos(4,7);
347. Disp_HZ("V",1);
348. }
349. }
350. }
351. /*
352. * Temperature pt100 function
353. */
354. void wen_du()
355. {
356. wen_pt = ((32231.7975*data4+0.3150709*data4*data4)*0.000016); //Temperature data processing
358. lcd_pos(2,4);
359. Disp_SZ(wen_pt%1000/100);
360. Disp_SZ(wen_pt%100/10);
361. Disp_HZ(".",1); //Charging current
362. Disp_SZ(wen_pt%10);
364. lcd_pos(2,7);
365. Disp_HZ("℃",1);
366. }
367. /*
368. * Main function
369. */
370. void main()
371. {
372. int_t();
373. ADC(); //AD function setting
374. //ADC_DATA(); //AD conversion starts
375. while(1)
376. {
377. ADC_DATA(); //AD conversion starts
379. if(pt100 == 1)
380. {
381. pt100 = 0;
382. wen_du();
383. }
384. if(P2IN & BIT2) //DC voltage detection position
385. {
386. zhi_liu(); //DC voltage range selection control
387. }
388. else if(P2IN & BIT3) //AC voltage detection gear
389. {
390. jiao_liu(); //DC voltage range selection control
391. }
392. else if(P2IN & BIT4) //resistance voltage detection gear
393. {
394. dian_zu(); //DC voltage range selection control
395. }
396. }
397. }
398. /**
399. *Name Watchdog Timer Interrupt
400. **/
401. #pragma vector=WDT_VECTOR
402. __interrupt void watchdog_timer(void)
403. {
404. shua_xin++;
405. if(shua_xin >= 1000)
406. {
407. shua_xin = 0;
408. ADC_flag1 = 1;
409. s++;
410. if(s >= 50)
411. {
412. pt100 = 1;
413. }

alan000345

Nice sharing