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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › MCU综合技术区 › modbus通信协议中文版 附带一部分功能码的实现源码
返回列表 发新帖
查看: 3534|回复: 1
打印 上一主题 下一主题
收起左侧

modbus通信协议中文版 附带一部分功能码的实现源码

[复制链接]
跳转到指定楼层
楼主
ID:382189 发表于 2018-8-2 16:31 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
内容包含以下modbus 功能码的实现01
读线圈状态
00001-09999
位操作  单个或多个
02
读(开关)输入状态
10001-19999
位操作  单个或多个
03
读保持寄存器
40001-49999
字操作  单个或多个
04
读输入寄存器
30001-39999
字操作  单个或多个
05
写单个线圈
00001-09999
位操作  单个
06
写单个保持寄存器
40001-49999
字操作  单个
15
写多个线圈
00001-09999
位操作  多个
16
写多个保持寄存器
40001-49999
字操作  多个



单片机源程序如下:
  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. …………限于本文篇幅 余下代码请从51黑下载附件…………
复制代码

所有资料51hei提供下载:
modbus.zip (1.09 MB, 下载次数: 66)




评分

参与人数 1黑币 +50 收起 理由
admin + 50 共享资料的黑币奖励！

查看全部评分

分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏1 分享淘帖 顶顶 踩踩
回复

使用道具 举报

沙发
ID:235062 发表于 2019-10-14 11:21 | 只看该作者
下载了，谢谢楼主
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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