查看: 434|回复: 0

[经验] MSP430 G2553 Launchpad实现电容测量

[复制链接]

该用户从未签到

发表于 2020-12-6 22:48:41 | 显示全部楼层 |阅读模式
分享到:
测试代码
main.c程序:


  
  1. 1 // C meter 2015.9.26
  2.   2 //
  3.   3 // P1.5(TA0.0) --[||||]----------- P1.4(CA3)
  4.   4 //             R=10kOhm     |
  5.   5 //                       -----
  6.   6 //                   cap -----
  7.   7 //                         |
  8.   8 //                        GND
  9.   9 //  http://zlbg.cnblogs.com
  10. 10 /////////////////////////////////////////
  11. 11
  12. 12 #include "io430.h"
  13. 13
  14. 14 #define LED1 BIT0 // P1.0, red led
  15. 15 #define LED2 BIT6 // P1.6, green led
  16. 16
  17. 17 #define VMEAS BIT4 // P1.4(CA4) for voltage measurement of the cap
  18. 18 #define VCTRL BIT5 // P1.5(TA0.0) for voltage control
  19. 19 #define PUSH2 BIT3 // P1.3, button
  20. 20
  21. 21 #define RXD BIT1 //P1.1
  22. 22 #define TXD BIT2 //P1.2
  23. 23
  24. 24 #define READY 0
  25. 25 #define CHARGING 1
  26. 26 #define DISCHARGING 2
  27. 27 #define FINISH_DC 3
  28. 28
  29. 29 #define R_SERIES 10000 //10kOhm
  30. 30 #define LN4 1.3863
  31. 31
  32. 32 //functions for C meter
  33. 33 void P1Init(void);
  34. 34 void TA0Init(void);
  35. 35 void CAInit(void);
  36. 36  
  37. 37 void setReadyStatus(void);
  38. 38
  39. 39 //functions for printf()
  40. 40 void sendByte(unsigned char);
  41. 41 void printf(char *, ...);
  42. 42 void initUART(void);
  43. 43
  44. 44 char state = READY;
  45. 45 unsigned char overflowsCharging = 0;
  46. 46 unsigned char overflowsDischarging = 0;
  47. 47 unsigned char i = 0;
  48. 48 float capacitance = 0; // unit: nF
  49. 49
  50. 50 void main(void)
  51. 51 {
  52. 52     // Stop watchdog timer to prevent time out reset
  53. 53     WDTCTL = WDTPW + WDTHOLD;
  54. 54     
  55. 55     // DCO setup
  56. 56     BCSCTL1 = CALBC1_1MHZ; //running at 1Mhz
  57. 57     DCOCTL = CALDCO_1MHZ;
  58. 58     
  59. 59     // P1 setup
  60. 60     P1Init();
  61. 61     
  62. 62     // Timer0 setup
  63. 63     TA0Init();
  64. 64     
  65. 65     // CA setup
  66. 66     CAInit();  
  67. 67     
  68. 68     // UART setup
  69. 69     initUART();
  70. 70     
  71. 71     setReadyStatus();
  72. 72     
  73. 73     __enable_interrupt();
  74. 74     
  75. 75     // enter LP mode
  76. 76     LPM0;
  77. 77     
  78. 78 }
  79. 79
  80. 80
  81. 81 void P1Init(void)
  82. 82 {
  83. 83     P1OUT = 0;
  84. 84     
  85. 85     // set P1.3 (PUSH2) as input with pullup
  86. 86     P1OUT |= PUSH2;
  87. 87     P1REN |= PUSH2;
  88. 88         
  89. 89     // set P1.0, P1.6, P1.5 as output
  90. 90     P1DIR |= LED1 + LED2 + VCTRL;
  91. 91  
  92. 92     // enable P1.3 interrupt
  93. 93     P1IES |= PUSH2; // high -> low transition
  94. 94     P1IFG &= ~PUSH2; // clear the flag
  95. 95     P1IE |= PUSH2;
  96. 96 }
  97. 97
  98. 98 void TA0Init(void)
  99. 99 {
  100. 100     // use SMCLK (1MHz), no div, clear, halt
  101. 101     TA0CTL = TASSEL_2 + ID_0 + MC_0 + TACLR;
  102. 102     
  103. 103     // TA0CCTL0: compare mode, enable interrupt
  104. 104     TA0CCTL0 = CCIE;
  105. 105     
  106. 106     // TA0CCTL1: capture mode, no capture, CCI1B(CAOUT) input, syn capture
  107. 107     // interrupt enabled
  108. 108     TA0CCTL1 = CCIS_1 + SCS + CAP + CCIE;
  109. 109 }
  110. 110
  111. 111 void CAInit(void)
  112. 112 {
  113. 113     //0.25 Vcc ref on V+, halt
  114. 114     CACTL1 = CAREF_1 + CAIES;
  115. 115     // input CA4 (P1.4), remove the jumper) on V-, filter on
  116. 116     CACTL2 = P2CA3 + CAF;
  117. 117 }
  118. 118
  119. 119 void setReadyStatus(void)
  120. 120 {   
  121. 121     state = READY;
  122. 122     // light led2 and turn off led1 to indicate ready
  123. 123     P1OUT &= ~LED1;
  124. 124     P1OUT |= LED2;
  125. 125     
  126. 126     //stop and clear timer, stop T0_A1 capture & CA+
  127. 127     TA0CTL = TASSEL_2 + ID_0 + MC_0 + TACLR;
  128. 128     TA0CCTL1 &= ~CM_3;
  129. 129     CACTL1 &= ~CAON;
  130. 130     
  131. 131     overflowsCharging = 0;
  132. 132 }
  133. 133
  134. 134 void initUART(void) {  
  135. 135         //config P1.1 RXD, P1.2 TXD
  136. 136         P1SEL |= TXD + RXD;
  137. 137         P1SEL2 |= TXD + RXD;
  138. 138         
  139. 139         //reset UCA0, to be configured
  140. 140         UCA0CTL1 = UCSWRST;
  141. 141         //config
  142. 142         UCA0CTL1 |= UCSSEL_2; //SMCLK
  143. 143         UCA0BR0 = 104;
  144. 144         UCA0BR1 = 0;//1MHz baut rate = 9600 8-N-1
  145. 145         UCA0MCTL = UCBRS0; // Modulation UCBRSx = 1
  146. 146         //make UCA0 out of reset
  147. 147         UCA0CTL1 &= ~UCSWRST;
  148. 148 }
  149. 149
  150. 150
  151. 151 void sendByte(unsigned char byte )
  152. 152 {
  153. 153     while (!(IFG2&UCA0TXIFG));            // USCI_A0 TX buffer ready?
  154. 154     UCA0TXBUF = byte;                // TX -> RXed character
  155. 155 }
  156. 156
  157. 157 #pragma vector = PORT1_VECTOR
  158. 158 __interrupt void P1_ISR(void)
  159. 159 {
  160. 160     if((P1IFG & PUSH2) == PUSH2)
  161. 161     {
  162. 162         P1IFG &= ~PUSH2; //clear the flag
  163. 163         switch(state)
  164. 164         {
  165. 165         case READY:
  166. 166             state = CHARGING;
  167. 167             // light LED1 and turn off LED2, indicate a busy status
  168. 168             P1OUT |= LED1;
  169. 169             P1OUT &= ~LED2;
  170. 170             //start timer, continuous mode
  171. 171             TACTL |= MC_2;
  172. 172             //start charging
  173. 173             P1OUT |= VCTRL;
  174. 174             break;
  175. 175         default:
  176. 176             break;
  177. 177         }
  178. 178         
  179. 179     }
  180. 180     else
  181. 181     {
  182. 182         P1IFG = 0;
  183. 183     }
  184. 184 }
  185. 185
  186. 186 #pragma vector = TIMER0_A0_VECTOR
  187. 187 __interrupt void CCR0_ISR(void)
  188. 188 {
  189. 189     switch(state)
  190. 190     {
  191. 191     case CHARGING:
  192. 192         if (++overflowsCharging == 50) // wait 6.5535*50 = 3.28s
  193. 193         {
  194. 194             state = DISCHARGING;
  195. 195             CACTL1 |= CAON; // turn on CA+
  196. 196             TA0CCTL1 |= CM_1; // start TA1 capture on rising edge
  197. 197             P1OUT &= ~VCTRL; // start discharging     
  198. 198             overflowsDischarging = 0;
  199. 199         }
  200. 200         break;
  201. 201     case DISCHARGING:
  202. 202         overflowsDischarging++;
  203. 203     default:
  204. 204         break;
  205. 205         
  206. 206     }
  207. 207
  208. 208 }
  209. 209
  210. 210 #pragma vector = TIMER0_A1_VECTOR
  211. 211 __interrupt void CCR1_ISR(void)
  212. 212 {
  213. 213     TA0CTL &= ~MC_3; //stop timer
  214. 214     TA0CCTL1 &= ~CCIFG; // clear flag
  215. 215     switch(state)
  216. 216     {
  217. 217     case DISCHARGING:
  218. 218         state = FINISH_DC;        
  219. 219         capacitance = (overflowsDischarging*65536 + TA0CCR1)*1000 / (R_SERIES*LN4); //nF
  220. 220         //send result to PC     
  221. 221         printf("Capatitance:  %n", (long unsigned)capacitance);
  222. 222         printf(" nF\r\n");
  223. 223         
  224. 224         setReadyStatus();
  225. 225         break;
  226. 226     default:
  227. 227         break;
  228. 228     }
  229. 229 }
复制代码


回复

使用道具 举报

您需要登录后才可以回帖 注册/登录

本版积分规则

关闭

站长推荐上一条 /4 下一条



手机版|小黑屋|与非网

GMT+8, 2024-11-25 17:02 , Processed in 0.111304 second(s), 15 queries , MemCache On.

ICP经营许可证 苏B2-20140176  苏ICP备14012660号-2   苏州灵动帧格网络科技有限公司 版权所有.

苏公网安备 32059002001037号

Powered by Discuz! X3.4

Copyright © 2001-2024, Tencent Cloud.