Arduino 怎么使用定时器产生 微妙级的中断

songjiahaonanna

想通过 IO 口定时器模拟出 PWM 波，但现在所知定时器只有毫秒级的，想产生 500HZ 的方波。。

幻生幻灭

之前做过一个方波发生器，参考下

1. // Set CS10&CS11 bit for 64 prescaler
   
2. //  OCR1A = 255;
   
3. //Pe = 2, pu = 1 cycle about 2 ms freq = 490Hz
   
4. //Pe = 4, pu = 2 cycle about 4 ms freq = 247Hz
   
5. //Pe = 6, pu = 3 cycle about 6 ms freq = 165Hz
   
6. //Pe = 7, pu = 4 cycle about 7 ms freq = 140Hz
   
7. //Pe = 8, pu = 4 cycle about 8 ms freq = 125Hz
   
8. //  OCR1A = 30;
   
9. //Pe = 2, pu = 1 cycle about 0.1 ms freq = 4.03kHz
   
10. //Pe = 4, pu = 2 cycle about 0.5 ms freq = 2.00kHz
    
11. //Pe = 6, pu = 3 cycle about 0.8 ms freq = 1.35kHz
    
12. //Pe = 8, pu = 4 cycle about 1 ms freq = 1.00kHz
    
13. //  OCR1A = 25;
    
14. //Pe = 2, pu = 1 cycle about 0.2 ms freq = 4.83kHz
    
15. //Pe = 10, pu = 5 cycle about 1 ms freq = 960Hz
    
16. //Pe = 23, pu = 11 cycle about 2.2 ms freq = 420Hz
    
17. //Pe = 40, pu = 20 cycle about 4 ms freq = 244Hz(****)
    
18. //Pe = 50, pu = 25 cycle about 5.2 ms freq = 193Hz
    
19. //Pe = 100, pu = 50 cycle about 10 ms freq = 100Hz
    
20. //Pe = 1000, pu = 500 cycle about 100 ms freq = 9.7Hz
    
21. //Pe = 2000, pu = 1000 cycle about 200 ms freq = 5Hz
    
22. //Pe = 5000, pu = 2500 cycle about 510 ms freq = 1.9Hz(****)
    
23. 
    
24. //Hardware connection
    
25. //R10Kx2 + 1.5K
    
26. //R20K(电位器） +1.5K
    
27. //Measure Range: 4.651V(0 - 950)
    
28. //Period Range: 40 - 5000
    
29. //Calculation: Period = 40 + A0*5(Range: 40 - 4790)
    
30. //Calculation: PulseWidth = int((A1/950)*period)
    
31. 
    
32. //Hardware Define
    
33. int pinFreq = A2;
    
34. int pinPulseWidth = A1;
    
35. int pinFreqR = A3;
    
36. int pinPulseWidthR = A0;
    
37. int pinLed = 3;
    
38. int pinPWM = 4;
    
39. int pinKey = 5;
    
40. int pinKeyV = 6;
    
41. int pinKeyG = 7;
    
42. int pinKeyVisu = 13;
    
43. //variables for PW pot monitoring
    
44. float pulseWidth;
    
45. int pulseWidthScaled;
    
46. int PWCurrent;
    
47. byte PWTolerance = 2;//adjust this to increase/decrease stability of PW measurement
    
48. 
    
49. //variables for freq pot monitoring
    
50. int frequency;
    
51. int freqCurrent;
    
52. byte freqTolerance = 2;//adjust this to increase/decrease stability of frequency measurement
    
53. unsigned int freqscaled;
    
54. 
    
55. int t;
    
56. int period;
    
57. 
    
58. int testMode = 0; //Default is 0;
    
59. int freqPreTest;
    
60. int PWPreTest;
    
61. //int cycleISR = 4; //unit us
    
62. //定义一个comdata字符串变量，赋初值为空值
    
63. String comdata = "";
    
64. //numdata是分拆之后的数字数组
    
65. int numdata[2] = {
    
66.   0};
    
67. int mark = 0;
    
68. 
    
69. void setup() {
    
70.   Serial.begin(9600);
    
71.   //set port/pin  mode
    
72.   pinMode(pinLed, OUTPUT);   
    
73.   pinMode(pinPWM, OUTPUT);
    
74.   pinMode(pinKeyV, OUTPUT);
    
75.   pinMode(pinKeyG, OUTPUT);
    
76.   pinMode(pinKeyVisu, OUTPUT);
    
77.   pinMode(pinKey, INPUT);
    
78.   digitalWrite(pinKeyV, HIGH);
    
79.   digitalWrite(pinKeyG, LOW);
    
80.   digitalWrite(pinKeyVisu, LOW);
    
81. 
    
82. 
    
83.   //TIMER INTERRUPT SETUP
    
84.   cli();//disable interrupts
    
85.   //timer 1:
    
86.   TCCR1A = 0;// set entire TCCR1A register to 0
    
87.   TCCR1B = 0;// same for TCCR1B
    
88.   //set compare match register- 100khz to start
    
89.   OCR1A = 25; //period = 0.1ms
    
90.   //turn on CTC mode
    
91.   TCCR1B |= (1 << WGM12);
    
92.   // Set CS10&CS11 bit for 64 prescaler
    
93.   TCCR1B |= (1 << CS10) | (1 << CS11);
    
94.   // enable timer compare interrupt
    
95.   TIMSK1 |= (1 << OCIE1A);
    
96. 
    
97.   //initialize variables 200Hz
    
98.   t = 0;
    
99.   period = 48;
    
100.   pulseWidthScaled = 24;
     
101. 
     
102.   sei();//enable interrupts
     
103. 
     
104.   if(testMode == 1){
     
105.     Serial.println(" ");
     
106.     Serial.println("Test Mode Actived!");
     
107.   }
     
108. }
     
109. 
     
110. 
     
111. //Leo checked
     
112. ISR(TIMER1_COMPA_vect){//timer 1 interrupt
     
113.   //increment t and reset each time it reaches period
     
114.   t += 1;
     
115.   if (t >= period){
     
116.     t = 0;
     
117.   }
     
118.   if (pulseWidthScaled <= t) {
     
119.     //PORTD = 0xff;
     
120.     digitalWrite(pinPWM, HIGH);
     
121.     digitalWrite(pinLed, HIGH);
     
122.   }
     
123.   else{
     
124.     //PORTD = 0x00;
     
125.     digitalWrite(pinPWM, LOW);  
     
126.     digitalWrite(pinLed, LOW);  
     
127.   }
     
128. }
     
129. 
     
130. //Leo checked
     
131. void loop() {
     
132.   if(testMode == 1) SerialInput();
     
133.   checkFreq();
     
134.   checkPW();
     
135.   if(digitalRead(pinKey) == HIGH){
     
136.     digitalWrite(pinKeyVisu, HIGH);
     
137.   }
     
138.   else{
     
139.     digitalWrite(pinKeyVisu, LOW);
     
140.   }
     
141. }
     
142. 
     
143. //Leo checked
     
144. void checkFreq() {
     
145.   if(digitalRead(pinKey) == HIGH){
     
146.     freqCurrent = analogRead(pinFreq);
     
147.   }
     
148.   else{
     
149.     freqCurrent = analogRead(pinFreqR);
     
150.   }
     
151.   if(testMode == 1) freqCurrent = freqPreTest;
     
152.   if (abs(freqCurrent-frequency)>freqTolerance){//if reading from pot exceeds tolerance
     
153.     frequency = freqCurrent;
     
154.     period = 40 + frequency*5; //Range: 40 - 4790
     
155.   }
     
156. }
     
157. 
     
158. //Leo checked
     
159. void checkPW() {
     
160.   if(digitalRead(pinKey) == HIGH){
     
161.     PWCurrent = analogRead(pinPulseWidth);
     
162.   }
     
163.   else{
     
164.     PWCurrent = analogRead(pinPulseWidthR);
     
165.   }
     
166.   if(testMode == 1) PWCurrent = PWPreTest;
     
167.   if (abs(PWCurrent-pulseWidth)>PWTolerance){//if reading from pot exceeds tolerance
     
168.     pulseWidth = PWCurrent;//new pulse width, val between 0 and 1023
     
169.     if(digitalRead(pinKey) == HIGH){
     
170.       pulseWidthScaled = int((pulseWidth/930)*period);
     
171.     }
     
172.     else{
     
173.       pulseWidthScaled = int((pulseWidth/1023)*period);
     
174.     }
     
175.   }
     
176. }
     
177. 
     
178. //Leo checked
     
179. void SerialInput(){
     
180.   //j是分拆之后数字数组的位置记数
     
181.   int j = 0;
     
182. 
     
183.   //不断循环检测串口缓存，一个个读入字符串，
     
184.   while (Serial.available() > 0)
     
185.   {
     
186.     //读入之后将字符串，串接到comdata上面。
     
187.     comdata += char(Serial.read());
     
188.     //延时一会，让串口缓存准备好下一个数字，不延时会导致数据丢失，
     
189.     delay(2);
     
190.     //标记串口读过数据，如果没有数据的话，直接不执行这个while了。
     
191.     mark = 1;
     
192.   }
     
193. 
     
194.   if(mark == 1)  //如果接收到数据则执行comdata分析操作，否则什么都不做。
     
195.   {
     
196.     //显示刚才输入的字符串（可选语句）
     
197.     //Serial.println(comdata);
     
198.     //显示刚才输入的字符串长度（可选语句）
     
199.     //Serial.println(comdata.length());
     
200. 
     
201.     /*******************下面是重点*******************/
     
202.     //以串口读取字符串长度循环，
     
203.     for(int i = 0; i < comdata.length() ; i++)
     
204.     {
     
205.       //逐个分析comdata[i]字符串的文字，如果碰到文字是分隔符（这里选择逗号分割）则将结果数组位置下移一位
     
206.       //即比如11,22,33,55开始的11记到numdata[0];碰到逗号就j等于1了，
     
207.       //再转换就转换到numdata[1];再碰到逗号就记到numdata[2];以此类推，直到字符串结束
     
208.       if(comdata[i] == ',')
     
209.       {
     
210.         j++;
     
211.       }
     
212.       else
     
213.       {
     
214.         //如果没有逗号的话，就将读到的数字*10加上以前读入的数字，
     
215.         //并且(comdata[i] - '0')就是将字符'0'的ASCII码转换成数字0（下面不再叙述此问题，直接视作数字0）。
     
216.         //比如输入数字是12345，有5次没有碰到逗号的机会，就会执行5次此语句。
     
217.         //因为左边的数字先获取到，并且numdata[0]等于0，
     
218.         //所以第一次循环是numdata[0] = 0*10+1 = 1
     
219.         //第二次numdata[0]等于1，循环是numdata[0] = 1*10+2 = 12
     
220.         //第三次是numdata[0]等于12，循环是numdata[0] = 12*10+3 = 123
     
221.         //第四次是numdata[0]等于123，循环是numdata[0] = 123*10+4 = 1234
     
222.         //如此类推，字符串将被变成数字0。
     
223.         numdata[j] = numdata[j] * 10 + (comdata[i] - '0');
     
224.       }
     
225.     }
     
226.     //comdata的字符串已经全部转换到numdata了，清空comdata以便下一次使用，
     
227.     //如果不请空的话，本次结果极有可能干扰下一次。
     
228.     comdata = String("");
     
229. 
     
230.     period = numdata[0];
     
231.     pulseWidthScaled = numdata[1];
     
232.     Serial.println("P----------------");
     
233.     if(digitalRead(pinKey) == HIGH){
     
234.       Serial.println("IN2 & IN3 is actived! ");
     
235.     }
     
236.     else{
     
237.       Serial.println("IN1 & IN4 is actived! ");
     
238.     }
     
239.     Serial.print("period: ");
     
240.     Serial.println(period);
     
241.     Serial.print("pulseWidthScaled: ");
     
242.     Serial.println(pulseWidthScaled);
     
243.     //循环输出numdata的内容，并且写到PWM引脚
     
244.     for(int i = 0; i < 2; i++)
     
245.     {
     
246.       numdata[i] = 0;
     
247.     }
     
248.     //输出之后必须将读到数据的mark置0，不置0下次循环就不能使用了。
     
249.     mark = 0;
     
250.   }
     
251. }
     
252. 
     

复制代码

Ref:
http://www.instructables.com/id/ ... or-Shield/?ALLSTEPS
Arduino学习笔记A6（补充） - 在串口读取多个字符串，并且转换为数字数组
http://www.geek-workshop.com/thread-260-1-1.html

wdjkzym

不是有US级的么  

seagatecm

@幻生幻灭，为什么在中断程序里面没有重置TCNT1的值？

songjiahaonanna

wdjkzym 发表于 2015-6-19 13:27
不是有US级的么

毫秒级的不够么，如果我要产生 500 HZ 的方波，就得 2MS 一个周期，还怎么去控制电机的具体转速。。。。

suoma

songjiahaonanna 发表于 2015-6-23 09:13
毫秒级的不够么，如果我要产生 500 HZ 的方波，就得 2MS 一个周期，还怎么去控制电机的具体转速。。。。

              US、微秒

songjiahaonanna

suoma 发表于 2015-6-23 18:46
US、微秒

定时器 1 有毫秒级别的，，，，找到了。。