久久久久久久999_99精品久久精品一区二区爱城_成人欧美一区二区三区在线播放_国产精品日本一区二区不卡视频_国产午夜视频_欧美精品在线观看免费

 找回密碼
 立即注冊

QQ登錄

只需一步,快速開始

搜索
查看: 5039|回復: 10
打印 上一主題 下一主題
收起左側

關于單片機定時器的問題

[復制鏈接]
跳轉到指定樓層
樓主
已經看了很久很久很久了一直未能解決這個問題...很絕望啊,國慶節就寫好的,一直找到現在都還不知道哪里出了問題,太難受了!!這是定時采集溫度的單片機程序

  1. #include <reg52.h>
  2. #include <intrins.h>
  3. #define uchar unsigned char
  4. #define uint  unsigned int
  5. #define MAIN_Fosc                11059200UL        //宏定義主時鐘HZ
  6. /*====================================
  7. 自定義類型名
  8. ====================================*/
  9. typedef unsigned char INT8U;
  10. typedef unsigned int INT16U;
  11. sbit TSCLK = P1^0;//時鐘線 接到P10上用杜邦線
  12. sbit TIO   = P1^1;//數據線,接到P11上
  13. sbit TRST  = P1^2;//使能端,接到P12上
  14. sbit DS  = P2^2;   //DS18B20單總線
  15. uint  wenduzhi[10];
  16. static n=0;
  17. sbit DU  = P2^6;   //數碼管段選
  18. sbit WE  = P2^7;   //數碼管位選
  19. sbit we = P2^7;
  20. sbit du = P2^6;
  21. sbit KEY1=P3^0;
  22. sbit KEY2=P3^1;
  23. sbit KEY3=P3^2;
  24. sbit KEY4=P3^3;
  25. uchar time_1=1;
  26. uchar shi1=0,shi2=0;
  27. uint  wenduzhi[10]={0};
  28. uint p_1=0;
  29. void timer();
  30. void ds18b20();
  31. unsigned char pp;
  32. /*====================================
  33. 共陰極數碼管段選碼
  34. ====================================*/
  35. uchar code table[]={
  36. //0                1         2     3     4     5     6     7     8
  37. 0x3F, 0x06, 0x5B, 0x4F, 0x66, 0x6D, 0x7D, 0x07, 0x7F,
  38. //9     A     B           C         D           E         F                -         .          關顯示
  39. 0x6F, 0x77, 0x7C, 0x39, 0x5E, 0x79, 0x71, 0x40, 0x80, 0x00
  40.                    };

  41. /*====================================
  42. 數碼管位選碼
  43. ====================================*/
  44.                                   //第1位        2位          3位         4位   5位        6位          7位        8位
  45. uchar code T_COM[] = {0xfe, 0xfd, 0xfb, 0xf7, 0xef, 0xdf, 0xbf, 0x7f};//數碼管位碼
  46. uchar code leddata[]={

  47.                 0x3F,  //"0"
  48.                 0x06,  //"1"
  49.                 0x5B,  //"2"
  50.                 0x4F,  //"3"
  51.                 0x66,  //"4"
  52.                 0x6D,  //"5"
  53.                 0x7D,  //"6"
  54.                 0x07,  //"7"
  55.                 0x7F,  //"8"
  56.                 0x6F,  //"9"
  57.                 0x77,  //"A"
  58.                 0x7C,  //"B"
  59.                 0x39,  //"C"
  60.                 0x5E,  //"D"
  61.                 0x79,  //"E"
  62.                 0x71,  //"F"
  63.                 0x76,  //"H"
  64.                 0x38,  //"L"
  65.                 0x37,  //"n"
  66.                 0x3E,  //"u"
  67.                 0x73,  //"P"
  68.                 0x5C,  //"o"
  69.                 0x40,  //"-"
  70.                 0x00,  //熄滅
  71.                 0x00  //自定義

  72.                          };

  73. void delay1(uint z)
  74. {
  75.         uint x,y;
  76.         for(x = z; x > 0; x--)
  77.                 for(y = 114; y > 0 ; y--);
  78. }
  79. uchar code leddata[];
  80. void delay(uint z)
  81. {
  82.         uint x,y;
  83.         for(x = z; x > 0; x--)
  84.                 for(y = 114; y > 0 ; y--);
  85. }
  86. void Delay_us(uchar us)
  87. {
  88.         while(us--);        
  89. }
  90. void smg()
  91. {
  92.         char i=0;
  93.         unsigned char  sj[4]={1,5,30,60};
  94.         while(1)
  95.         {
  96.         we = 1;
  97.         P0=0x7f;  
  98.         we=0;
  99.         du=1;
  100.         P0=leddata[sj[i]%10];
  101.         du=0;
  102.         delay(5);
  103.         
  104.         we = 1;
  105.         P0=0xbf;        
  106.         we=0;
  107.         du=1;
  108.         P0=leddata[sj[i]/10];
  109.         du=0;
  110.         delay(5);
  111.         
  112.         we = 1;
  113.         P0=0xdf;            
  114.         we=0;
  115.         du=1;
  116.         P0=leddata[22];
  117.         du=0;
  118.         delay(5);
  119.         if(0==KEY1)
  120.         {
  121.                 delay(10);
  122.                 if(0==KEY1)
  123.                 {
  124.                         i++;
  125.                         if(4==i)
  126.                                 i=0;
  127.                         time_1=sj[i];

  128.                 }
  129.         }                                                
  130.         if(0==KEY2)                         //檢測按鍵是否按下
  131.                 {
  132.                         delay(10);           //延時去抖
  133.                         if(0==KEY2)
  134.                         {
  135.                                 break;        
  136.                         }
  137.                 }
  138.         }
  139. }
  140. void Delay_Ms(INT16U ms)
  141. {
  142.      INT16U i;
  143.          do{
  144.               i = MAIN_Fosc / 96000;
  145.                   while(--i);   //96T per loop
  146.      }while(--ms);
  147. }
  148. void Display(uchar Hour, Min, Sec)
  149. {               
  150. //------------------------------
  151.         DU = 0;                                                        
  152.         P0 = table[Hour/10];               
  153.         DU = 1;                                                
  154.         DU = 0;                                                        

  155.         WE = 0;                                                
  156.         P0 = T_COM[0];                                   
  157.         WE = 1;                                                
  158.         WE = 0;                                                
  159.         Delay_Ms(3);
  160. //-------------------------------
  161.         DU = 0;
  162.         P0 = table[Hour%10];           //為了加點|0x80
  163.         DU = 1;
  164.         DU = 0;

  165.         WE = 0;
  166.         P0 = T_COM[1];                          
  167.         WE = 1;
  168.         WE = 0;
  169.         Delay_Ms(3);
  170. //------------------------------
  171.         DU = 0;                                                        
  172.         P0 = table[16];               
  173.         DU = 1;                                                
  174.         DU = 0;                                                        

  175.         WE = 0;                                                
  176.         P0 = T_COM[2];                                   
  177.         WE = 1;                                                
  178.         WE = 0;                                                
  179.         Delay_Ms(3);
  180. //------------------------------
  181.         DU = 0;                                                        
  182.         P0 = table[Min/10];               
  183.         DU = 1;                                                
  184.         DU = 0;                                                        

  185.         WE = 0;                                                
  186.         P0 = T_COM[3];                                   
  187.         WE = 1;                                                
  188.         WE = 0;                                                
  189.         Delay_Ms(3);
  190. //-------------------------------
  191.         DU = 0;
  192.         P0 = table[Min%10];    //  為了加點|0x80   不錯的算法
  193.         DU = 1;
  194.         DU = 0;

  195.         WE = 0;
  196.         P0 = T_COM[4];                        
  197.         WE = 1;
  198.         WE = 0;
  199.         Delay_Ms(3);
  200. //------------------------------
  201.         DU = 0;                                                        
  202.         P0 = table[16];               
  203.         DU = 1;                                                
  204.         DU = 0;                                                        

  205.         WE = 0;                                                
  206.         P0 = T_COM[5];                                   
  207.         WE = 1;                                                
  208.         WE = 0;                                                
  209.         Delay_Ms(3);

  210. //------------------------------
  211.         DU = 0;                                                        
  212.         P0 = table[Sec/10];               
  213.         DU = 1;                                                
  214.         DU = 0;                                                        

  215.         WE = 0;                                                
  216.         P0 = T_COM[6];                                   
  217.         WE = 1;                                                
  218.         WE = 0;                                                
  219.         Delay_Ms(3);
  220. //-------------------------------
  221.         DU = 0;
  222.         P0 = table[Sec%10];
  223.         DU = 1;
  224.         DU = 0;

  225.         WE = 0;
  226.         P0 = T_COM[7];                          
  227.         WE = 1;
  228.         WE = 0;
  229.         Delay_Ms(3);

  230. }

  231. //寫DS1302數據
  232. void Write_DS1302_DAT(uchar cmd, uchar dat)
  233. {
  234.         uchar i;
  235.         TRST = 0; //拉低使能端
  236.         TSCLK = 0;//拉低數據總線
  237.         TRST = 1; //拉高使能端,產生上升沿開始寫數據
  238.         for(i = 0; i < 8; i++)//每次寫1位,寫8次
  239.         {
  240.                 TSCLK = 0;                  //拉低時鐘總線
  241.                 TIO = cmd & 0x01; //寫1位數據,從最低位開始寫
  242.                 TSCLK = 1;                  //拉高時鐘總線,產生上升沿數據被DS1302讀走
  243.                 cmd >>=1;                  //右移一位
  244.         }
  245.         for(i = 0; i < 8; i++)//每次寫1位,寫8次
  246.         {
  247.                 TSCLK = 0;                  //拉低時鐘總線
  248.                 TIO = dat & 0x01; //寫1位數據,從最低位開始寫
  249.                 TSCLK = 1;                  //拉高時鐘總線,產生上升沿數據被DS1302讀走
  250.                 dat >>= 1;                  //右移一位
  251.         }
  252. }
  253. //讀DS1302數據
  254. uchar Read_DS1302_DAT(uchar cmd)
  255. {
  256.         uchar i, dat;
  257.         TRST = 0;  //拉低使能端
  258.         TSCLK = 0; //拉低數據總線
  259.         TRST = 1;  //拉高使能端,產生上升沿開始寫數據
  260.         for(i = 0; i < 8; i++)//每次寫1位,寫8次
  261.         {
  262.                 TSCLK = 0;                 //拉低時鐘總線
  263.                 TIO = cmd & 0x01;//寫1位數據,從最低位開始寫
  264.                 TSCLK = 1;                 //拉高時鐘總線,產生上升沿數據被DS1302讀走
  265.                 cmd >>=1;                 //右移一位
  266.         }
  267.         for(i = 0; i < 8; i++)//每次讀1位,讀8次
  268.         {
  269.                 TSCLK = 0;                  //拉低時鐘總線,產生下降沿,DS1302把數據放到TIO上
  270.                 dat >>= 1;                  //右移一位
  271.                 if(TIO)        dat |= 0x80;//讀取數據,從最低位開始
  272.                 TSCLK = 1;                        //拉高時鐘總線,以備下一次產生下降沿
  273.         }
  274.         return dat;        //返回讀出數據
  275. }

  276. //數據轉BCD碼
  277. uchar Dat_Chg_BCD(uchar dat)
  278. {
  279.         uchar dat1, dat2;
  280.         dat1 = dat / 10;
  281.         dat2 = dat % 10;
  282.         dat2 = dat2 + dat1 * 16;
  283.         return dat2;
  284. }

  285. //BCD碼轉換為數據
  286. uchar BCD_Chg_Dat(uchar dat)
  287. {
  288.         uchar dat1, dat2;
  289.         dat1 = dat / 16;
  290.         dat2 = dat % 16;
  291.         dat2 = dat2 + dat1 * 10;
  292.         return dat2;
  293. }

  294. void ds1302()
  295. {
  296.         uchar i;
  297.         uchar Sec, Min, Hour;
  298.         Write_DS1302_DAT(0x8e, 0);//清除寫保護
  299.         Write_DS1302_DAT(0x80, Dat_Chg_BCD(10));//30秒(并且進行BCD碼轉換)
  300.         Write_DS1302_DAT(0x82, Dat_Chg_BCD(0));//15分
  301.         Write_DS1302_DAT(0x84, Dat_Chg_BCD(0));//19時
  302.         Write_DS1302_DAT(0x8e, 0x80);//開寫保護
  303.         while(1)
  304.         {
  305.                 Write_DS1302_DAT(0x8e, 0); //清除寫保護
  306.                 Sec = BCD_Chg_Dat(Read_DS1302_DAT(0x81));//讀秒寄存器(并且進行BCD碼轉換)
  307.                 Min        = BCD_Chg_Dat(Read_DS1302_DAT(0x83));//讀分寄存器
  308.                 Hour = BCD_Chg_Dat(Read_DS1302_DAT(0x85));//讀時寄存器
  309.                 Write_DS1302_DAT(0x8e, 0x80);//開寫保護
  310.                 for(i = 0; i < 50; i++)        //循環顯示時鐘
  311.                         Display(Hour, Min, Sec);
  312.                  if(n==10)
  313.                          {
  314.                                 TR0=0;
  315.                                 P1=0; //         最好寫0x00 不然后面會誤解 成位 就會 寫錯
  316.                                 break;
  317.                         }
  318.         }
  319. }
  320. bit ds_init()
  321. {
  322.         bit i;
  323.         DS = 1;
  324.         _nop_();
  325.         DS = 0;
  326.         Delay_us(75); //拉低總線499.45us 掛接在總線上的18B20將會全部被復位
  327.         DS = 1; //釋放總線
  328.         Delay_us(4); //延時37.95us 等待18B20發回存在信號
  329.         i = DS;
  330.         Delay_us(20); //141.95us
  331.         DS = 1;
  332.         _nop_();
  333.         return (i);
  334. }
  335. /*寫一個字節*/
  336. void write_byte(uchar dat)
  337. {
  338.         uchar i;
  339.         for(i=0;i<8;i++)
  340.         {
  341.                 DS = 0;
  342.                 _nop_();//產生些時序
  343.                 DS = dat & 0x01;
  344.                 Delay_us(10);//76.95us
  345.                 DS = 1; //釋放總線準備下一次數據寫入
  346.                 _nop_();
  347.                 dat >>= 1;
  348.         }
  349. }

  350. uchar read_byte()
  351. {
  352.         uchar i, j, dat;
  353.         for(i=0;i<8;i++)
  354.         {
  355.                 DS = 0;
  356.                 _nop_();//產生讀時序
  357.                 DS = 1;
  358.                 _nop_();//釋放總線
  359.                 j = DS;
  360.                 Delay_us(10);//76.95us
  361.                 DS = 1;
  362.                 _nop_();
  363.                 dat = (j<<7)|(dat>>1);        
  364.         }
  365.         return (dat);
  366. }
  367. void ds18b20()
  368. {
  369.         uint i;
  370.         uchar L, M;
  371. /*        ds_init();//初始化DS18B20
  372.         write_byte(0xcc);//發送跳躍ROM指令
  373.         write_byte(0x4e);//寫暫存器指令
  374.         write_byte(0x7f);
  375.         write_byte(0xf7);
  376.         write_byte(0x1f);//配置工作在9位模式下
  377.         ds_init();//初始化DS18B20
  378.         write_byte(0xcc);//發送跳躍ROM指令
  379.         write_byte(0x48);*/
  380. //        while(1)
  381. //        {
  382.                 ds_init();//初始化DS18B20
  383.                 write_byte(0xcc);//發送跳躍ROM指令
  384.                 write_byte(0x44);//發送溫度轉換指令
  385.                 ds_init();//初始化DS18B20
  386.                 write_byte(0xcc);//發送跳躍ROM指令
  387.                 write_byte(0xbe);//讀取DS18B20暫存器值
  388.                 L = read_byte();
  389.                 M = read_byte();
  390.                 i = M;
  391.                 i <<= 8;
  392.                 i |= L;                                                
  393.                 i = i * 0.0625 * 10 + 0.5;
  394.         //        Display(i);
  395.                 wenduzhi[n]=i;
  396.                 n++;
  397.                
  398. //        }
  399. }
  400. void smg2()
  401. {
  402.         n=0;
  403.         while(1)
  404.         {
  405.                
  406.                 //------------------------------
  407.                 DU = 0;                                                        
  408.                 P0 = table[16];               
  409.                 DU = 1;                                                
  410.                 DU = 0;                                                        
  411.         
  412.                 WE = 0;                                                
  413.                 P0 = T_COM[0];                                   
  414.                 WE = 1;                                                
  415.                 WE = 0;                                                
  416.                 Delay_Ms(3);
  417.         //-------------------------------
  418.                 DU = 0;
  419.                 P0 = table[n/10];           //為了加點|0x80
  420.                 DU = 1;
  421.                 DU = 0;
  422.         
  423.                 WE = 0;
  424.                 P0 = T_COM[1];                          
  425.                 WE = 1;
  426.                 WE = 0;
  427.                 Delay_Ms(3);
  428.         //------------------------------
  429.                 DU = 0;                                                        
  430.                 P0 = table[n%10];               
  431.                 DU = 1;                                                
  432.                 DU = 0;                                                        
  433.         
  434.                 WE = 0;                                                
  435.                 P0 = T_COM[2];                                   
  436.                 WE = 1;                                                
  437.                 WE = 0;                                                
  438.                 Delay_Ms(3);
  439.         //------------------------------
  440.                 DU = 0;                                                        
  441.                 P0 = table[18];               
  442.                 DU = 1;                                                
  443.                 DU = 0;                                                        
  444.         
  445.                 WE = 0;                                                
  446.                 P0 = T_COM[3];                                   
  447.                 WE = 1;                                                
  448.                 WE = 0;                                                
  449.                 Delay_Ms(3);
  450.         //-------------------------------
  451.                 DU = 0;
  452.                 P0 = table[18];    //  為了加點|0x80   不錯的算法
  453.                 DU = 1;
  454.                 DU = 0;
  455.         
  456.                 WE = 0;
  457.                 P0 = T_COM[4];                        
  458.                 WE = 1;
  459.                 WE = 0;
  460.                 Delay_Ms(3);
  461.         //------------------------------
  462.                 DU = 0;                                                        
  463.                 P0 = table[16];               
  464.                 DU = 1;                                                
  465.                 DU = 0;                                                        
  466.         
  467.                 WE = 0;                                                
  468.                 P0 = T_COM[5];                                   
  469.                 WE = 1;                                                
  470.                 WE = 0;                                                
  471.                 Delay_Ms(3);
  472.         
  473.         //------------------------------
  474.                 DU = 0;                                                        
  475.                 P0 = table[wenduzhi[n]/100];        //溫度值擴大了 10倍 所以有三位數 23.5——235        個位實際上是十位,這樣便于計算
  476.                 DU = 1;                                                
  477.                 DU = 0;                                                        
  478.         
  479.                 WE = 0;                                                
  480.                 P0 = T_COM[6];                                   
  481.                 WE = 1;                                                
  482.                 WE = 0;                                                
  483.                 Delay_Ms(3);
  484.         //-------------------------------
  485.                 DU = 0;
  486.                 P0 = table[wenduzhi[n]/10%10];
  487.                 DU = 1;
  488.                 DU = 0;
  489.         
  490.                 WE = 0;
  491.                 P0 = T_COM[7];                          
  492.                 WE = 1;
  493.                 WE = 0;                                                                                         
  494.                 Delay_Ms(3);
  495.                
  496.         
  497.                 if(0==KEY3)
  498.                 {
  499.                         delay(10);
  500.                         if(0==KEY3)
  501.                         {
  502.                                 n++;
  503.                                 P1=0XFF;
  504.                         //        P1=1;          這里p1是一個字節有八位 送1的話會默認為是十進制 也就是0x01了
  505.                                 if(10==n)
  506.                                         n=0;
  507.                         }
  508.                 }
  509.                 if(0==KEY4)
  510.                 {
  511.                         delay(10);
  512.                         if(0==KEY4)
  513.                         {
  514.                                 break;
  515.                         }
  516.                 }
  517.         }
  518.                
  519. }
  520. void T0Init()
  521. {
  522.         TMOD=0X01;
  523.         TL0 = 0x00;                //設置定時初值
  524.         TH0 = 0x4C;                //設置定時初值                 50MS
  525.         TR0=1;
  526.         ET0=1;
  527.         EA=1;        
  528. }
  529. void main()
  530. {         
  531.         while(1)
  532.         {
  533. //                T0Init();
  534.                 smg();
  535.                 T0Init();//在數碼管之后不行 1秒的時候會異常 在按鍵里設置tr0=1也是一樣。
  536.                 ds1302();
  537.                 smg2();
  538.         }
  539. }
  540. void T0timer()  interrupt 1        //using 1   //加上會出現異常,我也不知道為什么
  541. {
  542.         p_1++;
  543.         TL0 = 0x00;                //設置定時初值
  544.         TH0 = 0x4C;                //設置定時初值                 50MS
  545.         switch(time_1)
  546.         {
  547.                 case(1):
  548.                                 if(p_1==20)
  549.                                 {
  550.                                         p_1=0;
  551.                                         ds18b20();
  552.                                 }
  553.                 case(5):
  554.                                 if(p_1==100)
  555.                                 {
  556.                                          p_1=0;
  557.                                         ds18b20();
  558.                                 }
  559.                 case(30):
  560.                                 if(p_1==600)
  561.                                 {
  562.                                         p_1=0;
  563.                                         ds18b20();
  564.                                 }
  565.                 case(60):
  566.                                 if(p_1==1200)
  567.                                 {
  568.                                         p_1=0;
  569.                                         ds18b20();
  570.                                 }
  571.         }
  572. }
復制代碼

111111111111111111111111.png (8.53 KB, 下載次數: 98)

這里定時器啟動放在數碼管后面 設置一秒定時的時候 時間到了又回到選擇時間的界面,如果定時器啟動放在數碼 ...

這里定時器啟動放在數碼管后面 設置一秒定時的時候 時間到了又回到選擇時間的界面,如果定時器啟動放在數碼 ...
分享到:  QQ好友和群QQ好友和群 QQ空間QQ空間 騰訊微博騰訊微博 騰訊朋友騰訊朋友
收藏收藏 分享淘帖 頂 踩
回復

使用道具 舉報

沙發
ID:213173 發表于 2017-11-19 07:13 | 只看該作者
void main()
{         
        T0Init();
        while(1)
        {
                smg();
                ds1302();
                smg2();
        }       
}
回復

使用道具 舉報

板凳
ID:223164 發表于 2017-11-19 16:25 | 只看該作者
wulin 發表于 2017-11-19 07:13
void main()
{         
        T0Init();

定時器提前開的話還沒選擇幾秒測一次就已經測完了
回復

使用道具 舉報

地板
ID:213173 發表于 2017-11-19 20:34 | 只看該作者
Laptop 發表于 2017-11-19 16:25
定時器提前開的話還沒選擇幾秒測一次就已經測完了

你還沒有掌握定時器的使用方法。普通51單片機如果外接12M晶振,定時器最大定時周期65.5ms,想得到更長的定時時間通常使用定時器中斷計數。不是特別需要不要在程序中頻繁更改定時器設定,而是根據需要打開或關閉定時器或定時器中斷。所以定時器初始化函數放在主循環前面,如果有必要改變定時器定時周期只要在其函數中打開定時器TR0前重裝TH0、TL0初值即可。
回復

使用道具 舉報

5#
ID:223164 發表于 2017-11-21 10:49 來自手機 | 只看該作者
Laptop 發表于 2017-11-19 16:25
定時器提前開的話還沒選擇幾秒測一次就已經測完了

對的是這樣 不過 我定時的時間是50ms 利用中斷來增加定時時間。然后 關于設定 我也是這樣想的 設定一次就夠了 后面需要的時候再打開 但是因為這個定時器的打開在數碼管前和后有很大區別 在后面1s的時候有問題 然后我就調著調著就把啟動放在初始化里了 但是這其實影響不大 主要問題是 啟動在數碼管后面才是正確的但是有問題。。。放在前面就可以。。。很是郁悶
回復

使用道具 舉報

6#
ID:223164 發表于 2017-11-25 21:25 | 只看該作者
!!求大神
回復

使用道具 舉報

7#
ID:213173 發表于 2017-11-26 10:26 | 只看該作者
Laptop 發表于 2017-11-25 21:25
!!求大神

你的問題根源根本不在定時器而是在smg()和smg2(),你在這兩個子程序里使用死循環while(1),到此除了中斷程序外其它程序都無法執行。
回復

使用道具 舉報

8#
ID:223164 發表于 2017-11-29 10:13 來自手機 | 只看該作者
wulin 發表于 2017-11-26 10:26
你的問題根源根本不在定時器而是在smg()和smg2(),你在這兩個子程序里使用死循環while(1),到此除了中斷 ...

是的,如果沒有按鍵按下就還在數碼管,但本意也是如此 KEY2按下才會去做要做的,相當于確認鍵。 現在問題就是 定時器啟動的位置在數碼管后面在1s測量會有問題  其他是沒有問題的
回復

使用道具 舉報

9#
ID:223164 發表于 2017-11-29 10:15 來自手機 | 只看該作者
還有就是最后那個定時器的中斷,用了寄存器using 1會有問題。。。不曉得為啥
回復

使用道具 舉報

10#
ID:223164 發表于 2017-12-21 16:06 來自手機 | 只看該作者
Laptop 發表于 2017-11-29 10:15
還有就是最后那個定時器的中斷,用了寄存器using 1會有問題。。。不曉得為啥

還沒有解決
回復

使用道具 舉報

11#
ID:97438 發表于 2017-12-22 10:39 | 只看該作者
T0Init();放到while(1)里????其他沒看,就這個已經是致命問題了。
回復

使用道具 舉報

您需要登錄后才可以回帖 登錄 | 立即注冊

本版積分規則

手機版|小黑屋|51黑電子論壇 |51黑電子論壇6群 QQ 管理員QQ:125739409;技術交流QQ群281945664

Powered by 單片機教程網

快速回復 返回頂部 返回列表
主站蜘蛛池模板: 国产成人精品999在线观看 | 国产精品二区三区在线观看 | 日韩欧美国产精品一区二区 | 日本高清不卡视频 | 青青久久久| 网络毛片 | 国产日韩免费观看 | 国产精品一区二区三区久久久 | 国产精品一区在线观看你懂的 | 欧美成人免费在线 | zzzwww在线看片免费 | 免费观看日韩精品 | 国产a一区二区 | 久久精品成人一区 | 一级做a爰片性色毛片16美国 | 欧美视频一区二区三区 | 日韩成人在线播放 | 国产特级毛片aaaaaa喷潮 | 中文字幕中文字幕 | 日韩伦理一区二区 | 日韩一区二区在线视频 | 91精品国产91久久久 | www.性色| 欧美自拍另类 | 日韩综合在线视频 | 久久久青草婷婷精品综合日韩 | 欧洲精品一区 | 黄色一级免费 | 精品免费看 | 日本免费一区二区三区四区 | 日韩视频在线免费观看 | 国产精品国产a | 黄色大片网站 | 午夜av电影院 | 国产精品美女久久久久久免费 | 少妇特黄a一区二区三区88av | 毛片大全 | 国产1页| 成人在线中文字幕 | 二区av | 97av视频在线观看 |