找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
查看: 4142|回复: 10
收起左侧

关于单片机定时器的问题

[复制链接]
ID:223164 发表于 2017-11-18 20:49 | 显示全部楼层 |阅读模式
已经看了很久很久很久了一直未能解决这个问题...很绝望啊,国庆节就写好的,一直找到现在都还不知道哪里出了问题,太难受了!!!这是定时采集温度的单片机程序

  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. }
复制代码

这里定时器启动放在数码管后面 设置一秒定时的时候 时间到了又回到选择时间的界面,如果定时器启动放在数码 ...

这里定时器启动放在数码管后面 设置一秒定时的时候 时间到了又回到选择时间的界面,如果定时器启动放在数码 ...
回复

使用道具 举报

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初值即可。
回复

使用道具 举报

ID:223164 发表于 2017-11-21 10:49 来自手机 | 显示全部楼层
Laptop 发表于 2017-11-19 16:25
定时器提前开的话还没选择几秒测一次就已经测完了

对的是这样 不过 我定时的时间是50ms 利用中断来增加定时时间。然后 关于设定 我也是这样想的 设定一次就够了 后面需要的时候再打开 但是因为这个定时器的打开在数码管前和后有很大区别 在后面1s的时候有问题 然后我就调着调着就把启动放在初始化里了 但是这其实影响不大 主要问题是 启动在数码管后面才是正确的但是有问题。。。放在前面就可以。。。很是郁闷
回复

使用道具 举报

ID:223164 发表于 2017-11-25 21:25 | 显示全部楼层
!!!求大神
回复

使用道具 举报

ID:213173 发表于 2017-11-26 10:26 | 显示全部楼层

你的问题根源根本不在定时器而是在smg()和smg2(),你在这两个子程序里使用死循环while(1),到此除了中断程序外其它程序都无法执行。
回复

使用道具 举报

ID:223164 发表于 2017-11-29 10:13 来自手机 | 显示全部楼层
wulin 发表于 2017-11-26 10:26
你的问题根源根本不在定时器而是在smg()和smg2(),你在这两个子程序里使用死循环while(1),到此除了中断 ...

是的,如果没有按键按下就还在数码管,但本意也是如此 KEY2按下才会去做要做的,相当于确认键。 现在问题就是 定时器启动的位置在数码管后面在1s测量会有问题  其他是没有问题的
回复

使用道具 举报

ID:223164 发表于 2017-11-29 10:15 来自手机 | 显示全部楼层
还有就是最后那个定时器的中断,用了寄存器using 1会有问题。。。不晓得为啥
回复

使用道具 举报

ID:223164 发表于 2017-12-21 16:06 来自手机 | 显示全部楼层
Laptop 发表于 2017-11-29 10:15
还有就是最后那个定时器的中断,用了寄存器using 1会有问题。。。不晓得为啥

还没有解决
回复

使用道具 举报

ID:97438 发表于 2017-12-22 10:39 | 显示全部楼层
T0Init();放到while(1)里????其他没看,就这个已经是致命问题了。
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表