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

標(biāo)題: modbus通信協(xié)議中文版 附帶一部分功能碼的實(shí)現(xiàn)源碼 [打印本頁(yè)]
作者: zyisme    時(shí)間: 2018-8-2 16:31
標(biāo)題: modbus通信協(xié)議中文版 附帶一部分功能碼的實(shí)現(xiàn)源碼
內(nèi)容包含以下modbus 功能碼的實(shí)現(xiàn)01
讀線圈狀態(tài)
00001-09999
位操作  單個(gè)或多個(gè)
02
讀(開關(guān))輸入狀態(tài)
10001-19999
位操作  單個(gè)或多個(gè)
03
讀保持寄存器
40001-49999
字操作  單個(gè)或多個(gè)
04
讀輸入寄存器
30001-39999
字操作  單個(gè)或多個(gè)
05
寫單個(gè)線圈
00001-09999
位操作  單個(gè)
06
寫單個(gè)保持寄存器
40001-49999
字操作  單個(gè)
15
寫多個(gè)線圈
00001-09999
位操作  多個(gè)
16
寫多個(gè)保持寄存器
40001-49999
字操作  多個(gè)



單片機(jī)源程序如下:
  1. #include "modbus.h"

  3. uint16_t modbus_addr[MODBUS_SIZE + 8];
  4. //
  5. uint16_t *COIL_ADDR = modbus_addr + 8;
  6. uint16_t *STATE_ADDR = (modbus_addr + 8 + COIL_SIZE / 16);
  7. uint16_t *INPUT_ADDR = (modbus_addr + 8 + (COIL_SIZE + STATE_SIZE) / 16);
  8. uint16_t *HOLD_ADDR = (modbus_addr + 8 + (COIL_SIZE + STATE_SIZE) / 16 + INPUT_SIZE);

  10. uint16_t read_coil(uint16_t coil_addr,uint16_t reg_type)
  11. {
  12.         uint16_t i,j;

  14.         if(reg_type == REG_MODBUS)
  15.                 coil_addr -= 1;
  16.        
  17.         if(coil_addr >= COIL_SIZE)
  18.                 return 0;
  19.        
  20.         i = coil_addr / 16;
  21.         j = coil_addr % 16;
  22.         i = *(COIL_ADDR + i) & (1<<j);
  23.         return (i != 0);
  24. }

  26. void write_coil(uint16_t coil_addr, uint16_t on_off, uint16_t reg_type)
  27. {
  28.         uint16_t i, j, *addr;

  30.         if(reg_type == REG_MODBUS)
  31.                 coil_addr -= 1;
  32.         if(coil_addr >= COIL_SIZE)
  33.                 return;       
  34.         i = coil_addr / 16;
  35.         j = coil_addr % 16;
  36.         j = 1 << j;
  37.         addr = COIL_ADDR + i;
  38.         if(on_off)
  39.         {
  40.                 *addr = ( *addr | j);
  41.         }
  42.         else
  43.         {
  44.                 *addr = (*addr & (~j));
  45.         }
  46. }

  48. uint16_t read_state(uint16_t status_addr, uint16_t reg_type)
  49. {
  50.         uint16_t i,j;

  52.         if(reg_type == REG_MODBUS)
  53.                 status_addr -= 10001;
  54.         if(status_addr >= STATE_SIZE)
  55.                 return 0;
  56.        
  57.         i = status_addr / 16;
  58.         j = status_addr % 16;
  59.         i = *(STATE_ADDR + i) & (1<<j);
  60.         return (i != 0);
  61. }

  63. void write_state(uint16_t state_addr, uint16_t on_off, uint16_t reg_type)
  64. {
  65.         uint16_t i, j, *addr;

  67.         if(reg_type == REG_MODBUS)
  68.                 state_addr -= 10001;
  69.         if(state_addr >= STATE_SIZE)
  70.                 return;       
  71.         i = state_addr / 16;
  72.         j = state_addr % 16;
  73.         j = 1 << j;
  74.         addr = STATE_ADDR + i;
  75.         if(on_off)
  76.         {
  77.                 *addr = (*addr | j);
  78.         }
  79.         else
  80.         {
  81.                 *addr = (*addr & (~j));
  82.         }
  83. }

  85. uint16_t read_input(uint16_t input_addr, uint16_t reg_type)
  86. {
  87.         if(reg_type == REG_MODBUS)
  88.                 input_addr -= 30001;
  89.        
  90.         if(input_addr >= INPUT_SIZE)
  91.                 return 0;
  92.         return *(INPUT_ADDR + input_addr);
  93. }

  95. void write_input(uint16_t input_addr, uint16_t data, uint16_t reg_type)
  96. {
  97.         if(reg_type == REG_MODBUS)
  98.                 input_addr -= 30001;
  99.         if(input_addr >= INPUT_SIZE)
  100.                 return;       
  101.         *(INPUT_ADDR + input_addr) = data;
  102. }

  104. uint16_t read_hold(uint16_t hold_addr,uint16_t reg_type)
  105. {
  106.         if(reg_type == REG_MODBUS)
  107.                 hold_addr -= 40001;
  108.        
  109.         if(hold_addr >= HOLD_SIZE)
  110.                 return 0;
  111.         return *(HOLD_ADDR + hold_addr);
  112. }

  114. void write_hold(uint16_t hold_addr, uint16_t data, uint16_t reg_type)
  115. {
  116.         if(reg_type == REG_MODBUS)
  117.                 hold_addr -= 40001;
  118.         if(hold_addr >= HOLD_SIZE)
  119.                 return;       
  120.         *(HOLD_ADDR + hold_addr) = data;
  121. }

  123. uint16_t read_reg_n(uint16_t reg_addr)
  124. {
  125.         if((reg_addr >= 1) && (reg_addr <= COIL_SIZE))
  126.                 return read_coil(reg_addr, REG_MODBUS);
  127.         if((reg_addr >=10001) && (reg_addr <=(10000+STATE_SIZE)))
  128.                 return read_state(reg_addr ,REG_MODBUS);
  129.         if((reg_addr >=30001) && (reg_addr <=(30000+INPUT_SIZE)))
  130.                 return read_input(reg_addr ,REG_MODBUS);
  131.         if((reg_addr >=40001) && (reg_addr <=(40000+HOLD_SIZE)))
  132.                 return read_hold(reg_addr ,REG_MODBUS);
  133.         return 0;
  134. }

  136. /*???????*/
  137. void write_reg_n(uint16_t reg_addr ,uint16_t data)
  138. {
  139.         if((reg_addr >=1) && (reg_addr <=COIL_SIZE))
  140.                 write_coil(reg_addr ,data,REG_MODBUS);
  141.         else if((reg_addr >=10001) && (reg_addr <=(10000+STATE_SIZE)))
  142.                 write_state(reg_addr ,data,REG_MODBUS);
  143.         else if((reg_addr >=30001) && (reg_addr <=(30000+INPUT_SIZE)))
  144.                 write_input(reg_addr ,data,REG_MODBUS);
  145.         else if((reg_addr >=40001) && (reg_addr <=(40000+HOLD_SIZE)))
  146.                 write_hold(reg_addr ,data,REG_MODBUS);
  147.         else;
  148. }

  150. /*??????? swap=0-???? 1-????*/
  151. float read_reg_f(uint16_t reg_addr ,uint8_t swap)
  152. {
  153.         union { uint32_t i; float f; } w;
  154.         if((reg_addr >=30001) && (reg_addr <=(30000+INPUT_SIZE)))
  155.         {
  156.                 if(swap==1)
  157.                         w.i=(read_input(reg_addr ,REG_MODBUS)<<16)+read_input(reg_addr +1,REG_MODBUS);
  158.                 else                
  159.                         w.i=read_input(reg_addr ,REG_MODBUS)+(read_input(reg_addr +1,REG_MODBUS)<<16);
  160.                 return w.f;
  161.         }
  162.         else if((reg_addr >=40001) && (reg_addr <=(40000+HOLD_SIZE)))
  163.         {
  164.                 if(swap==1)
  165.                         w.i=(read_hold(reg_addr ,REG_MODBUS)<<16)+read_hold(reg_addr +1,REG_MODBUS);
  166.                 else                
  167.                         w.i=read_hold(reg_addr ,REG_MODBUS)+(read_hold(reg_addr +1,REG_MODBUS)<<16);
  168.                 return w.f;
  169.         }
  170.         else;
  171.         return 0.0;
  172. }

  174. /*??????? swap=0-???? 1-????*/
  175. void write_reg_f(uint16_t reg_addr ,float data,uint8_t swap)
  176. {
  177.         union { uint32_t i; float f; } w;                /*????????  ??:????ADP3?????!!!*/
  178.         w.f=data;
  179.         if((reg_addr >=30001) && (reg_addr <=(30000+INPUT_SIZE)))
  180.         {
  181.                 if(swap==1)
  182.                 {
  183.                         write_input(reg_addr ,w.i>>16,REG_MODBUS);
  184.                         write_input(reg_addr +1,w.i,REG_MODBUS);
  185.                 }
  186.                 else
  187.                 {
  188.                         write_input(reg_addr ,w.i,REG_MODBUS);
  189.                         write_input(reg_addr +1,w.i>>16,REG_MODBUS);
  190.                 }
  191.         }
  192.         else if((reg_addr>=40001) && (reg_addr<=(40000+HOLD_SIZE)))
  193.         {
  194.                 if(swap==1)
  195.                 {
  196.                         write_hold(reg_addr,w.i>>16,REG_MODBUS);
  197.                         write_hold(reg_addr+1,w.i,REG_MODBUS);
  198.                 }
  199.                 else
  200.                 {
  201.                         write_hold(reg_addr,w.i,REG_MODBUS);
  202.                         write_hold(reg_addr+1,w.i>>16,REG_MODBUS);
  203.                 }
  204.         }
  205.         else;
  206. }

  208. /*???????? swap=0-???? 1-????*/
  209. uint32_t read_reg_ln(uint16_t reg_addr, uint8_t swap)
  210. {
  211.         uint32_t i = 0;
  212.         if((reg_addr >= 30001) && (reg_addr <= (30000 + INPUT_SIZE)))
  213.         {
  214.                 if(swap == 1)
  215.                         i = (read_input(reg_addr, REG_MODBUS) << 16) + read_input(reg_addr + 1, REG_MODBUS);
  216.                 else               
  217.                         i = read_input(reg_addr, REG_MODBUS) + (read_input(reg_addr + 1, REG_MODBUS) << 16);
  218.         }
  219.         else if((reg_addr >= 40001) && (reg_addr <= (40000 + HOLD_SIZE)))
  220.         {
  221.                 if(swap == 1)
  222.                         i = (read_hold(reg_addr, REG_MODBUS) << 16) + read_hold(reg_addr + 1,REG_MODBUS);
  223.                 else               
  224.                         i = read_hold(reg_addr, REG_MODBUS) + (read_hold(reg_addr + 1, REG_MODBUS) << 16);
  225.         }
  226.         else;
  227.         return i;
  228. }

  230. void write_reg_ln(uint16_t reg_addr, uint32_t data, uint8_t swap)
  231. {
  232.         uint32_t i;
  233.         i = data;
  234.         if((reg_addr >= 30001) && (reg_addr<=(30000 + INPUT_SIZE)))
  235.         {
  236.                 if(swap==1)
  237.                 {
  238.                         write_input(reg_addr, i >> 16,REG_MODBUS);
  239.                         write_input(reg_addr + 1, i, REG_MODBUS);
  240.                 }
  241.                 else
  242.                 {
  243.                         write_input(reg_addr, i, REG_MODBUS);
  244.                         write_input(reg_addr + 1, i >> 16, REG_MODBUS);
  245.                 }
  246.         }
  247.         else if((reg_addr >= 40001) && (reg_addr <= (40000 + HOLD_SIZE)))
  248.         {
  249.                 if(swap==1)
  250.                 {
  251.                         write_hold(reg_addr, i >> 16, REG_MODBUS);
  252.                         write_hold(reg_addr + 1, i, REG_MODBUS);
  253.                 }
  254.                 else
  255.                 {
  256.                         write_hold(reg_addr, i, REG_MODBUS);
  257.                         write_hold(reg_addr + 1, i >> 16, REG_MODBUS);
  258.                 }
  259.         }
  260.         else;
  261. }
  262. uint8_t LRC(uint8_t *auchMsg, uint16_t usDataLen)
  263. {
  264.         uint8_t uchLRC = 0 ;
  265.         while (usDataLen--) { uchLRC += *auchMsg++ ; }
  266.         return ((uint8_t)(~uchLRC+1));
  267. }

  269. static const uint8_t auchCRCHi[]={
  270. 0x00,0xc1,0x81,0x40,0x01,0xc0,0x80,0x41,0x01,0xc0,0x80,0x41,0x00,0xc1,0x81,0x40,
  271. 0x01,0xc0,0x80,0x41,0x00,0xc1,0x81,0x40,0x00,0xc1,0x81,0x40,0x01,0xc0,0x80,0x41,
  272. 0x01,0xc0,0x80,0x41,0x00,0xc1,0x81,0x40,0x00,0xc1,0x81,0x40,0x01,0xc0,0x80,0x41,
  273. 0x00,0xc1,0x81,0x40,0x01,0xc0,0x80,0x41,0x01,0xc0,0x80,0x41,0x00,0xc1,0x81,0x40,
  274. 0x01,0xc0,0x80,0x41,0x00,0xc1,0x81,0x40,0x00,0xc1,0x81,0x40,0x01,0xc0,0x80,0x41,
  275. 0x00,0xc1,0x81,0x40,0x01,0xc0,0x80,0x41,0x01,0xc0,0x80,0x41,0x00,0xc1,0x81,0x40,
  276. 0x00,0xc1,0x81,0x40,0x01,0xc0,0x80,0x41,0x01,0xc0,0x80,0x41,0x00,0xc1,0x81,0x40,
  277. 0x01,0xc0,0x80,0x41,0x00,0xc1,0x81,0x40,0x00,0xc1,0x81,0x40,0x01,0xc0,0x80,0x41,

  279. 0x01,0xc0,0x80,0x41,0x00,0xc1,0x81,0x40,0x00,0xc1,0x81,0x40,0x01,0xc0,0x80,0x41,
  280. 0x00,0xc1,0x81,0x40,0x01,0xc0,0x80,0x41,0x01,0xc0,0x80,0x41,0x00,0xc1,0x81,0x40,
  281. 0x00,0xc1,0x81,0x40,0x01,0xc0,0x80,0x41,0x01,0xc0,0x80,0x41,0x00,0xc1,0x81,0x40,
  282. 0x01,0xc0,0x80,0x41,0x00,0xc1,0x81,0x40,0x00,0xc1,0x81,0x40,0x01,0xc0,0x80,0x41,
  283. 0x00,0xc1,0x81,0x40,0x01,0xc0,0x80,0x41,0x01,0xc0,0x80,0x41,0x00,0xc1,0x81,0x40,
  284. 0x01,0xc0,0x80,0x41,0x00,0xc1,0x81,0x40,0x00,0xc1,0x81,0x40,0x01,0xc0,0x80,0x41,
  285. 0x01,0xc0,0x80,0x41,0x00,0xc1,0x81,0x40,0x00,0xc1,0x81,0x40,0x01,0xc0,0x80,0x41,
  286. 0x00,0xc1,0x81,0x40,0x01,0xc0,0x80,0x41,0x01,0xc0,0x80,0x41,0x00,0xc1,0x81,0x40
  287. };
  288. static const uint8_t auchCRCLo[]={
  289. 0x00,0xc0,0xc1,0x01,0xc3,0x03,0x02,0xc2,0xc6,0x06,0x07,0xc7,0x05,0xc5,0xc4,0x04,
  290. 0xcc,0x0c,0x0d,0xcd,0x0f,0xcf,0xce,0x0e,0x0a,0xca,0xcb,0x0b,0xc9,0x09,0x08,0xc8,
  291. 0xd8,0x18,0x19,0xd9,0x1b,0xdb,0xda,0x1a,0x1e,0xde,0xdf,0x1f,0xdd,0x1d,0x1c,0xdc,
  292. 0x14,0xd4,0xd5,0x15,0xd7,0x17,0x16,0xd6,0xd2,0x12,0x13,0xd3,0x11,0xd1,0xd0,0x10,
  293. 0xf0,0x30,0x31,0xf1,0x33,0xf3,0xf2,0x32,0x36,0xf6,0xf7,0x37,0xf5,0x35,0x34,0xf4,
  294. 0x3c,0xfc,0xfd,0x3d,0xff,0x3f,0x3e,0xfe,0xfa,0x3a,0x3b,0xfb,0x39,0xf9,0xf8,0x38,
  295. 0x28,0xe8,0xe9,0x29,0xeb,0x2b,0x2a,0xea,0xee,0x2e,0x2f,0xef,0x2d,0xed,0xec,0x2c,
  296. 0xe4,0x24,0x25,0xe5,0x27,0xe7,0xe6,0x26,0x22,0xe2,0xe3,0x23,0xe1,0x21,0x20,0xe0,

  298. 0xa0,0x60,0x61,0xa1,0x63,0xa3,0xa2,0x62,0x66,0xa6,0xa7,0x67,0xa5,0x65,0x64,0xa4,
  299. 0x6c,0xac,0xad,0x6d,0xaf,0x6f,0x6e,0xae,0xaa,0x6a,0x6b,0xab,0x69,0xa9,0xa8,0x68,
  300. 0x78,0xb8,0xb9,0x79,0xbb,0x7b,0x7a,0xba,0xbe,0x7e,0x7f,0xbf,0x7d,0xbd,0xbc,0x7c,
  301. 0xb4,0x74,0x75,0xb5,0x77,0xb7,0xb6,0x76,0x72,0xb2,0xb3,0x73,0xb1,0x71,0x70,0xb0,
  302. 0x50,0x90,0x91,0x51,0x93,0x53,0x52,0x92,0x96,0x56,0x57,0x97,0x55,0x95,0x94,0x54,
  303. 0x9c,0x5c,0x5d,0x9d,0x5f,0x9f,0x9e,0x5e,0x5a,0x9a,0x9b,0x5b,0x99,0x59,0x58,0x98,
  304. 0x88,0x48,0x49,0x89,0x4b,0x8b,0x8a,0x4a,0x4e,0x8e,0x8f,0x4f,0x8d,0x4d,0x4c,0x8c,
  305. 0x44,0x84,0x85,0x45,0x87,0x47,0x46,0x86,0x82,0x42,0x43,0x83,0x41,0x81,0x80,0x40
  306. };

  308. uint16_t CRC16(uint8_t* puchMsg, uint16_t usDataLen)
  309. {
  310.         uint8_t uchCRCHi=0xff;
  311.         uint8_t uchCRCLo=0xff;
  312.         uint16_t uIndex;
  313.         while(usDataLen--)
  314.         {
  315.                 uIndex=uchCRCHi^*(puchMsg++);
  316.                 uchCRCHi=uchCRCLo^auchCRCHi[uIndex];
  317.                 uchCRCLo=auchCRCLo[uIndex];
  318.         }
  319.         return uchCRCHi<<8|uchCRCLo;
  320. }

  322. uint16_t sx2toi(uint8_t *str)
  323. {
  324.         uint16_t i=0;
  325.        
  326.         if((str[0]>='0') && (str[0]<='9'))                 i=(str[0]-'0')<<4;
  327.         else if((str[0]>='A') && (str[0]<='F')) i=(str[0]-'A'+10)<<4;  
  328.         else if((str[0]>='a') && (str[0]<='f')) i=(str[0]-'a'+10)<<4;  
  329.         else;

  331.         if((str[1]>='0') && (str[1]<='9'))                 i=i+str[1]-'0';
  332.         else if((str[1]>='A') && (str[1]<='F')) i=i+str[1]-'A'+10;  
  333.         else if((str[1]>='a') && (str[1]<='f')) i=i+str[1]-'a'+10;  
  334.         else;
  335.        
  336.         return i;
  337. }

  339. void itosx2(uint16_t data,uint8_t *str)
  340. {
  341.         uint16_t i,j;
  342.        
  343.         i=(data & 0xf0)>>4; j=data & 0x0f;
  344.        

  346.         if(i<=9)         str[0]='0'+i;
  347.         else                 str[0]='A'+i-10;  

  349.         if(j<=9)         str[1]='0'+j;
  350.         else                 str[1]='A'+j-10;  
  351. }

  353. uint16_t modbus_asc_hex(uint8_t *asc_buf,uint16_t num)
  354. {
  355.         uint16_t i;
  356.         num=(num-3)/2;
  357.         for(i=0;i<num;i++)
  358.         { asc_buf[i]=(uint8_t)sx2toi(&asc_buf[i*2+1]); }
  359.         return i;
  360. }

  362. uint16_t modbus_hex_asc(uint8_t *hex_buf,uint8_t *asc_buf,uint16_t num)
  363. {
  364.         uint16_t i;
  365.         asc_buf[0]=':';
  366.         for(i=0;i<num;i++)
  367.         { itosx2((uint16_t)hex_buf[i],&asc_buf[i*2+1]); }
  368.         num=num*2+1;
  369.         asc_buf[num]='\r'; num++;
  370.         asc_buf[num]='\n'; num++;
  371.         return num;
  372. }

  374. static const uint32_t crc32tab[] =
  375. {  
  376. 0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL,  
  377. 0x076dc419L, 0x706af48fL, 0xe963a535L, 0x9e6495a3L,  
  378. 0x0edb8832L, 0x79dcb8a4L, 0xe0d5e91eL, 0x97d2d988L,  
  379. 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L, 0x90bf1d91L,  
  380. 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL,  
  381. 0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L,  
  382. 0x136c9856L, 0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL,  
  383. 0x14015c4fL, 0x63066cd9L, 0xfa0f3d63L, 0x8d080df5L,  
  384. 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L, 0xa2677172L,  
  385. 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL,  
  386. 0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L,  
  387. 0x32d86ce3L, 0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L,  
  388. 0x26d930acL, 0x51de003aL, 0xc8d75180L, 0xbfd06116L,  
  389. 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L, 0xb8bda50fL,  
  390. 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L,  
  391. 0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL,  
  392. 0x76dc4190L, 0x01db7106L, 0x98d220bcL, 0xefd5102aL,  
  393. 0x71b18589L, 0x06b6b51fL, 0x9fbfe4a5L, 0xe8b8d433L,  
  394. 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL, 0xe10e9818L,  
  395. 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L,  
  396. 0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL,  
  397. 0x6c0695edL, 0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L,  
  398. 0x65b0d9c6L, 0x12b7e950L, 0x8bbeb8eaL, 0xfcb9887cL,  
  399. 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L, 0xfbd44c65L,  
  400. 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L,  
  401. 0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL,  
  402. 0x4369e96aL, 0x346ed9fcL, 0xad678846L, 0xda60b8d0L,  
  403. 0x44042d73L, 0x33031de5L, 0xaa0a4c5fL, 0xdd0d7cc9L,  
  404. 0x5005713cL, 0x270241aaL, 0xbe0b1010L, 0xc90c2086L,  
  405. 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL,  
  406. ……………………

  408. …………限于本文篇幅 余下代碼請(qǐng)從51黑下載附件…………
復(fù)制代碼

所有資料51hei提供下載:
modbus.zip (1.09 MB, 下載次數(shù): 68)




作者: lbq666    時(shí)間: 2019-10-14 11:21
下載了，謝謝樓主



歡迎光臨 (http://www.zg4o1577.cn/bbs/) Powered by Discuz! X3.1
主站蜘蛛池模板： 中文字幕第九页 | 日日碰狠狠躁久久躁96avv | 亚洲精品欧美 | 日本国产精品视频 | 韩日精品一区 | 二区在线视频 | 日韩av中文 | 亚洲一区二区在线播放 | 一区二区三区视频在线观看 | 日韩精品在线观看一区二区三区 | 国产一级一级 | 欧美综合一区二区三区 | 中文字幕 亚洲一区 | 毛片大全 | 成人在线精品 | 久久精品国产v日韩v亚洲 | 精品中文在线 | 97国产精品| 国产一级特黄aaa大片评分 | 美日韩免费视频 | 激情 亚洲 | 亚洲综合一区二区三区 | 欧美精品在欧美一区二区 | 国产精品99久久久久久宅男 | 亚洲成人在线视频播放 | 成人免费视频 | 精品国产乱码久久久久久丨区2区 | 视频一区在线 | 成人aaa视频 | 欧美色综合一区二区三区 | 欧美日韩亚洲在线 | 一区二区中文字幕 | 三级成人在线 | 欧美精品久久久久久 | 欧美视频网 | 99亚洲精品 | 国产在线播放一区二区三区 | 亚洲精品久久区二区三区蜜桃臀 | 中文在线一区二区 | 国产亚洲久 | 亚洲高清在线 |