设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › stc11f60xe单片机modbus(RTU)从站源程序可与plc组态王通 ...
返回列表 发新帖
查看: 5614|回复: 3
收起左侧

stc11f60xe单片机modbus(RTU)从站源程序可与plc组态王通信

[复制链接]
ID:76127 发表于 2015-4-8 21:14 | 显示全部楼层 |阅读模式
晶振12M 波特率9200 可与组态王通信 组态王IO设备选择西门子S7-200 MODBUS(RTU)或支持MODBUS 协义的PLC
编译器为KEIL3
单片机型号：STC11F60XE
  1. #include<reg52.h>
  2. #define uchar unsigned char
  3. #define uint unsigned int
  4. #define _irol_(a,b) (a<<b)|(a>>16-b)
  5. #define BIT(A) (1<<A )
  6. #define D0 DW0[0]
  7. #define D1 DW0[1]
  8. #define D2 DW0[2]
  9. #define D3 DW0[3]
  10. #define D4 DW0[4]
  11. #define D5 DW0[5]
  12. #define D6 DW0[6]
  13. #define D7 DW0[7]
  14. #define D8 DW0[8]
  15. #define D9 DW0[9]
  16. #define D10 DW0[10]
  17. #define D11 DW0[11]
  18. #define D12 DW0[12]
  19. #define D13 DW0[13]
  20. #define D14 DW0[14]
  21. #define D15 DW0[15]
  22. #define D16 DW0[16]
  23. #define D17 DW0[17]
  24. #define D18 DW0[18]
  25. #define D19 DW0[19]
  26. #define D20 DW0[20]
  27. #define D21 DW0[21]
  28. #define D22 DW0[22]
  29. #define D23 DW0[23]
  30. #define D24 DW0[24]
  31. #define D25 DW0[25]
  32. #define D26 DW0[26]
  33. #define D27 DW0[27]
  34. #define D28 DW0[28]
  35. #define D29 DW0[29]
  36. #define D30 DW0[30]
  37. #define D31 DW0[31]
  38. unsigned long bdata  M00=0xAAAADCBA;
  39. unsigned int idata DW0[32]={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30} ;//_at_ 0x0000

  41. /*sbit p10=P1^0;
  42. sbit p11=P1^1; */
  43. sbit p12=P1^2;
  44. sbit p13=P1^3;
  45. sbit p14=P1^4;

  47. uchar ac;
  48. uchar at;//结束接收计时;
  49. uint b;
  50. uchar *p;
  51. uchar uartR[80]={2};//接收缓冲区;
  52. bit fcbz;//启动发送标志,发送结束需清零;
  53. bit fcz;//发送中标志位;
  54. uchar fc;//发送数据个数;
  55. uchar fc1;//发送数据现在数;
  56. bit a1;//数据接收中标志位;
  57. bit a2;//数据接收结束标志位;
  58. bit crc1;//crc校验正确位;1有效;
  59. sfr BRT=0X9C;
  60. sfr AUXR1=0XA2;
  61. sfr AUXR=0X8E;
  62. uchar code suzhu[11]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90,0x7f};

  64. sbit P07=P0^7;
  65. void delay(uint a) //延时函数;
  66. {
  67.   while(a--);
  68. }
  69. void time0() interrupt 1 //定时器0中断服务程序,用于提供通信接收空闲结束时钟等;
  70. {
  71.     TH0=0XFE;
  72. TL0=0X0C;
  73. if(a1)
  74. {
  75. at++;
  76. if(at>=100)  //50毫秒无数据流,完成接收;
  77. {a1=0;
  78.   a2=1;
  79.   at=0;
  80. }
  81. }
  82. if(M00&BIT(0))
  83. {
  84. b++;
  85. if(b==1000)
  86. {
  87.     b=0;
  88.   if(M00&BIT(1))M00&=~BIT(1);
  89.   else M00|=BIT(1);
  90. }
  91. if(M00&BIT(1))P07=!P07;
  92. else P07=1;
  93. }
  94. else P07=1;
  95. }
  96. void uartinit() //串口初始化;
  97. {
  98.   SCON=0X50;
  99.   PCON = 0x80;
  100.   AUXR=0X15;
  101.   BRT=217;
  102.   EA=1;
  103.   ES=1;
  104. }
  105. uint crc16(unsigned char *p,A) //调用时把校验数据首地址送给指针p,校验数据个数送给A;
  106. {
  107. uint code pp[256]={0x0000,0xC0C1,0xC181,0x0140,0xC301,0x03C0,0x0280,0xC241,
  108.          0xC601,0x06C0,0x0780,0xC741,0x0500,0xC5C1,0xC481,0x0440,
  109.          0xCC01,0x0CC0,0x0D80,0xCD41,0x0F00,0xCFC1,0xCE81,0x0E40,
  110.          0x0A00,0xCAC1,0xCB81,0x0B40,0xC901,0x09C0,0x0880,0xC841,
  111.          0xD801,0x18C0,0x1980,0xD941,0x1B00,0xDBC1,0xDA81,0x1A40,
  112.          0x1E00,0xDEC1,0xDF81,0x1F40,0xDD01,0x1DC0,0x1C80,0xDC41,
  113.          0x1400,0xD4C1,0xD581,0x1540,0xD701,0x17C0,0x1680,0xD641,
  114.          0xD201,0x12C0,0x1380,0xD341,0x1100,0xD1C1,0xD081,0x1040,
  115.          0xF001,0x30C0,0x3180,0xF141,0x3300,0xF3C1,0xF281,0x3240,
  116.          0x3600,0xF6C1,0xF781,0x3740,0xF501,0x35C0,0x3480,0xF441,
  117.          0x3C00,0xFCC1,0xFD81,0x3D40,0xFF01,0x3FC0,0x3E80,0xFE41,
  118.          0xFA01,0x3AC0,0x3B80,0xFB41,0x3900,0xF9C1,0xF881,0x3840,
  119.          0x2800,0xE8C1,0xE981,0x2940,0xEB01,0x2BC0,0x2A80,0xEA41,
  120.          0xEE01,0x2EC0,0x2F80,0xEF41,0x2D00,0xEDC1,0xEC81,0x2C40,
  121.          0xE401,0x24C0,0x2580,0xE541,0x2700,0xE7C1,0xE681,0x2640,
  122.          0x2200,0xE2C1,0xE381,0x2340,0xE101,0x21C0,0x2080,0xE041,
  123.          0xA001,0x60C0,0x6180,0xA141,0x6300,0xA3C1,0xA281,0x6240,
  124.          0x6600,0xA6C1,0xA781,0x6740,0xA501,0x65C0,0x6480,0xA441,
  125.          0x6C00,0xACC1,0xAD81,0x6D40,0xAF01,0x6FC0,0x6E80,0xAE41,
  126.          0xAA01,0x6AC0,0x6B80,0xAB41,0x6900,0xA9C1,0xA881,0x6840,
  127.          0x7800,0xB8C1,0xB981,0x7940,0xBB01,0x7BC0,0x7A80,0xBA41,
  128.          0xBE01,0x7EC0,0x7F80,0xBF41,0x7D00,0xBDC1,0xBC81,0x7C40,
  129.          0xB401,0x74C0,0x7580,0xB541,0x7700,0xB7C1,0xB681,0x7640,
  130.          0x7200,0xB2C1,0xB381,0x7340,0xB101,0x71C0,0x7080,0xB041,
  131.          0x5000,0x90C1,0x9181,0x5140,0x9301,0x53C0,0x5280,0x9241,
  132.          0x9601,0x56C0,0x5780,0x9741,0x5500,0x95C1,0x9481,0x5440,
  133.          0x9C01,0x5CC0,0x5D80,0x9D41,0x5F00,0x9FC1,0x9E81,0x5E40,
  134.          0x5A00,0x9AC1,0x9B81,0x5B40,0x9901,0x59C0,0x5880,0x9841,
  135.          0x8801,0x48C0,0x4980,0x8941,0x4B00,0x8BC1,0x8A81,0x4A40,
  136.          0x4E00,0x8EC1,0x8F81,0x4F40,0x8D01,0x4DC0,0x4C80,0x8C41,
  137.          0x4400,0x84C1,0x8581,0x4540,0x8701,0x47C0,0x4680,0x8641,
  138.          0x8201,0x42C0,0x4380,0x8341,0x4100,0x81C1,0x8081,0x4040};
  139. uchar i;
  140. uint arc, crc;
  141. crc=0xffff;
  142. for (i=0;i<A;i++ )
  143.     {
  144.    arc= (p[i]^crc)&0x00ff;
  145.      crc=_irol_(crc,8);
  146.      crc= crc & 0x00ff;
  147.      crc= crc^pp[arc];
  148.      }
  149.    return(crc);
  150. }

  152. void modbus1(unsigned char *p,unsigned long M00) //功能码1(读线圈)处理函数;
  153. {
  154.   unsigned int A,B;
  155.   unsigned char i,y,u;

  157.   B=p[4];
  158.   B=B<<8|p[5];//取线圈个数;
  159.   A=p[2];
  160.   A=A<<8|p[3]; //取线圈地址;
  161.   if(B>0&&B<33)
  162.   {
  163.   if(A>=0&&A+B<33)
  164.   {
  165.   fc=B/8;
  166.   for(i=0;i<fc;i++)
  167.   {
  168.     u=0;
  169.   for(y=0;y<8;y++)
  170.   {
  171.    u>>=1;
  172.    if((M00>>A)&0x01 )u|=0x80;
  173.    A++;
  174.    }
  175.    p[i+3]=u;
  176.   }   
  177.   if(B%8)
  178.   {
  179.   fc+=1;
  180.   u=0;
  181.   for(y=0;y<B%8;y++)
  182.   {
  183.    if((M00>>A)&0x01 )u|=0x01<<y;
  184.    A++;  
  185.   }
  186.    p[fc+2]=u;
  187.    }
  188.   p[2]=fc;
  189.   fc+=3;
  190.   }
  191.   else
  192.   {
  193.    p[1]=0x81;
  194.    p[2]=0x02;
  195.    fc=3;
  196.   }
  197.   }
  198.   else
  199.   {
  200.    p[1]=0x81;
  201.    p[2]=0x03;
  202.    fc=3;
  203.   }
  204. }
  205. void modbus2(unsigned char *p,unsigned long M00)//功能码2(读输入离散)处理函数;
  206. {
  207.   unsigned int A,B;
  208.   unsigned char i,y,u;

  210.   B=p[4];
  211.   B=B<<8|p[5];//取IO离散个数;
  212.   A=p[2];
  213.   A=A<<8|p[3];//取IO离散地址;
  214.   if(B>0&&B<33)
  215.   {
  216.   if(A>=0&&A+B<33)
  217.   {
  218.   fc=B/8;
  219.   for(i=0;i<fc;i++)
  220.   {
  221.   u=0;
  222.   for(y=0;y<8;y++)
  223.   {
  224.    u>>=1;
  225.    if((M00>>A)&0x01 )u|=0x80;
  226.    A++;
  227.    }
  228.    p[i+3]=u;
  229.   }   
  230.   if(B%8)
  231.   {
  232. fc+=1;
  233. u=0;
  234.   for(y=0;y<B%8;y++)
  235.   {
  236.    if((M00>>A)&0x01 )u|=0x01<<y;
  237.    A++;   
  238.   }
  239.   
  240.   p[fc+2]=u;
  241.    }
  242.   p[2]=fc;
  243.   fc+=3;
  244.   }
  245.   else
  246.   {
  247.    p[1]=0x82;
  248.    p[2]=0x02;
  249.    fc=3;
  250.   }
  251.   }
  252.   else
  253.   {
  254.    p[1]=0x82;
  255.    p[2]=0x03;
  256.    fc=3;
  257.   }
  258. }
  259. void modbus3(unsigned char *p,unsigned int *p0)//功能码3(读保持寄存器)处理函数;
  260. {
  261.   unsigned int A,B;
  262.   unsigned char i;
  263.   unsigned int *p1;
  264.   p1=p+3;
  265.   B=p[4];
  266.   B=B<<8|p[5]; //取保持寄存器数量;
  267.   A=p[2];
  268.   A=A<<8|p[3];//取保持寄存器地址;
  269.   if(B>0&&B<33)
  270.   {
  271.   if(A>=0&&A+B<33)
  272.   {
  273.   for(i=0;i<B;i++)
  274.   {
  275.    p1[i]=p0[A+i];
  276.   }
  277.   p[2]=B*2;
  278.   fc=B*2+3;

  280.   }
  281.   else
  282.   {
  283.    p[1]=0x83;
  284.    p[2]=0x02;
  285.    fc=3;
  286.   }
  287.   }
  288.   else
  289.   {
  290.    p[1]=0x83;
  291.    p[2]=0x03;
  292.    fc=3;
  293.   }
  294. }
  295. void modbus4(unsigned char *p,unsigned int *p0 ) //功能码4(读输入寄存器)处理函数;
  296. {
  297.   unsigned int A,B;
  298.   unsigned char i;
  299.   unsigned int *p1;
  300.   p1=p+3;
  301.   B=p[4];
  302.   B=B<<8|p[5]; //取输入寄存器个数;
  303.   A=p[2];
  304.   A=A<<8|p[3]; //取输入寄存器地址;
  305.   if(B>0&&B<33)
  306.   {
  307.   if(A>=0&&A+B<33)
  308.   {
  309.   for(i=0;i<B;i++)
  310.   {
  311.    p1[i]=p0[A+i];
  312.   }
  313.   p[2]=B*2;
  314.   fc=B*2+3;
  315.   }
  316.   else
  317.   {
  318.    p[1]=0x84;
  319.    p[2]=0x02;
  320.    fc=3;
  321.   }
  322.   }
  323.   else
  324.   {
  325.    p[1]=0x84;
  326.    p[2]=0x03;
  327.    fc=3;
  328.   }
  329. }
  330. void modbus5(unsigned char *p,unsigned long *p1)//功能码5(写单个线圈)处理函数;
  331. {
  332.   unsigned int A,B,i;
  333.   B=p[4];
  334.   B=B<<8|p[5];//取线圈状态;
  335.   A=p[2];
  336.   A=A<<8|p[3];//取线圈地址;
  337.   if(B==0X0000||B==0XFF00)
  338.   {
  339.   if(A>=0&&A<32)
  340.   {
  341.    i=1;
  342.    if(B==0XFF00)
  343.    {
  344.     p1[0]|=i<<A;
  345.    }
  346.    else M00&=~(i<<A);
  347.    fc=6;
  348.   }
  349.   else
  350.   {
  351.    p[1]=0x85;
  352.    p[2]=0x02;
  353.    fc=3;
  354.   }
  355.   }
  356.   else
  357.   {
  358.    p[1]=0x85;
  359.    p[2]=0x03;
  360.    fc=3;
  361.   }
  362. }
  363. void modbus6(unsigned char *p,unsigned int *p1)//功能码6(写单个寄存器)处理函数;
  364. {
  365.   unsigned int A,B;
  366.   B=p[4];
  367.   B=B<<8|p[5];//取寄存器值;
  368.   A=p[2];
  369.   A=A<<8|p[3];//取寄存器地址;
  370.   if(B>=0X00||B<=0XFFFF)
  371.   {
  372.   if(A>=0&&A<32)
  373.   {
  374.    p1[A]=B;
  375.    fc=6;
  376.   }
  377.   else
  378.   {
  379.    p[1]=0x86;
  380.    p[2]=0x02;
  381.    fc=3;
  382.   }
  383.   }
  384.   else
  385.   {
  386.    p[1]=0x86;
  387.    p[2]=0x03;
  388.    fc=3;
  389.   }
  390. }
  391. void modbus15(unsigned char *p,unsigned long *M00)//功能码15(写多个线圈)处理函数;
  392. {
  393.   unsigned int A,B;
  394.   unsigned char i,y,u;
  395.   unsigned long l;

  397.   B=p[4];
  398.   B=B<<8|p[5]; //取线圈个数;
  399.   A=p[2];
  400.   A=A<<8|p[3];//取线圈地址;
  401.   if(B>0&&B<33)
  402.   {
  403.   if(A>=0&&A+B<33)
  404.   {
  405.   l=1;
  406.   fc=B/8;
  407.   for(i=0;i<fc;i++)
  408.   {
  409.   u=p[i+7];
  410.   for(y=0;y<8;y++)
  411.   {
  412.    if((u>>y)&0x01 )M00[0]|=l<<A;
  413.    else M00[0]&=~(l<<A);
  414.    A++;
  415.    }
  416.   }   
  417.   if(B%8)
  418.   {
  419. if(fc)
  420. {
  421. fc+=1;
  422. u=p[fc+6];
  423. }
  424. else  u=p[7];
  425.   for(y=0;y<B%8;y++)
  426.   {
  427.    if((u>>y)&0x01 )M00[0]|=l<<A;
  428.    else M00[0]&=~(l<<A);
  429.    A++;
  430.   }
  431.   }
  432.   fc=6;
  433.   p14=0;
  434.   }
  435.   else
  436.   {
  437.    p[1]=0x8F;
  438.    p[2]=0x02;
  439.    fc=3;
  440.   }
  441. }
  442.   else
  443.   {
  444.    p[1]=0x8F;
  445.    p[2]=0x03;
  446.    fc=3;
  447.   }
  448. }
  449. void modbus16(unsigned char *p,unsigned int *p1)
  450. {
  451.   unsigned int A,B;
  452.   unsigned int *p0;
  453.   p0=p+7;
  454.   B=p[4];
  455.   B=B<<8|p[5];//取寄存器数量;
  456.   A=p[2];
  457.   A=A<<8|p[3];//取寄存器地址;
  458.   if(B>0&&B<33)
  459.   {
  460.   if(A>=0&&A+B<33)
  461.   {
  462.    p1+=A;
  463.   while(B--)
  464.    {
  465.     p1[0]=p0[0];
  466.     p1++;
  467. p0++;
  468.    }  
  469.    fc=6;
  470.   }
  471.   else
  472.   {
  473.    p[1]=0x90;
  474.    p[2]=0x02;
  475.    fc=3;
  476.    fcbz=1;
  477.    }
  478.   }
  479.   else
  480.   {
  481.    p[1]=0x90;
  482.    p[2]=0x03;
  483.    fc=3;
  484.    fcbz=1;
  485.   }
  486. }
  487. /*void modbus23(unsigned char *p,unsigned int *p1)
  488. {
  489.   unsigned int A,B,AW,BW;
  490.   unsigned int *p0;
  491. // unsigned char u;
  492.   B=p[4];
  493.   B=B<<8|p[5];//取读寄存器数量;
  494.   A=p[2];
  495.   A=A<<8|p[8]; //取读寄存器地址;
  496.   BW=p[8];
  497.   BW=BW<<8|p[9];//取写寄存器数量;
  498.   AW=p[6];
  499.   AW=AW<<8|p[7]; //取写寄存器地址;
  500. if(B>0&&B<33&&BW>0&&BW<33)
  501. {
  502. if(A>=0&&A+B<33&&AW>=0&&AW+BW<33)
  503. {
  504. unsigned char i;
  505.   p1+=AW;
  506.   p0=p+11;
  507.     do
  508.    {
  509.     p1[0]=p0[0];
  510.     p1++;
  511. p0++;
  512.    }while(BW--);
  513.   ////////////////////c=(B&0X00FF)*2;
  514.   p0=p+3;
  515.   p1=p1-AW-BW;
  516.   p1+=A;
  517.     for(i=0;i<B;i++)
  518.   {
  519.    p1[i]=p0[A+i];
  520.   }
  521.   }
  522.   else
  523. {
  524.    p[1]=0x97;
  525.    p[2]=0x02;
  526.    fc=3;
  527. }
  528. }
  529. else
  530. {
  531.    p[1]=0x97;
  532.    p[2]=0x03;
  533.    fc=3;
  534. }
  535.   }*/
  536. void modata(uchar *p,ac)
  537. {
  538. unsigned int a,b;
  539.   p13=0;
  540.   a=p[ac];
  541.   a=(a<<8)|p[ac-1];
  542.   b=crc16(p,ac-1);
  543.   if(a!=b)goto pp;
  544.   p12=0;
  545.   fcbz=1;
  546.   switch(p[1]) //功能码判断与服务函数调用;
  547.   {
  548.   case 1: //读线圈;
  549.   modbus1(uartR, M00);
  550.   break;
  551.   case 2://读输入离散;
  552.   modbus2(uartR, M00);
  553.   break;
  554.   case 3://读保持寄存器;
  555.   modbus3(uartR,DW0);
  556.   break;
  557.   case 4://读输入寄存器;
  558.   modbus4(uartR,DW0);
  559.   break;
  560.   case 5://写单个线圈;
  561.   modbus5(uartR, &M00);
  562.   break;
  563.   case 6://写单个数据寄存器;
  564.   modbus6(uartR, DW0);
  565.   break;
  566.   case 15://写多个连续线圈;
  567.   modbus15(uartR,&M00);
  568.   break;
  569.   case 16://写多个连续寄存器;
  570.   modbus16(uartR,DW0);
  571.   break;
  572. // case 23://读写寄存器;
  573. // modbus23(uartR,DW0);
  574.   break;
  575.   default:
  576.    p[1]+=0x80;
  577.    p[2]=0x01;
  578.    fc=3;
  579.   }
  580. pp:;
  581. }
  582.   modbushy(unsigned char *p ,a)//通讯回应;
  583. {
  584.   unsigned int b;
  585.   b=crc16(p,a);
  586.   p[a]=b;
  587.   a+=1;
  588.   p[a]=b>>8;
  589.   fc=a;
  590.   SBUF=p[0];
  591. }

  593. void uart() interrupt 4 //串口中断函数;
  594. {
  595.   uchar ua;
  596.   if(RI)
  597.   {
  598.    RI=0;
  599.    ua=SBUF;
  600.    if(!a1)
  601.    {
  602.     if(ua==2)
  603. {a1=1;
  604.   ac=0;
  605.   at=0;
  606.   uartR[0]=ua;
  607.   }
  608.    }
  609.    else
  610.    {
  611.    RI=0;
  612.    ac++;
  613.    uartR[ac]=ua;
  614.    at=0; //清零结束接收计时器;
  615.    }
  616.    }
  617.   else
  618.   {
  619.    TI=0;
  620.   if(fc--)
  621.    {
  622.     fc1++;
  623. SBUF=uartR[fc1];
  624.    }
  625.    else fc1=0,fc=0;
  626.   }
  627. }
  628. void sumaguan(uint c)
  629. {
  630.   P2|=0x0f;
  631.   P1=suzhu[c%10];
  632.   P2&=~1;
  633.   delay(300);
  634.   P2|=0x0f;
  635.   P1=suzhu[c%100/10];
  636.   P2&=~4;
  637.   delay(300);
  638.   P2|=0x0f;
  639.   P1=suzhu[c%1000/100];
  640.   //if(b1)P1&=~0x80;
  641.   P2&=~2;
  642.   delay(300);
  643.   P2|=0x0f;
  644.   P1=suzhu[c/1000];
  645.   P2&=~8;
  646. delay(300);
  647. }

  649. void main()
  650. {
  651.     TH0=0XFE;
  652. TL0=0X0C;
  653.   TMOD=0X01;
  654. TR0=1;
  655. EA=1;
  656. ET0=1;
  657. uartinit();
  658. while(1)
  659. {  
  660.   if(!(M00&BIT(0)))M00&=~BIT(1);
  661.     //sumaguan(D1);
  662.     if(a2)modata(uartR,ac),a2=0;
  663.     if(fcbz)modbushy(uartR ,fc),fcbz=0;
  664. }
  665. }
复制代码



西门子, 单片机, 编译器, 源程序, 波特率

相关帖子
回复

使用道具 举报

ID:82719 发表于 2015-6-11 18:50 | 显示全部楼层
你好，请问有51单片机modbus协议的程序吗？
回复

使用道具 举报

ID:428400 发表于 2019-9-17 19:59 | 显示全部楼层
谢谢分享!
回复

使用道具 举报

ID:428400 发表于 2019-9-28 19:35 | 显示全部楼层
有例子吗，大神？
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

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

Powered by 单片机教程网

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