PIC定时器的使用

View Code
  1 TIM0  查询法使LED一秒闪烁,未使用预分频
  2 #include
  3 #define uint unsigned int
  4 #define uchar unsigned char
  5 #define input  RA3
  6 #define clk  RA5
  7 #define cs_led  RE0 
  8 __CONFIG(0x3B31);
  9 
 10 void init();
 11 void delay(uint);
 12 void write_164(uchar);
 13 uint intnum1,intnum2;
 14 void main()
 15 {
 16        init();
 17        while(1)
 18        {
 19               if(T0IF==1)//判断中断溢出位是否溢出,TOIF是否溢出和总中断是否开启无关系。
 20               {
 21                      T0IF=0;//需要软件清零
 22                  intnum1++;
 23                      if(intnum1==3906)//一秒钟到了
 24                     {
 25                             intnum1=0;
 26                             intnum2++;
 27                             cs_led=0;
 28                             if(intnum2==1)
 29                             write_164(0xfd);
 30                             if(intnum2==2)
 31                             {
 32                                    intnum2=0;
 33                                    write_164(0xff);
 34                             }
 35                      }                  
 36               }
 37        }
 38 }
 39 
 40 void init()
 41 {
 42        TRISA=0b11010111;
 43        TRISE=0b11111110;
 44        OPTION=0x08;//使用内部时钟信号,预分频器分配给WDT模块,相当于不给TM0设置预分频,
 45        //一个时钟周期是一秒,当不装初值时,256微秒之后溢出,因为时8位定时器。
 46 }
 47 void delay(uint x)
 48 {
 49        uint a,b;
 50        for(a=x;a>0;a--)
 51               for(b=110;b>0;b--);
 52 }
 53 
 54 void write_164(uchar dt)
 55 {
 56        uchar i;   
 57        for(i=0;i<8;i++)
 58        { 
 59               clk=0;     
 60               if(dt&0x80)
 61                      input=1;
 62               else
 63                      input=0;
 64               dt=dt<<1;                   
 65               clk=1;           
 66        }            
 67 }
 68 
 69 TIM0  查询法使LED一秒闪烁,使用预分频
 70 #include
 71 #define uint unsigned int
 72 #define uchar unsigned char
 73 #define input  RA3
 74 #define clk  RA5
 75 #define cs_led  RE0 
 76 __CONFIG(0x3B31);
 77 
 78 void init();
 79 void delay(uint);
 80 void write_164(uchar);
 81 uint intnum1,intnum2;
 82 void main()
 83 {
 84        init();
 85        while(1)
 86        {
 87               if(T0IF==1)//判断中断溢出位是否溢出,TOIF是否溢出和总中断是否开启无关系。
 88               {
 89                           T0IF=0;//需要软件清零
 90                      TMR0=61;//重新给定时器装初值。
 91                      intnum1++;
 92                      if(intnum1==20)//一秒钟到了
 93                      {
 94                             intnum1=0;
 95                             intnum2++;
 96                             cs_led=0;
 97                             if(intnum2==1)
 98                             write_164(0xfd);
 99                             if(intnum2==2)
100                             {
101                                    intnum2=0;
102                                    write_164(0xff);
103                             }
104                      }
105               }
106        }
107 }
108 
109 void init()
110 {
111        TRISA=0b11010111;
112        TRISE=0b11111110;
113        OPTION=0x07;//使用内部时钟信号,预分频器分配给TIM0模块,256分频。
114        //一个时钟周期是一秒,当不装初值时,256微秒之后溢出,因为时8位定时器。
115        TMR0=61;//256*Y=50000,=>Y=195,256-195=61,这样就是50ms溢出一次,溢出20次就是1s。
116 }
117 
118 void delay(uint x)
119 {
120        uint a,b;
121        for(a=x;a>0;a--)
122               for(b=110;b>0;b--);
123 }
124 
125 void write_164(uchar dt)
126 {
127        uchar i;   
128        for(i=0;i<8;i++)
129        { 
130               clk=0;     
131               if(dt&0x80)
132                      input=1;
133               else
134                      input=0;
135               dt=dt<<1;       
136               clk=1;           
137        }            
138 }
139 
140 TIM0  中断法使LED一秒闪烁,使用预分频
141 #include
142 #define uint unsigned int
143 #define uchar unsigned char
144 #define input  RA3
145 #define clk  RA5
146 #define cs_led  RE0 
147 __CONFIG(0x3B31);
148  
149 void init();
150 void delay(uint);
151 void write_164(uchar);
152 uint intnum1,intnum2;
153 void main()
154 {
155        init();
156       while(1)
157        {
158       if(intnum1==2)//一秒钟到了
159                      {
160                             intnum1=0;
161                             intnum2++;
162                             cs_led=0;
163                             if(intnum2==1)
164                             write_164(0xfd);
165                             if(intnum2==2)
166                             {
167                                    intnum2=0;
168                                    write_164(0xff);                         
169                             }                   
170                      }            
171        }
172 }
173 
174 void init()
175 {
176        TRISA=0b11010111;
177        TRISE=0b11111110;
178        OPTION=0x07;//使用内部时钟信号,预分频器分配给TIM0模块,256分频。
179        //一个时钟周期是一秒,当不装初值时,256微秒之后溢出,因为时8位定时器。
180        INTCON=0xa0;//GIE=1,开总中断,T0IE=1,开启T0中断,T0IE是TMR0 溢出中断允许位。
181        TMR0=61;//256*Y=50000,=>Y=195,256-195=61,这样就是50ms溢出一次,溢出20次就是1s。
182 }
183 
184 void interrupt time0()
185 
186 {
187        T0IF=0;//由于只开启了TMR0中断,所以不用查询是哪个中断,能进来的肯定是TMR0溢出中断,直接将中断溢出标志位清零,
188        TMR0=61;
189        intnum1++;
190 }
191 
192 void delay(uint x)
193 {
194        uint a,b;
195        for(a=x;a>0;a--)
196               for(b=110;b>0;b--);
197 }
198 
199 void write_164(uchar dt)
200 {
201       uchar i;   
202        for(i=0;i<8;i++)
203        { 
204               clk=0;             
205               if(dt&0x80)
206                      input=1;
207               else
208                      input=0;
209               dt=dt<<1;                          
210               clk=1;           
211        }            
212 }
213 
214 TMR1 中断法TIM0  中断法使LED一秒闪烁,不设置预分频。
215 #include
216 #define uint unsigned int
217 #define uchar unsigned char
218 #define input  RA3
219 #define clk  RA5
220 #define cs_led  RE0 
221 
222 __CONFIG(0x3B31);
223 
224  
225 
226 void init();
227 void delay(uint);
228 void write_164(uchar);
229 uint intnum1,intnum2;
230 void main()
231 {
232        init();
233        while(1)
234        {
235                 if(intnum1==20)//一秒钟到了
236 
237                      {
238 
239                             intnum1=0;
240 
241                             intnum2++;
242 
243                             cs_led=0;
244 
245                             if(intnum2==1)
246 
247                             write_164(0xfd);
248 
249                             if(intnum2==2)
250 
251                             {
252 
253                                    intnum2=0;
254 
255                                    write_164(0xff);
256 
257                             
258 
259                             }                   
260 
261                      }            
262 
263        }
264 
265 }
266 
267 void init()
268 
269 {
270 
271        TRISA=0b11010111;
272 
273        TRISE=0b11111110;
274 
275  
276 
277        INTCON=0xc0;//GIE=1,开总中断,开启第一外设中断
278 
279        PIE1=0x01;//开启定时器1的中断
280 
281        TMR1L=(65536-50000)%256;
282 
283        TMR1H=(65536-50000)/256;//进入一次中断,是50ms,
284 
285  
286 
287        T1CON=0x01;//不设置预分频,关闭定时器1晶振使能控制位,与外部时钟同步,选择内部时钟,使能定时器1,
288 
289  
290 
291 }
292 
293 void interrupt time1()
294 
295 {
296 
297        TMR1IF=0;//将中断溢出标志位清零,
298 
299        TMR1L=(65536-50000)%256;
300 
301        TMR1H=(65536-50000)/256;
302 
303        
304 
305        intnum1++;
306 
307 }
308 
309 void delay(uint x)
310 
311 {
312 
313        uint a,b;
314 
315        for(a=x;a>0;a--)
316 
317               for(b=110;b>0;b--);
318 
319  
320 
321 }
322 
323 void write_164(uchar dt)
324 
325 {
326 
327        uchar i;   
328 
329        for(i=0;i<8;i++)
330 
331        { 
332 
333               clk=0;     
334 
335               
336 
337               if(dt&0x80)
338 
339                      input=1;
340 
341               else
342 
343                      input=0;
344 
345               dt=dt<<1;       
346 
347                      
348 
349               clk=1;           
350 
351        }            
352 
353 }
354 
355 TMR1 中断法TIM0  中断法使LED400ms闪烁,设置预分频
356 
357 #include
358 
359 #define uint unsigned int
360 
361 #define uchar unsigned char
362 
363 #define input  RA3
364 
365 #define clk  RA5
366 
367 #define cs_led  RE0 
368 
369  
370 
371 __CONFIG(0x3B31);
372 
373  
374 
375 void init();
376 
377 void delay(uint);
378 
379 void write_164(uchar);
380 
381 uint intnum1,intnum2;
382 
383 void main()
384 
385 {
386 
387        init();
388 
389        while(1)
390 
391        {
392 
393        
394 
395               /*    if(intnum1==20)//一秒钟到了
396 
397                      {
398 
399                             intnum1=0;
400 
401                             intnum2++;
402 
403                             cs_led=0;
404 
405                             if(intnum2==1)
406 
407                             write_164(0xfd);
408 
409                             if(intnum2==2)
410 
411                             {
412 
413                                    intnum2=0;
414 
415                                    write_164(0xff);
416 
417                             
418 
419                             }                   
420 
421                      }*/          
422 
423        }
424 
425 }
426 
427 void init()
428 
429 {
430 
431        TRISA=0b11010111;
432 
433        TRISE=0b11111110;
434 
435  
436 
437        INTCON=0xc0;//GIE=1,开总中断,开启第一外设中断
438 
439        PIE1=0x01;//开启定时器1的中断
440 
441        TMR1L=(65536-50000)%256;
442 
443        TMR1H=(65536-50000)/256;//如果不设置预分频,进入一次中断,是50ms,现在设置8倍预分频,进入一次中断是400ms。
444 
445  
446 
447        T1CON=0x31;//设置8倍预分频,关闭定时器1晶振使能控制位,与外部时钟同步,选择内部时钟,使能定时器1,
448 
449  
450 
451 }
452 
453 void interrupt time1()
454 
455 {
456 
457        TMR1IF=0;//将中断溢出标志位清零,
458 
459        TMR1L=(65536-50000)%256;
460 
461        TMR1H=(65536-50000)/256;
462 
463        
464 
465        //intnum1++;
466 
467               intnum2++;
468 
469                             cs_led=0;
470 
471                             if(intnum2==1)
472 
473                             write_164(0xfd);
474 
475                             if(intnum2==2)
476 
477                             {
478 
479                                    intnum2=0;
480 
481                                    write_164(0xff);
482 
483                             
484 
485                             }                   
486 
487  
488 
489 }
490 
491 void delay(uint x)
492 
493 {
494 
495        uint a,b;
496 
497        for(a=x;a>0;a--)
498 
499               for(b=110;b>0;b--);
500 
501  
502 
503 }
504 
505 void write_164(uchar dt)
506 
507 {
508 
509        uchar i;   
510 
511        for(i=0;i<8;i++)
512 
513        { 
514 
515               clk=0;     
516 
517               
518 
519               if(dt&0x80)
520 
521                      input=1;
522 
523               else
524 
525                      input=0;
526 
527               dt=dt<<1;       
528 
529                      
530 
531               clk=1;           
532 
533        }            
534 
535 }
536 
537 TMR2预分频 后分频       
538 
539 #include
540 
541 #define uint unsigned int
542 
543 #define uchar unsigned char
544 
545 #define input  RA3
546 
547 #define clk  RA5
548 
549 #define cs_led  RE0 
550 
551  
552 
553 __CONFIG(0x3B31);
554 
555  
556 
557 void init();
558 
559 void delay(uint);
560 
561 void write_164(uchar);
562 
563 uint intnum1,intnum2;
564 
565 void main()
566 
567 {
568 
569        init();
570 
571        while(1)
572 
573        {
574 
575        
576 
577                      if(intnum1==1000)//本来预分频1:1时是200ms到了,现在预分频是4.所以是200*4 ms到了,由于后分频1:2,所以是200*4*2 ms
578 
579                      {
580 
581                             intnum1=0;
582 
583                             intnum2++;
584 
585                             cs_led=0;
586 
587                             if(intnum2==1)
588 
589                             write_164(0xfd);
590 
591                             if(intnum2==2)
592 
593                             {
594 
595                                    intnum2=0;
596 
597                                    write_164(0xff);
598 
599                             
600 
601                             }                   
602 
603                      }     
604 
605        }
606 
607 }
608 
609 void init()
610 
611 {
612 
613        TRISA=0b11010111;
614 
615        TRISE=0b11111110;
616 
617  
618 
619        INTCON=0xc0;//GIE=1,开总中断,开启第一外设中断外围功能模块中断
620 
621        PIE1=0x02;//开启定时器2的中断
622 
623  
624 
625        TMR2=56;
626 
627        T2CON=0x0d;//预分频1:4,使能tmr2计数允许/禁止控制位,预分频1:4后分频1:2,
628 
629  
630 
631 }
632 
633 void interrupt time1()
634 
635 {
636 
637        TMR2IF=0;//将中断溢出标志位清零,
638 
639        TMR2=56;
640 
641        
642 
643        intnum1++;
644 
645                             
646 
647  
648 
649 }
650 
651 void delay(uint x)
652 
653 {
654 
655        uint a,b;
656 
657        for(a=x;a>0;a--)
658 
659               for(b=110;b>0;b--);
660 
661  
662 
663 }
664 
665 void write_164(uchar dt)
666 
667 {
668 
669        uchar i;   
670 
671        for(i=0;i<8;i++)
672 
673        { 
674 
675               clk=0;     
676 
677               
678 
679               if(dt&0x80)
680 
681                      input=1;
682 
683               else
684 
685                      input=0;
686 
687               dt=dt<<1;       
688 
689                      
690 
691               clk=1;           
692 
693        }            
694 
695 }
696 
697 TMR2预分频 后分频 周期寄存器
698 
699 #include
700 
701 #define uint unsigned int
702 
703 #define uchar unsigned char
704 
705 #define input  RA3
706 
707 #define clk  RA5
708 
709 #define cs_led  RE0 
710 
711  
712 
713 __CONFIG(0x3B31);
714 
715  
716 
717 void init();
718 
719 void delay(uint);
720 
721 void write_164(uchar);
722 
723 uint intnum1,intnum2;
724 
725 void main()
726 
727 {
728 
729        init();
730 
731        while(1)
732 
733        {
734 
735        
736 
737                      if(intnum1==1000)//本来预分频1:1时是100ms到了,现在预分频是4.所以是100*4 ms到了,由于后分频1:2,所以是100*4*2 ms
738 
739                      {
740 
741                             intnum1=0;
742 
743                             intnum2++;
744 
745                             cs_led=0;
746 
747                             if(intnum2==1)
748 
749                             write_164(0xfd);
750 
751                             if(intnum2==2)
752 
753                             {
754 
755                                    intnum2=0;
756 
757                                    write_164(0xff);
758 
759                             
760 
761                             }                   
762 
763                      }     
764 
765        }
766 
767 }
768 
769 void init()
770 
771 {
772 
773        TRISA=0b11010111;
774 
775        TRISE=0b11111110;
776 
777  
778 
779        INTCON=0xc0;//GIE=1,开总中断,开启第一外设中断外围功能模块中断
780 
781        PIE1=0x02;//开启定时器2的中断
782 
783  
784 
785        TMR2=0;
786 
787        PR2=100;//周期寄存器
788 
789        T2CON=0x0d;//预分频1:4,使能tmr2计数允许/禁止控制位,预分频1:4后分频1:2,
790 
791  
792 
793 }
794 
795 void interrupt time1()
796 
797 {
798 
799        TMR2IF=0;//将中断溢出标志位清零,
800 
801        //TMR2=56;
802 
803        
804 
805        intnum1++;
806 
807                             
808 
809  
810 
811 }
812 
813 void delay(uint x)
814 
815 {
816 
817        uint a,b;
818 
819        for(a=x;a>0;a--)
820 
821               for(b=110;b>0;b--);
822 
823  
824 
825 }
826 
827 void write_164(uchar dt)
828 
829 {
830 
831        uchar i;   
832 
833        for(i=0;i<8;i++)
834 
835        { 
836 
837               clk=0;     
838 
839               
840 
841               if(dt&0x80)
842 
843                      input=1;
844 
845               else
846 
847                      input=0;
848 
849               dt=dt<<1;       
850 
851                      
852 
853               clk=1;           
854 
855        }            
856 
857 }

 

PIC定时程序
  1 TIM0  查询法使LED一秒闪烁,未使用预分频
  2 #include
  3 #define uint unsigned int
  4 #define uchar unsigned char
  5 #define input  RA3
  6 #define clk  RA5
  7 #define cs_led  RE0 
  8 __CONFIG(0x3B31);
  9 
 10 void init();
 11 void delay(uint);
 12 void write_164(uchar);
 13 uint intnum1,intnum2;
 14 void main()
 15 {
 16        init();
 17        while(1)
 18        {
 19             if(T0IF==1)//判断中断溢出位是否溢出,TOIF是否溢出和总中断是否开启无关系。
 20               {
 21                      T0IF=0;//需要软件清零
 22                      intnum1++;
 23                      if(intnum1==3906)//一秒钟到了
 24                      {
 25                             intnum1=0;
 26                             intnum2++;
 27                             cs_led=0;
 28                             if(intnum2==1)
 29                             write_164(0xfd);
 30                             if(intnum2==2)
 31                             {
 32                                   intnum2=0;
 33                                    write_164(0xff);                          
 34                             }                   
 35                      }                     
 36               }
 37        }
 38 }
 39 
 40 void init()
 41 {
 42        TRISA=0b11010111;
 43        TRISE=0b11111110;
 44        OPTION=0x08;//使用内部时钟信号,预分频器分配给WDT模块,相当于不给TM0设置预分频,
 45        //一个时钟周期是一秒,当不装初值时,256微秒之后溢出,因为时8位定时器。
 46 }
 47 
 48 void delay(uint x)
 49 {
 50        uint a,b;
 51        for(a=x;a>0;a--)
 52               for(b=110;b>0;b--);
 53 }
 54 
 55 void write_164(uchar dt)
 56 {
 57        uchar i;   
 58        for(i=0;i<8;i++)
 59        { 
 60               clk=0;                  
 61               if(dt&0x80)
 62                      input=1;
 63               else
 64                      input=0;
 65               dt=dt<<1;                            
 66               clk=1;           
 67        }            
 68 }
 69 
 70 TIM0  查询法使LED一秒闪烁,使用预分频
 71 #include
 72 #define uint unsigned int
 73 #define uchar unsigned char
 74 #define input  RA3
 75 #define clk  RA5
 76 #define cs_led  RE0  
 77 __CONFIG(0x3B31);
 78 void init();
 79 void delay(uint);
 80 void write_164(uchar);
 81 uint intnum1,intnum2;
 82 void main()
 83 {
 84        init();
 85        while(1)
 86        {             
 87               if(T0IF==1)//判断中断溢出位是否溢出,TOIF是否溢出和总中断是否开启无关系。
 88               {
 89                      T0IF=0;//需要软件清零
 90                      TMR0=61;//重新给定时器装初值。
 91                      intnum1++;
 92                      if(intnum1==20)//一秒钟到了
 93                      {
 94                             intnum1=0;
 95                             intnum2++;
 96                             cs_led=0;
 97                             if(intnum2==1)
 98                                        write_164(0xfd);
 99                             if(intnum2==2)
100                             {
101                                   intnum2=0;
102                                    write_164(0xff);                            
103                             }
104                   }
105               }
106        }
107 }
108 
109 void init()
110 {
111        TRISA=0b11010111;
112        TRISE=0b11111110;
113        OPTION=0x07;//使用内部时钟信号,预分频器分配给TIM0模块,256分频。
114        //一个时钟周期是一秒,当不装初值时,256微秒之后溢出,因为时8位定时器。
115        TMR0=61;//256*Y=50000,=>Y=195,256-195=61,这样就是50ms溢出一次,溢出20次就是1s。
116 }
117 
118 void delay(uint x)
119 {
120        uint a,b;
121        for(a=x;a>0;a--)
122               for(b=110;b>0;b--);
123 }
124 
125 void write_164(uchar dt)
126 {
127        uchar i;   
128        for(i=0;i<8;i++)
129        { 
130               clk=0;               
131               if(dt&0x80)
132                      input=1;
133               else
134                      input=0;
135               dt=dt<<1;                            
136               clk=1;           
137        }            
138 }
139 
140 TIM0  中断法使LED一秒闪烁,使用预分频
141 #include
142 #define uint unsigned int
143 #define uchar unsigned char
144 #define input  RA3
145 #define clk  RA5
146 #define cs_led  RE0 
147 __CONFIG(0x3B31);
148 
149 void init();
150 void delay(uint);
151 void write_164(uchar);
152 uint intnum1,intnum2;
153 void main()
154 {
155        init();
156        while(1)
157        {
158                      if(intnum1==2)//一秒钟到了
159                      {
160                             intnum1=0;
161                             intnum2++;
162                             cs_led=0;
163                             if(intnum2==1)
164                             write_164(0xfd);
165                             if(intnum2==2)
166                             {
167                                   intnum2=0;
168                                    write_164(0xff);                            
169                             }                   
170 
171                      }            
172        }
173 }
174 
175 void init()
176 {
177        TRISA=0b11010111;
178        TRISE=0b11111110;
179        OPTION=0x07;//使用内部时钟信号,预分频器分配给TIM0模块,256分频。
180        //一个时钟周期是一秒,当不装初值时,256微秒之后溢出,因为时8位定时器。
181        INTCON=0xa0;//GIE=1,开总中断,T0IE=1,开启T0中断,T0IE是TMR0 溢出中断允许位。
182        TMR0=61;//256*Y=50000,=>Y=195,256-195=61,这样就是50ms溢出一次,溢出20次就是1s。
183 }
184 
185 void interrupt time0()
186 {
187        T0IF=0;//由于只开启了TMR0中断,所以不用查询是哪个中断,能进来的肯定是TMR0溢出中断,直接将中断溢出标志位清零,
188        TMR0=61;
189        intnum1++;
190 }
191 
192 void delay(uint x)
193 {
194        uint a,b;
195        for(a=x;a>0;a--)
196               for(b=110;b>0;b--);
197 }
198 
199 void write_164(uchar dt)
200 {
201        uchar i;   
202        for(i=0;i<8;i++)
203        { 
204               clk=0;                 
205              if(dt&0x80)
206                      input=1;
207               else
208                      input=0;
209               dt=dt<<1;                            
210               clk=1;           
211        }            
212 }
213 
214 TMR1 中断法TIM0  中断法使LED一秒闪烁,不设置预分频。
215 #include
216 #define uint unsigned int
217 #define uchar unsigned char
218 #define input  RA3
219 #define clk  RA5
220 #define cs_led  RE0 
221 __CONFIG(0x3B31);
222 
223  
224 
225 void init();
226 void delay(uint);
227 void write_164(uchar);
228 uint intnum1,intnum2;
229 void main()
230 {
231        init();
232        while(1)
233        {     
234                      if(intnum1==20)//一秒钟到了
235                      {
236                             intnum1=0;
237                             intnum2++;
238                             cs_led=0;
239                             if(intnum2==1)
240                                         write_164(0xfd);
241                             if(intnum2==2)
242                             {
243                                    intnum2=0;
244                                    write_164(0xff);                         
245                             }                   
246                      }            
247        }
248 }
249 
250 void init()
251 {
252        TRISA=0b11010111;
253        TRISE=0b11111110; 
254        INTCON=0xc0;//GIE=1,开总中断,开启第一外设中断
255        PIE1=0x01;//开启定时器1的中断
256        TMR1L=(65536-50000)%256;
257        TMR1H=(65536-50000)/256;//进入一次中断,是50ms, 
258        T1CON=0x01;//不设置预分频,关闭定时器1晶振使能控制位,与外部时钟同步,选择内部时钟,使能定时器1,
259 }
260 
261 void interrupt time1()
262 {
263        TMR1IF=0;//将中断溢出标志位清零,
264        TMR1L=(65536-50000)%256;
265        TMR1H=(65536-50000)/256;       
266        intnum1++;
267 }
268 
269 void delay(uint x)
270 {
271        uint a,b;
272        for(a=x;a>0;a--)
273               for(b=110;b>0;b--);
274 }
275 
276 void write_164(uchar dt)
277 {
278        uchar i;   
279        for(i=0;i<8;i++)
280        { 
281               clk=0;                
282               if(dt&0x80)
283                     input=1;
284               else
285                      input=0;
286               dt=dt<<1;                            
287               clk=1;           
288        }            
289 }
290 
291 TMR1 中断法TIM0  中断法使LED400ms闪烁,设置预分频
292 #include
293 #define uint unsigned int
294 #define uchar unsigned char
295 #define input  RA3
296 #define clk  RA5
297 #define cs_led  RE0 
298 __CONFIG(0x3B31);
299 
300 void init();
301 void delay(uint);
302 void write_164(uchar);
303 uint intnum1,intnum2;
304 void main()
305 {
306        init();
307        while(1)
308        {                   
309               /*    if(intnum1==20)//一秒钟到了
310                    {
311                             intnum1=0;                                                
312                             intnum2++;
313                             cs_led=0;
314                             if(intnum2==1)
315                             write_164(0xfd);
316                             if(intnum2==2)
317                             {
318                                   intnum2=0;
319                                    write_164(0xff);                           
320                             }                   
321                      }*/          
322        }
323 }
324 
325 void init()
326 {
327        TRISA=0b11010111;
328        TRISE=0b11111110; 
329        INTCON=0xc0;//GIE=1,开总中断,开启第一外设中断
330        PIE1=0x01;//开启定时器1的中断
331        TMR1L=(65536-50000)%256;
332        TMR1H=(65536-50000)/256;//如果不设置预分频,进入一次中断,是50ms,现在设置8倍预分频,进入一次中断是400ms。
333        T1CON=0x31;//设置8倍预分频,关闭定时器1晶振使能控制位,与外部时钟同步,选择内部时钟,使能定时器1,
334 }
335 
336 void interrupt time1()
337 {
338        TMR1IF=0;//将中断溢出标志位清零,
339        TMR1L=(65536-50000)%256;
340        TMR1H=(65536-50000)/256;      
341        //intnum1++;
342         intnum2++;
343        cs_led=0;
344         if(intnum2==1)
345              write_164(0xfd);
346          if(intnum2==2)
347             {
348                    intnum2=0;
349                    write_164(0xff);           
350             }                   
351 }
352 
353 void delay(uint x)
354 {
355        uint a,b;
356        for(a=x;a>0;a--)
357               for(b=110;b>0;b--); 
358 }
359 
360 void write_164(uchar dt)
361 {
362        uchar i;   
363        for(i=0;i<8;i++)
364        {                           
365               clk=0;                   
366               if(dt&0x80)
367                      input=1;
368               else                    
369                      input=0;
370               dt=dt<<1;                            
371               clk=1;           
372        }            
373 }
374 
375 TMR2预分频 后分频       
376 #include
377 #define uint unsigned int
378 #define uchar unsigned char
379 #define input  RA3
380 #define clk  RA5
381 #define cs_led  RE0 
382 __CONFIG(0x3B31);
383 
384 void init();
385 void delay(uint);
386 void write_164(uchar);
387 uint intnum1,intnum2;
388 void main()
389 {      
390        init();
391        while(1)
392        {      
393                      if(intnum1==1000)//本来预分频1:1时是200ms到了,现在预分频是4.所以是200*4 ms到了,由于后分频1:2,所以是200*4*2 ms
394                      {
395                             intnum1=0;
396                             intnum2++;
397                             cs_led=0;
398                             if(intnum2==1)
399                             write_164(0xfd);
400                             if(intnum2==2)
401                             {                                  
402                                    intnum2=0;
403                                            write_164(0xff);
404                             }                   
405                      }     
406        }
407 }
408 
409 void init()
410 {
411        TRISA=0b11010111;
412        TRISE=0b11111110;
413        INTCON=0xc0;//GIE=1,开总中断,开启第一外设中断外围功能模块中断
414        PIE1=0x02;//开启定时器2的中断 
415        TMR2=56;
416        T2CON=0x0d;//预分频1:4,使能tmr2计数允许/禁止控制位,预分频1:4后分频1:2,
417 }
418 
419 void interrupt time1()
420 {
421        TMR2IF=0;//将中断溢出标志位清零,
422        TMR2=56;       
423        intnum1++;                           
424 }
425 
426 void delay(uint x)
427 {
428        uint a,b;
429        for(a=x;a>0;a--)
430               for(b=110;b>0;b--);
431 }
432 
433 void write_164(uchar dt)
434 {
435        uchar i;   
436        for(i=0;i<8;i++)
437        { 
438               clk=0;            
439               if(dt&0x80)
440                      input=1;
441               else
442                      input=0;
443               dt=dt<<1;                            
444               clk=1;           
445        }            
446 }
447 TMR2预分频 后分频 周期寄存器
448 #include
449 #define uint unsigned int
450 #define uchar unsigned char
451 #define input  RA3
452 #define clk  RA5
453 #define cs_led  RE0 
454 __CONFIG(0x3B31);
455 void init();
456 void delay(uint);
457 void write_164(uchar);
458 uint intnum1,intnum2;
459 void main()
460 {
461        init();
462        while(1)
463        {     
464                      if(intnum1==1000)//本来预分频1:1时是100ms到了,现在预分频是4.所以是100*4 ms到了,由于后分频1:2,所以是100*4*2 ms
465                      {
466                             intnum1=0;
467                             intnum2++;
468                             cs_led=0;
469                             if(intnum2==1)
470                                     write_164(0xfd);
471                             if(intnum2==2)
472                             {
473                                    intnum2=0;
474                                    write_164(0xff);                          
475                             }                   
476                      }     
477        }
478 }
479 
480 void init()
481 {
482        TRISA=0b11010111;
483        TRISE=0b11111110;
484        INTCON=0xc0;//GIE=1,开总中断,开启第一外设中断外围功能模块中断
485        PIE1=0x02;//开启定时器2的中断
486        TMR2=0;
487        PR2=100;//周期寄存器
488        T2CON=0x0d;//预分频1:4,使能tmr2计数允许/禁止控制位,预分频1:4后分频1:2?
489 }
490 
491 void interrupt time1()
492 {
493        TMR2IF=0;//将中断溢出标志位清零,
494        //TMR2=56;       
495        intnum1++;                           
496 }
497 
498 void delay(uint x)
499 {
500        uint a,b;
501        for(a=x;a>0;a--)
502               for(b=110;b>0;b--);
503 }
504 
505 void write_164(uchar dt)
506 {
507        uchar i;   
508        for(i=0;i<8;i++)
509        { 
510               clk=0;                  
511               if(dt&0x80)
512                      input=1;
513               else
514                     input=0;
515               dt=dt<<1;                           
516               clk=1;           
517        }            
518 }

 

 所谓定时功能就是通过来自单片机内部的时钟脉冲作计数脉冲,使计数器计数,即每个机器周期计数器加1 ,计数值达到予置值后,定时/计数模块产生溢出。

所谓计数是指对外部事件进行计数。外部事件的发生以输入脉冲表示,因此计数功能的实质就是对外来脉冲进行计数。

定时器/ 计数器TMR0 模块的定时工作方式

  对8 位定时器TMR0 来说,不使用分频器时,定时时间的计算公式为:(2-计数初值)×指令周期

  使用分频器时,定时时间的计算公式为:分频比×(28-计数初值) ×指令周期;分频比取值为2 、4 、8…256。

 

         首先强调的是TMR1可以被禁止工作,以降低能耗。要关闭定时/计数模块T M R 1只要将 T M R 1使能位 TMR1ON清0 ,“ 与” 门G1的一个引脚被低电平封锁,就使得累加计数器保持静止状态。对16位定时器TMR1 来说,如选择内部时钟源,则定时时间的计算公式为:

         分频比×(216– 计数初值)  ×指令周期。分频比取值为1 、2 、4、8 。

定时器TMR2模块只有一种工作方式,即定时器工作方式.时钟信
号由内部系统时钟4分频后获取,即取自指令周期信号.
(1)用作周期可调的时基发生器:如指令周期为T,分频比为P1,周期寄存器预赋值为PR2 ,则该周期的计算式为:TTMR2=T×P1×(PR2+1)。

(2)用作延时可调的周期性定时器:如指令周期为T,预分频比为P ,周期寄存器预赋值为PR2 ,后分频比为P2,则该超时溢出周期为:TTMR2IF=T×P1×(PR2+1)×P2
(3)用作普通定时器:如指令周期为T,预分频比为P1,则定时时间为P1×(28-X)×T   (以PIC16F877A为例进行的说明)

你可能感兴趣的:(PIC定时器的使用)