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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › STM32/8 › STM32驱动RC522代码分享
返回列表 发新帖
查看: 2681|回复: 0
收起左侧

STM32驱动RC522代码分享

[复制链接]
ID:297748 发表于 2018-11-29 11:59 | 显示全部楼层 |阅读模式
这是野火的代码，自己改了以后，可以直插直用，有问题，评论区见

单片机源程序如下:
  1. #include "rc522_function.h"
  2. #include "rc522_config.h"
  3. #include "stm32f10x.h"
  4. #include "bsp_SysTick.h"


  7. #define   RC522_DELAY()  Delay_us ( 200 )

  9. /**
  10.   * @brief  向RC522发送1 Byte 数据
  11.   * @param  byte，要发送的数据
  12.   * @retval RC522返回的数据
  13.   */
  14. void SPI_RC522_SendByte ( uint8_t byte )
  15. {
  16.   uint8_t counter;

  18.   for(counter=0;counter<8;counter++)
  19.   {     
  20.     if ( byte & 0x80 )
  21.       RC522_MOSI_1 ();
  22.     else
  23.       RC522_MOSI_0 ();
  24.    
  25.     RC522_DELAY();
  26.     RC522_SCK_0 ();
  27.    
  28.     RC522_DELAY();
  29.     RC522_SCK_1();
  30.    
  31.     RC522_DELAY();
  32.     byte <<= 1;
  33.   }         
  34. }


  37. /**
  38.   * @brief  从RC522发送1 Byte 数据
  39.   * @param  无
  40.   * @retval RC522返回的数据
  41.   */
  42. uint8_t SPI_RC522_ReadByte ( void )
  43. {
  44.   uint8_t counter;
  45.   uint8_t SPI_Data;

  47.   for(counter=0;counter<8;counter++)
  48.   {
  49.     SPI_Data <<= 1;
  50.     RC522_SCK_0 ();
  51.    
  52.     RC522_DELAY();
  53.     if ( RC522_MISO_GET() == 1)
  54.      SPI_Data |= 0x01;
  55.    
  56.     RC522_DELAY();
  57.     RC522_SCK_1 ();
  58.    
  59.     RC522_DELAY();
  60.   }
  61.   return SPI_Data;
  62.         
  63. }



  67. /**
  68.   * @brief  读RC522寄存器
  69.   * @param  ucAddress，寄存器地址
  70.   * @retval 寄存器的当前值
  71.   */
  72. uint8_t ReadRawRC ( uint8_t ucAddress )
  73. {
  74.         uint8_t ucAddr, ucReturn;
  75.         
  76.         ucAddr = ( ( ucAddress << 1 ) & 0x7E ) | 0x80;        
  77.         RC522_CS_Enable();
  78.   
  79.         SPI_RC522_SendByte ( ucAddr );
  80.         ucReturn = SPI_RC522_ReadByte ();
  81.   
  82.         RC522_CS_Disable();
  83.         
  84.         return ucReturn;        
  85. }

  87. /**
  88.   * @brief  写RC522寄存器
  89.   * @param  ucAddress，寄存器地址
  90.   * @param  ucValue，写入寄存器的值
  91.   * @retval 无
  92.   */
  93. void WriteRawRC ( uint8_t ucAddress, uint8_t ucValue )
  94. {  
  95.         uint8_t ucAddr;
  96.         
  97.         ucAddr = ( ucAddress << 1 ) & 0x7E;        
  98.         RC522_CS_Enable();
  99.         
  100.         SPI_RC522_SendByte ( ucAddr );        
  101.         SPI_RC522_SendByte ( ucValue );
  102.   
  103.         RC522_CS_Disable();               
  104. }


  107. /**
  108.   * @brief  对RC522寄存器置位
  109.   * @param  ucReg，寄存器地址
  110.   * @param   ucMask，置位值
  111.   * @retval 无
  112.   */
  113. void SetBitMask ( uint8_t ucReg, uint8_t ucMask )  
  114. {
  115.   uint8_t ucTemp;

  117.   ucTemp = ReadRawRC ( ucReg );
  118.   WriteRawRC ( ucReg, ucTemp | ucMask ); // set bit mask
  119. }


  122. /**
  123.   * @brief  对RC522寄存器清位
  124.   * @param  ucReg，寄存器地址
  125.   * @param  ucMask，清位值
  126.   * @retval 无
  127.   */
  128. void ClearBitMask ( uint8_t ucReg, uint8_t ucMask )  
  129. {
  130.   uint8_t ucTemp;

  132.   ucTemp = ReadRawRC ( ucReg );
  133.   WriteRawRC ( ucReg, ucTemp & ( ~ ucMask) ); // clear bit mask
  134. }


  137. /**
  138.   * @brief  开启天线
  139.   * @param  无
  140.   * @retval 无
  141.   */
  142. void PcdAntennaOn ( void )
  143. {
  144.   uint8_t uc;

  146.   uc = ReadRawRC ( TxControlReg );
  147.   if ( ! ( uc & 0x03 ) )
  148.    SetBitMask(TxControlReg, 0x03);               
  149. }


  152. /**
  153.   * @brief  关闭天线
  154.   * @param  无
  155.   * @retval 无
  156.   */
  157. void PcdAntennaOff ( void )
  158. {
  159.   ClearBitMask ( TxControlReg, 0x03 );        
  160. }


  163. /**
  164.   * @brief  复位RC522
  165.   * @param  无
  166.   * @retval 无
  167.   */
  168. void PcdReset ( void )
  169. {
  170.         RC522_Reset_Disable();
  171.         Delay_us ( 1 );
  172.         
  173.         RC522_Reset_Enable();
  174.         Delay_us ( 1 );
  175.         
  176.         RC522_Reset_Disable();
  177.         Delay_us ( 1 );
  178.         
  179.         WriteRawRC ( CommandReg, 0x0f );
  180.         
  181.         while ( ReadRawRC ( CommandReg ) & 0x10 );
  182.         
  183.         Delay_us ( 1 );
  184.   
  185.         //定义发送和接收常用模式 和Mifare卡通讯，CRC初始值0x6363
  186.   WriteRawRC ( ModeReg, 0x3D );        
  187.         
  188.   WriteRawRC ( TReloadRegL, 30 );      //16位定时器低位   
  189.         WriteRawRC ( TReloadRegH, 0 );                         //16位定时器高位
  190.         
  191.   WriteRawRC ( TModeReg, 0x8D );                         //定义内部定时器的设置
  192.         
  193.   WriteRawRC ( TPrescalerReg, 0x3E );         //设置定时器分频系数
  194.         
  195.         WriteRawRC ( TxAutoReg, 0x40 );                         //调制发送信号为100%ASK        
  196.         
  197. }



  201. /**
  202.   * @brief  设置RC522的工作方式
  203.   * @param  ucType，工作方式
  204.   * @retval 无
  205.   */
  206. void M500PcdConfigISOType ( uint8_t ucType )
  207. {
  208.         if ( ucType == 'A')                     //ISO14443_A
  209.   {
  210.                 ClearBitMask ( Status2Reg, 0x08 );
  211.                
  212.     WriteRawRC ( ModeReg, 0x3D );         //3F
  213.                
  214.                 WriteRawRC ( RxSelReg, 0x86 );        //84
  215.                
  216.                 WriteRawRC( RFCfgReg, 0x7F );         //4F
  217.                
  218.                 WriteRawRC( TReloadRegL, 30 );        
  219.                
  220.                 WriteRawRC ( TReloadRegH, 0 );
  221.                
  222.                 WriteRawRC ( TModeReg, 0x8D );
  223.                
  224.                 WriteRawRC ( TPrescalerReg, 0x3E );
  225.                
  226.                 Delay_us ( 2 );
  227.                
  228.                 PcdAntennaOn ();//开天线
  229.                
  230.    }         
  231. }



  235. /**
  236.   * @brief  通过RC522和ISO14443卡通讯
  237.   * @param  ucCommand，RC522命令字
  238.   * @param  pInData，通过RC522发送到卡片的数据
  239.   * @param  ucInLenByte，发送数据的字节长度
  240.   * @param  pOutData，接收到的卡片返回数据
  241.   * @param  pOutLenBit，返回数据的位长度
  242.   * @retval 状态值= MI_OK，成功
  243.   */
  244. char PcdComMF522 ( uint8_t ucCommand,
  245.                    uint8_t * pInData,
  246.                    uint8_t ucInLenByte,
  247.                    uint8_t * pOutData,
  248.                    uint32_t * pOutLenBit )               
  249. {
  250.   char cStatus = MI_ERR;
  251.   uint8_t ucIrqEn   = 0x00;
  252.   uint8_t ucWaitFor = 0x00;
  253.   uint8_t ucLastBits;
  254.   uint8_t ucN;
  255.   uint32_t ul;

  257.   switch ( ucCommand )
  258.   {
  259.      case PCD_AUTHENT:                  //Mifare认证
  260.         ucIrqEn   = 0x12;                //允许错误中断请求ErrIEn  允许空闲中断IdleIEn
  261.         ucWaitFor = 0x10;                //认证寻卡等待时候 查询空闲中断标志位
  262.         break;
  263.      
  264.      case PCD_TRANSCEIVE:                //接收发送 发送接收
  265.         ucIrqEn   = 0x77;                //允许TxIEn RxIEn IdleIEn LoAlertIEn ErrIEn TimerIEn
  266.         ucWaitFor = 0x30;                //寻卡等待时候 查询接收中断标志位与 空闲中断标志位
  267.         break;
  268.      
  269.      default:
  270.        break;     
  271.   }
  272.   //IRqInv置位管脚IRQ与Status1Reg的IRq位的值相反
  273.   WriteRawRC ( ComIEnReg, ucIrqEn | 0x80 );
  274.   //Set1该位清零时，CommIRqReg的屏蔽位清零
  275.   ClearBitMask ( ComIrqReg, 0x80 );         
  276.   //写空闲命令
  277.   WriteRawRC ( CommandReg, PCD_IDLE );                 
  278.   
  279.   //置位FlushBuffer清除内部FIFO的读和写指针以及ErrReg的BufferOvfl标志位被清除
  280.   SetBitMask ( FIFOLevelReg, 0x80 );                        

  282.   for ( ul = 0; ul < ucInLenByte; ul ++ )
  283.     WriteRawRC ( FIFODataReg, pInData [ ul ] ); //写数据进FIFOdata
  284.    
  285.   WriteRawRC ( CommandReg, ucCommand );                                        //写命令


  288.   if ( ucCommand == PCD_TRANSCEIVE )
  289.    
  290.     //StartSend置位启动数据发送 该位与收发命令使用时才有效
  291.     SetBitMask(BitFramingReg,0x80);                                    

  293.   ul = 1000;                             //根据时钟频率调整，操作M1卡最大等待时间25ms

  295.   do                                                                                                                          //认证 与寻卡等待时间        
  296.   {
  297.        ucN = ReadRawRC ( ComIrqReg );                 //查询事件中断
  298.        ul --;
  299.   } while ( ( ul != 0 ) && ( ! ( ucN & 0x01 ) ) && ( ! ( ucN & ucWaitFor ) ) );        

  301.   ClearBitMask ( BitFramingReg, 0x80 );         //清理允许StartSend位

  303.   if ( ul != 0 )
  304.   {
  305.     //读错误标志寄存器BufferOfI CollErr ParityErr ProtocolErr
  306.     if ( ! ( ReadRawRC ( ErrorReg ) & 0x1B ) )        
  307.     {
  308.       cStatus = MI_OK;
  309.       
  310.       if ( ucN & ucIrqEn & 0x01 )                                //是否发生定时器中断
  311.         cStatus = MI_NOTAGERR;   
  312.         
  313.       if ( ucCommand == PCD_TRANSCEIVE )
  314.       {
  315.         //读FIFO中保存的字节数
  316.         ucN = ReadRawRC ( FIFOLevelReg );                          
  317.         
  318.         //最后接收到得字节的有效位数
  319.         ucLastBits = ReadRawRC ( ControlReg ) & 0x07;        
  320.         
  321.         if ( ucLastBits )
  322.          
  323.           //N个字节数减去1（最后一个字节）+最后一位的位数 读取到的数据总位数
  324.           * pOutLenBit = ( ucN - 1 ) * 8 + ucLastBits;           
  325.         else
  326.           * pOutLenBit = ucN * 8;      //最后接收到的字节整个字节有效
  327.         
  328.         if ( ucN == 0 )               
  329.           ucN = 1;   
  330.         
  331.         if ( ucN > MAXRLEN )
  332.           ucN = MAXRLEN;   
  333.         
  334.         for ( ul = 0; ul < ucN; ul ++ )
  335.           pOutData [ ul ] = ReadRawRC ( FIFODataReg );   
  336.         
  337.         }        
  338.     }   
  339.     else
  340.       cStatus = MI_ERR;      
  341.   }

  343.   SetBitMask ( ControlReg, 0x80 );           // stop timer now
  344.   WriteRawRC ( CommandReg, PCD_IDLE );
  345.    
  346.   return cStatus;
  347. }

  349. /**
  350.   * @brief 寻卡
  351.   * @param  ucReq_code，寻卡方式 = 0x52，寻感应区内所有符合14443A标准的卡；
  352.             寻卡方式= 0x26，寻未进入休眠状态的卡
  353.   * @param  pTagType，卡片类型代码
  354.              = 0x4400，Mifare_UltraLight
  355.              = 0x0400，Mifare_One(S50)
  356.              = 0x0200，Mifare_One(S70)
  357.              = 0x0800，Mifare_Pro(X))
  358.              = 0x4403，Mifare_DESFire
  359.   * @retval 状态值= MI_OK，成功
  360.   */
  361. char PcdRequest ( uint8_t ucReq_code, uint8_t * pTagType )
  362. {
  363.   char cStatus;  
  364.   uint8_t ucComMF522Buf [ MAXRLEN ];
  365.   uint32_t ulLen;

  367.   //清理指示MIFARECyptol单元接通以及所有卡的数据通信被加密的情况
  368.   ClearBitMask ( Status2Reg, 0x08 );
  369.         //发送的最后一个字节的 七位
  370.   WriteRawRC ( BitFramingReg, 0x07 );
  371.   //TX1,TX2管脚的输出信号传递经发送调制的13.56的能量载波信号
  372.   SetBitMask ( TxControlReg, 0x03 );        

  374.   ucComMF522Buf [ 0 ] = ucReq_code;                //存入 卡片命令字

  376.   cStatus = PcdComMF522 ( PCD_TRANSCEIVE,        
  377.                           ucComMF522Buf,
  378.                           1,
  379.                           ucComMF522Buf,
  380.                           & ulLen );        //寻卡  

  382.   if ( ( cStatus == MI_OK ) && ( ulLen == 0x10 ) )        //寻卡成功返回卡类型
  383.   {   
  384.      * pTagType = ucComMF522Buf [ 0 ];
  385.      * ( pTagType + 1 ) = ucComMF522Buf [ 1 ];
  386.   }

  388.   else
  389.    cStatus = MI_ERR;

  391.   return cStatus;         
  392. }

  394. /**
  395.   * @brief  防冲撞
  396.   * @param  pSnr，卡片序列号，4字节
  397.   * @retval 状态值= MI_OK，成功
  398.   */
  399. char PcdAnticoll ( uint8_t * pSnr )
  400. {
  401.   char cStatus;
  402.   uint8_t uc, ucSnr_check = 0;
  403.   uint8_t ucComMF522Buf [ MAXRLEN ];
  404.   uint32_t ulLen;
  405.   
  406.   //清MFCryptol On位 只有成功执行MFAuthent命令后，该位才能置位
  407.   ClearBitMask ( Status2Reg, 0x08 );
  408.   //清理寄存器 停止收发
  409.   WriteRawRC ( BitFramingReg, 0x00);        
  410.         //清ValuesAfterColl所有接收的位在冲突后被清除
  411.   ClearBitMask ( CollReg, 0x80 );                          

  413.   ucComMF522Buf [ 0 ] = 0x93;                  //卡片防冲突命令
  414.   ucComMF522Buf [ 1 ] = 0x20;

  416.   cStatus = PcdComMF522 ( PCD_TRANSCEIVE,
  417.                           ucComMF522Buf,
  418.                           2,
  419.                           ucComMF522Buf,
  420.                           & ulLen);      //与卡片通信

  422.   if ( cStatus == MI_OK)                            //通信成功
  423.   {
  424.     for ( uc = 0; uc < 4; uc ++ )
  425.     {
  426.        * ( pSnr + uc )  = ucComMF522Buf [ uc ]; //读出UID
  427.        ucSnr_check ^= ucComMF522Buf [ uc ];
  428.     }
  429.    
  430.     if ( ucSnr_check != ucComMF522Buf [ uc ] )
  431.       cStatus = MI_ERR;                                    
  432.   }
  433.   
  434.   SetBitMask ( CollReg, 0x80 );
  435.       
  436.   return cStatus;               
  437. }


  440. /**
  441.   * @brief  用RC522计算CRC16
  442.   * @param  pIndata，计算CRC16的数组
  443.   * @param  ucLen，计算CRC16的数组字节长度
  444.   * @param  pOutData，存放计算结果存放的首地址
  445.   * @retval 无
  446.   */
  447. void CalulateCRC ( uint8_t * pIndata,
  448.                  uint8_t ucLen,
  449.                  uint8_t * pOutData )
  450. {
  451.   uint8_t uc, ucN;

  453.   ClearBitMask(DivIrqReg,0x04);

  455.   WriteRawRC(CommandReg,PCD_IDLE);

  457.   SetBitMask(FIFOLevelReg,0x80);

  459.   for ( uc = 0; uc < ucLen; uc ++)
  460.     WriteRawRC ( FIFODataReg, * ( pIndata + uc ) );   

  462.   WriteRawRC ( CommandReg, PCD_CALCCRC );

  464.   uc = 0xFF;

  466.   do
  467.   {
  468.       ucN = ReadRawRC ( DivIrqReg );
  469.       uc --;
  470.   } while ( ( uc != 0 ) && ! ( ucN & 0x04 ) );
  471.   
  472.   pOutData [ 0 ] = ReadRawRC ( CRCResultRegL );
  473.   pOutData [ 1 ] = ReadRawRC ( CRCResultRegM );               
  474. }


  477. /**
  478.   * @brief  选定卡片
  479.   * @param  pSnr，卡片序列号，4字节
  480.   * @retval 状态值= MI_OK，成功
  481.   */
  482. char PcdSelect ( uint8_t * pSnr )
  483. {
  484.   char ucN;
  485.   uint8_t uc;
  486.   uint8_t ucComMF522Buf [ MAXRLEN ];
  487.   uint32_t  ulLen;
  488.   
  489.   
  490.   ucComMF522Buf [ 0 ] = PICC_ANTICOLL1;
  491.   ucComMF522Buf [ 1 ] = 0x70;
  492.   ucComMF522Buf [ 6 ] = 0;

  494.   for ( uc = 0; uc < 4; uc ++ )
  495.   {
  496.     ucComMF522Buf [ uc + 2 ] = * ( pSnr + uc );
  497.     ucComMF522Buf [ 6 ] ^= * ( pSnr + uc );
  498.   }
  499.   
  500.   CalulateCRC ( ucComMF522Buf, 7, & ucComMF522Buf [ 7 ] );

  502.   ClearBitMask ( Status2Reg, 0x08 );

  504.   ucN = PcdComMF522 ( PCD_TRANSCEIVE,
  505.                      ucComMF522Buf,
  506.                      9,
  507.                      ucComMF522Buf,
  508.                      & ulLen );
  509.   
  510.   if ( ( ucN == MI_OK ) && ( ulLen == 0x18 ) )
  511.     ucN = MI_OK;  
  512.   else
  513.     ucN = MI_ERR;   
  514.   
  515.   return ucN;               
  516. }



  520. /**
  521.   * @brief  验证卡片密码
  522.   * @param  ucAuth_mode，密码验证模式= 0x60，验证A密钥，
  523.             密码验证模式= 0x61，验证B密钥
  524.   * @param  uint8_t ucAddr，块地址
  525.   * @param  pKey，密码
  526.   * @param  pSnr，卡片序列号，4字节
  527.   * @retval 状态值= MI_OK，成功
  528.   */
  529. char PcdAuthState ( uint8_t ucAuth_mode,
  530.                     uint8_t ucAddr,
  531.                     uint8_t * pKey,
  532.                     uint8_t * pSnr )
  533. {
  534.   char cStatus;
  535.   uint8_t uc, ucComMF522Buf [ MAXRLEN ];
  536.   uint32_t ulLen;
  537.   

  539.   ucComMF522Buf [ 0 ] = ucAuth_mode;
  540.   ucComMF522Buf [ 1 ] = ucAddr;

  542.   for ( uc = 0; uc < 6; uc ++ )
  543.     ucComMF522Buf [ uc + 2 ] = * ( pKey + uc );   

  545.   for ( uc = 0; uc < 6; uc ++ )
  546.     ucComMF522Buf [ uc + 8 ] = * ( pSnr + uc );   

  548.   cStatus = PcdComMF522 ( PCD_AUTHENT,
  549.                           ucComMF522Buf,
  550.                           12,
  551.                           ucComMF522Buf,
  552.                           & ulLen );

  554.   if ( ( cStatus != MI_OK ) || ( ! ( ReadRawRC ( Status2Reg ) & 0x08 ) ) )
  555.     cStatus = MI_ERR;   
  556.    
  557.   return cStatus;
  558. }


  561. /**
  562.   * @brief  写数据到M1卡一块
  563.   * @param  uint8_t ucAddr，块地址
  564.   * @param  pData，写入的数据，16字节
  565.   * @retval 状态值= MI_OK，成功
  566.   */
  567. char PcdWrite ( uint8_t ucAddr, uint8_t * pData )
  568. {
  569.   char cStatus;
  570.   uint8_t uc, ucComMF522Buf [ MAXRLEN ];
  571.   uint32_t ulLen;
  572.    
  573.   
  574.   ucComMF522Buf [ 0 ] = PICC_WRITE;
  575.   ucComMF522Buf [ 1 ] = ucAddr;

  577.   CalulateCRC ( ucComMF522Buf, 2, & ucComMF522Buf [ 2 ] );

  579.   cStatus = PcdComMF522 ( PCD_TRANSCEIVE,
  580.                           ucComMF522Buf,
  581.                           4,
  582.                           ucComMF522Buf,
  583.                           & ulLen );

  585.   if ( ( cStatus != MI_OK ) || ( ulLen != 4 ) ||
  586.          ( ( ucComMF522Buf [ 0 ] & 0x0F ) != 0x0A ) )
  587.     cStatus = MI_ERR;   
  588.       
  589.   if ( cStatus == MI_OK )
  590.   {
  591.     //memcpy(ucComMF522Buf, pData, 16);
  592.     for ( uc = 0; uc < 16; uc ++ )
  593.       ucComMF522Buf [ uc ] = * ( pData + uc );  
  594.    
  595.     CalulateCRC ( ucComMF522Buf, 16, & ucComMF522Buf [ 16 ] );

  597.     cStatus = PcdComMF522 ( PCD_TRANSCEIVE,
  598.                            ucComMF522Buf,
  599.                            18,
  600.                            ucComMF522Buf,
  601.                            & ulLen );
  602.    
  603.     if ( ( cStatus != MI_OK ) || ( ulLen != 4 ) ||
  604.          ( ( ucComMF522Buf [ 0 ] & 0x0F ) != 0x0A ) )
  605.       cStatus = MI_ERR;   
  606.    
  607.   }         
  608.   return cStatus;               
  609. }


  612. /**
  613.   * @brief  读取M1卡一块数据
  614.   * @param  ucAddr，块地址
  615.   * @param  pData，读出的数据，16字节
  616.   * @retval 状态值= MI_OK，成功
  617.   */
  618. char PcdRead ( uint8_t ucAddr, uint8_t * pData )
  619. {
  620.   char cStatus;
  621.   uint8_t uc, ucComMF522Buf [ MAXRLEN ];
  622.   uint32_t ulLen;
  623.   
  624.   ucComMF522Buf [ 0 ] = PICC_READ;
  625. ……………………

  627. …………限于本文篇幅 余下代码请从51黑下载附件…………
复制代码

所有资料51hei提供下载:
F103-指南者开发板配套例程.rar (343.49 KB, 下载次数: 25)
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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