格式化代码，使用4个空格代替tab

inc/small_modbus_base.h

@@ -15,18 +15,18 @@
 /* function codes */
 enum functionCode
 {
-	MODBUS_FC_READ_HOLDING_COILS = 0x01,
-	MODBUS_FC_READ_INPUTS_COILS = 0x02,
-	MODBUS_FC_READ_HOLDING_REGISTERS = 0x03,
-	MODBUS_FC_READ_INPUT_REGISTERS = 0x04,
-	MODBUS_FC_WRITE_SINGLE_COIL = 0x05,
-	MODBUS_FC_WRITE_SINGLE_REGISTER = 0x06,
-	MODBUS_FC_READ_EXCEPTION_STATUS = 0x07,
-	MODBUS_FC_WRITE_MULTIPLE_COILS = 0x0F,
-	MODBUS_FC_WRITE_MULTIPLE_REGISTERS = 0x10,
-	MODBUS_FC_REPORT_SLAVE_ID = 0x11,
-	MODBUS_FC_MASK_WRITE_REGISTER = 0x16,
-	MODBUS_FC_WRITE_AND_READ_REGISTERS = 0x17,
+    MODBUS_FC_READ_HOLDING_COILS = 0x01,
+    MODBUS_FC_READ_INPUTS_COILS = 0x02,
+    MODBUS_FC_READ_HOLDING_REGISTERS = 0x03,
+    MODBUS_FC_READ_INPUT_REGISTERS = 0x04,
+    MODBUS_FC_WRITE_SINGLE_COIL = 0x05,
+    MODBUS_FC_WRITE_SINGLE_REGISTER = 0x06,
+    MODBUS_FC_READ_EXCEPTION_STATUS = 0x07,
+    MODBUS_FC_WRITE_MULTIPLE_COILS = 0x0F,
+    MODBUS_FC_WRITE_MULTIPLE_REGISTERS = 0x10,
+    MODBUS_FC_REPORT_SLAVE_ID = 0x11,
+    MODBUS_FC_MASK_WRITE_REGISTER = 0x16,
+    MODBUS_FC_WRITE_AND_READ_REGISTERS = 0x17,
 };
 
 ///* Protocol exceptions */
@@ -44,55 +44,55 @@ enum functionCode
 
 enum returnCode
 {
-	MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE = -0x83,
-	MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS = -0x82,
-	MODBUS_EXCEPTION_ILLEGAL_FUNCTION = -0x81,
-	MODBUS_EXCEPTION = -0x80,
-	MODBUS_ERROR_CONTEXT = -0x0A,
-	MODBUS_ERROR_WAIT = -9,
-	MODBUS_ERROR_READ = -8,
-	MODBUS_FAIL_CHECK = -7,
-	MODBUS_FAIL_ADRR = -6,
-	MODBUS_FAIL_HANDLE = -5,
-	MODBUS_FAIL_CONFIRM = -4,
-	MODBUS_FAIL_REQUEST = -3,
-	MODBUS_TIMEOUT = -2,
-	MODBUS_FAIL = -1,
-	MODBUS_OK = 0
+    MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE = -0x83,
+    MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS = -0x82,
+    MODBUS_EXCEPTION_ILLEGAL_FUNCTION = -0x81,
+    MODBUS_EXCEPTION = -0x80,
+    MODBUS_ERROR_CONTEXT = -0x0A,
+    MODBUS_ERROR_WAIT = -9,
+    MODBUS_ERROR_READ = -8,
+    MODBUS_FAIL_CHECK = -7,
+    MODBUS_FAIL_ADRR = -6,
+    MODBUS_FAIL_HANDLE = -5,
+    MODBUS_FAIL_CONFIRM = -4,
+    MODBUS_FAIL_REQUEST = -3,
+    MODBUS_TIMEOUT = -2,
+    MODBUS_FAIL = -1,
+    MODBUS_OK = 0
 };
 
 enum waitCode
 {
-	MODBUS_WAIT_FOREVER = -1,
-	MODBUS_WAIT_NO = 0
+    MODBUS_WAIT_FOREVER = -1,
+    MODBUS_WAIT_NO = 0
 };
 
 enum coreType
 {
-	MODBUS_CORE_NONE = 0,
-	MODBUS_CORE_RTU = 1,
-	MODBUS_CORE_TCP = 2
+    MODBUS_CORE_NONE = 0,
+    MODBUS_CORE_RTU = 1,
+    MODBUS_CORE_TCP = 2
 };
 
 enum portType
 {
-	MODBUS_PORT_NONE = 0,
-	MODBUS_PORT_DEVICE = 1,
-	MODBUS_PORT_SOCKET = 2
+    MODBUS_PORT_NONE = 0,
+    MODBUS_PORT_DEVICE = 1,
+    MODBUS_PORT_SOCKET = 2
 };
 
 enum deviceType
 {
-	MODBUS_DEVICE_NONE = 0,
-	MODBUS_DEVICE_SLAVE = 1,
-	MODBUS_DEVICE_MASTER = 2
+    MODBUS_DEVICE_NONE = 0,
+    MODBUS_DEVICE_SLAVE = 1,
+    MODBUS_DEVICE_MASTER = 2
 };
 
 enum modbusMagic
 {
-	MODBUS_MAGIC = 0x4243424D,			//"MBCB"
-	MODBUS_CORE_MAGIC = 0x4343424D, //"MBCC"
-	MODBUS_PORT_MAGIC = 0x5050424D, //"MBPP"
+    MODBUS_MAGIC = 0x4243424D,          //"MBCB"
+    MODBUS_CORE_MAGIC = 0x4343424D, //"MBCC"
+    MODBUS_PORT_MAGIC = 0x5050424D, //"MBPP"
 };
 
 #define MODBUS_BROADCAST_ADDRESS 0
@@ -159,48 +159,48 @@ typedef struct _small_modbus_port small_modbus_port_t; // modbus port (rtthread
 
 struct _small_modbus_core
 {
-	const uint32_t magic;
-	const uint16_t type;
-	const uint16_t len_header;
-	const uint16_t len_checksum;
-	const uint16_t len_adu_max;
-	int (*build_request_header)(small_modbus_t *smb, uint8_t *buff, int slave, int fun, int reg, int num);
-	int (*build_response_header)(small_modbus_t *smb, uint8_t *buff, int slave, int fun);
-	int (*check_send_pre)(small_modbus_t *smb, uint8_t *buff, int length);
-	int (*check_wait_request)(small_modbus_t *smb, uint8_t *buff, int length);
-	int (*check_wait_response)(small_modbus_t *smb, uint8_t *buff, int length);
+    const uint32_t magic;
+    const uint16_t type;
+    const uint16_t len_header;
+    const uint16_t len_checksum;
+    const uint16_t len_adu_max;
+    int (*build_request_header)(small_modbus_t *smb, uint8_t *buff, int slave, int fun, int reg, int num);
+    int (*build_response_header)(small_modbus_t *smb, uint8_t *buff, int slave, int fun);
+    int (*check_send_pre)(small_modbus_t *smb, uint8_t *buff, int length);
+    int (*check_wait_request)(small_modbus_t *smb, uint8_t *buff, int length);
+    int (*check_wait_response)(small_modbus_t *smb, uint8_t *buff, int length);
 };
 
 struct _small_modbus_port
 {
-	const uint32_t magic;
-	const uint32_t type;
-	int (*open)(small_modbus_t *smb);
-	int (*close)(small_modbus_t *smb);
-	int (*read)(small_modbus_t *smb, uint8_t *data, uint16_t length);
-	int (*write)(small_modbus_t *smb, uint8_t *data, uint16_t length);
-	int (*flush)(small_modbus_t *smb);
-	int (*wait)(small_modbus_t *smb, int timeout);
+    const uint32_t magic;
+    const uint32_t type;
+    int (*open)(small_modbus_t *smb);
+    int (*close)(small_modbus_t *smb);
+    int (*read)(small_modbus_t *smb, uint8_t *data, uint16_t length);
+    int (*write)(small_modbus_t *smb, uint8_t *data, uint16_t length);
+    int (*flush)(small_modbus_t *smb);
+    int (*wait)(small_modbus_t *smb, int timeout);
 };
 
 struct _small_modbus
 {
-	uint32_t modbus_magic;
-	uint16_t device_mode;
-	uint8_t slave_addr;
-	uint8_t debug_level;
-
-	uint16_t transfer_id;
-	uint16_t protocol_id;
-
-	int status;
-	int error_code;
-	uint32_t timeout_frame;										 //帧超时时间ms
-	uint32_t timeout_byte;										 //字节超时时间ms
-	uint8_t read_buff[MODBUS_MAX_ADU_LENGTH];	 // modbus读缓冲区
-	uint8_t write_buff[MODBUS_MAX_ADU_LENGTH]; // modbus写缓冲区
-	small_modbus_core_t *core;								 // modbus core (modbus-rtu,modbus-tcp)
-	small_modbus_port_t *port;								 // modbus port (rtthread  ,linux ,win32) serial socket
+    uint32_t modbus_magic;
+    uint16_t device_mode;
+    uint8_t slave_addr;
+    uint8_t debug_level;
+
+    uint16_t transfer_id;
+    uint16_t protocol_id;
+
+    int status;
+    int error_code;
+    uint32_t timeout_frame;                                      //帧超时时间ms
+    uint32_t timeout_byte;                                       //字节超时时间ms
+    uint8_t read_buff[MODBUS_MAX_ADU_LENGTH];    // modbus读缓冲区
+    uint8_t write_buff[MODBUS_MAX_ADU_LENGTH]; // modbus写缓冲区
+    small_modbus_core_t *core;                               // modbus core (modbus-rtu,modbus-tcp)
+    small_modbus_port_t *port;                               // modbus port (rtthread  ,linux ,win32) serial socket
 };
 
 int _modbus_init(small_modbus_t *smb);

inc/small_modbus_port_rtthread.h

@@ -28,14 +28,14 @@ typedef struct small_modbus_port_rtdevice small_modbus_port_rtdevice_t;
 
 struct small_modbus_port_rtdevice
 {
-	struct _small_modbus_port base;
-	struct serial_configure serial_config;
-	const char *device_name;
-	struct rt_device *device;
-	struct rt_semaphore rx_sem;
-	rt_size_t rx_size;
-	int oflag;
-	int (*rts_set)(int on);
+    struct _small_modbus_port base;
+    struct serial_configure serial_config;
+    const char *device_name;
+    struct rt_device *device;
+    struct rt_semaphore rx_sem;
+    rt_size_t rx_size;
+    int oflag;
+    int (*rts_set)(int on);
 };
 
 small_modbus_port_rtdevice_t *modbus_port_rtdevice_get(small_modbus_t *smb);
@@ -84,15 +84,15 @@ typedef struct small_modbus_port_rtsocket small_modbus_port_rtsocket_t;
 
 struct small_modbus_port_rtsocket
 {
-	struct _small_modbus_port base;
-	int32_t socket_fd;
-	int devicemode;
-	const char *hostname;
-	const char *hostport;
-
-	struct rt_ringbuffer rx_ringbuff;
-	uint8_t rx_temp[256];
-	uint8_t rx_ringbuff_pool[256];
+    struct _small_modbus_port base;
+    int32_t socket_fd;
+    int devicemode;
+    const char *hostname;
+    const char *hostport;
+
+    struct rt_ringbuffer rx_ringbuff;
+    uint8_t rx_temp[256];
+    uint8_t rx_ringbuff_pool[256];
 };
 
 int modbus_tcp_status(small_modbus_t *smb);

src/small_modbus_port_linux.c

@@ -1,7 +1,7 @@
 /*
  * Change Logs:
  * Date           Author       Notes
- * 2021-06     		chenbin      small_modbus_port_linux.c  for linux
+ * 2021-06          chenbin      small_modbus_port_linux.c  for linux
  */
 
 #include "small_modbus_port_linux.h"

src/small_modbus_port_rtthread.c

@@ -1,7 +1,7 @@
 /*
  * Change Logs:
  * Date           Author       Notes
- * 2021-03     		chenbin      small_modbus_rtthread.c  for rtthread
+ * 2021-03          chenbin      small_modbus_rtthread.c  for rtthread
  */
 
 #include "small_modbus_port_rtthread.h"
@@ -16,67 +16,67 @@
 
 int _modbus_debug(small_modbus_t *smb, int level, const char *fmt, ...)
 {
-	static char log_buf[256];
-	rt_enter_critical();
-	if (level <= smb->debug_level)
-	{
-		va_list args;
-		va_start(args, fmt);
-		rt_vsnprintf(log_buf, 256, fmt, args);
-		va_end(args);
-		rt_kputs(log_buf);
-	}
-	rt_exit_critical();
-	return 0;
+    static char log_buf[256];
+    rt_enter_critical();
+    if (level <= smb->debug_level)
+    {
+        va_list args;
+        va_start(args, fmt);
+        rt_vsnprintf(log_buf, 256, fmt, args);
+        va_end(args);
+        rt_kputs(log_buf);
+    }
+    rt_exit_critical();
+    return 0;
 }
 /*
  *modbus_init
  */
 int modbus_init(small_modbus_t *smb, uint8_t core_type, void *port)
 {
-	small_modbus_port_t *smb_port = port;
-	if (smb && core_type && smb_port)
-	{
-		_modbus_init(smb);
-		if ((core_type == MODBUS_CORE_RTU) || (core_type == MODBUS_CORE_TCP)) // check core type
-		{
-			if (core_type == MODBUS_CORE_RTU)
-			{
-				smb->core = (small_modbus_core_t *)&_modbus_rtu_core;
-			}
-			if (core_type == MODBUS_CORE_TCP)
-			{
-				smb->core = (small_modbus_core_t *)&_modbus_tcp_core;
-			}
-		}
-		else
-		{
-			return 0;
-		}
-		if ((smb_port->type == MODBUS_PORT_DEVICE) || (smb_port->type == MODBUS_PORT_SOCKET)) // check port type
-		{
-			smb->port = smb_port;
-			return 1;
-		}
-	}
-	return 0;
+    small_modbus_port_t *smb_port = port;
+    if (smb && core_type && smb_port)
+    {
+        _modbus_init(smb);
+        if ((core_type == MODBUS_CORE_RTU) || (core_type == MODBUS_CORE_TCP)) // check core type
+        {
+            if (core_type == MODBUS_CORE_RTU)
+            {
+                smb->core = (small_modbus_core_t *)&_modbus_rtu_core;
+            }
+            if (core_type == MODBUS_CORE_TCP)
+            {
+                smb->core = (small_modbus_core_t *)&_modbus_tcp_core;
+            }
+        }
+        else
+        {
+            return 0;
+        }
+        if ((smb_port->type == MODBUS_PORT_DEVICE) || (smb_port->type == MODBUS_PORT_SOCKET)) // check port type
+        {
+            smb->port = smb_port;
+            return 1;
+        }
+    }
+    return 0;
 }
 
 small_modbus_t *modbus_create(uint8_t core_type, void *port)
 {
-	small_modbus_t *smb = rt_malloc_align(sizeof(small_modbus_t), 4);
-	if (smb)
-	{
-		if (modbus_init(smb, core_type, port))
-		{
-			return smb;
-		}
-		else
-		{
-			rt_free_align(smb);
-		}
-	}
-	return NULL;
+    small_modbus_t *smb = rt_malloc_align(sizeof(small_modbus_t), 4);
+    if (smb)
+    {
+        if (modbus_init(smb, core_type, port))
+        {
+            return smb;
+        }
+        else
+        {
+            rt_free_align(smb);
+        }
+    }
+    return NULL;
 }
 
 /*
@@ -89,198 +89,198 @@ small_modbus_t *modbus_create(uint8_t core_type, void *port)
 
 static rt_err_t _modbus_rtdevice_rx_indicate(rt_device_t dev, rt_size_t size)
 {
-	small_modbus_port_rtdevice_t *smb_port_device = dev->user_data;
+    small_modbus_port_rtdevice_t *smb_port_device = dev->user_data;
 
-	smb_port_device->rx_size = size;
+    smb_port_device->rx_size = size;
 
-	return rt_sem_release(&(smb_port_device->rx_sem));
+    return rt_sem_release(&(smb_port_device->rx_sem));
 }
 
 static int _modbus_rtdevice_open(small_modbus_t *smb)
 {
-	small_modbus_port_rtdevice_t *smb_port_device = (small_modbus_port_rtdevice_t *)smb->port;
-	if (smb_port_device->device)
-	{
-		smb_port_device->device->user_data = smb_port_device;
+    small_modbus_port_rtdevice_t *smb_port_device = (small_modbus_port_rtdevice_t *)smb->port;
+    if (smb_port_device->device)
+    {
+        smb_port_device->device->user_data = smb_port_device;
 
-		rt_device_set_rx_indicate(smb_port_device->device, _modbus_rtdevice_rx_indicate);
+        rt_device_set_rx_indicate(smb_port_device->device, _modbus_rtdevice_rx_indicate);
 
-		rt_device_open(smb_port_device->device, smb_port_device->oflag);
-		// rt_device_open(smb_port_device->device, RT_DEVICE_FLAG_INT_RX);
-		// rt_device_open(smb_port_device->device, RT_DEVICE_FLAG_DMA_RX);
+        rt_device_open(smb_port_device->device, smb_port_device->oflag);
+        // rt_device_open(smb_port_device->device, RT_DEVICE_FLAG_INT_RX);
+        // rt_device_open(smb_port_device->device, RT_DEVICE_FLAG_DMA_RX);
 
-		if (smb_port_device->rts_set)
-		{
-			smb_port_device->rts_set(0);
-		}
-	}
-	return 0;
+        if (smb_port_device->rts_set)
+        {
+            smb_port_device->rts_set(0);
+        }
+    }
+    return 0;
 }
 
 static int _modbus_rtdevice_close(small_modbus_t *smb)
 {
-	small_modbus_port_rtdevice_t *smb_port_device = (small_modbus_port_rtdevice_t *)smb->port;
-	if (smb_port_device->device)
-	{
-		rt_device_close(smb_port_device->device);
-	}
-	return 0;
+    small_modbus_port_rtdevice_t *smb_port_device = (small_modbus_port_rtdevice_t *)smb->port;
+    if (smb_port_device->device)
+    {
+        rt_device_close(smb_port_device->device);
+    }
+    return 0;
 }
 
 static int _modbus_rtdevice_write(small_modbus_t *smb, uint8_t *data, uint16_t length)
 {
-	small_modbus_port_rtdevice_t *smb_port_device = (small_modbus_port_rtdevice_t *)smb->port;
+    small_modbus_port_rtdevice_t *smb_port_device = (small_modbus_port_rtdevice_t *)smb->port;
 
-	if (smb_port_device->rts_set)
-		smb_port_device->rts_set(1);
+    if (smb_port_device->rts_set)
+        smb_port_device->rts_set(1);
 
-	rt_enter_critical(); // poll write start
+    rt_enter_critical(); // poll write start
 
-	rt_device_write(smb_port_device->device, 0, data, length);
+    rt_device_write(smb_port_device->device, 0, data, length);
 
-	rt_exit_critical(); // poll write end
+    rt_exit_critical(); // poll write end
 
-	if (smb_port_device->rts_set)
-		smb_port_device->rts_set(0);
+    if (smb_port_device->rts_set)
+        smb_port_device->rts_set(0);
 
-	return length;
+    return length;
 }
 
 static int _modbus_rtdevice_read(small_modbus_t *smb, uint8_t *data, uint16_t length)
 {
-	small_modbus_port_rtdevice_t *smb_port_device = (small_modbus_port_rtdevice_t *)smb->port;
+    small_modbus_port_rtdevice_t *smb_port_device = (small_modbus_port_rtdevice_t *)smb->port;
 
-	return rt_device_read(smb_port_device->device, 0, data, length);
+    return rt_device_read(smb_port_device->device, 0, data, length);
 }
 
 static int _modbus_rtdevice_flush(small_modbus_t *smb)
 {
-	small_modbus_port_rtdevice_t *smb_port_device = (small_modbus_port_rtdevice_t *)smb->port;
+    small_modbus_port_rtdevice_t *smb_port_device = (small_modbus_port_rtdevice_t *)smb->port;
 
-	int rc = rt_device_read(smb_port_device->device, 0, smb->read_buff, MODBUS_MAX_ADU_LENGTH);
+    int rc = rt_device_read(smb_port_device->device, 0, smb->read_buff, MODBUS_MAX_ADU_LENGTH);
 
-	rt_sem_control(&(smb_port_device->rx_sem), RT_IPC_CMD_RESET, RT_NULL);
-	return rc;
+    rt_sem_control(&(smb_port_device->rx_sem), RT_IPC_CMD_RESET, RT_NULL);
+    return rc;
 }
 
 static int _modbus_rtdevice_wait(small_modbus_t *smb, int timeout)
 {
-	int rc = -1;
-	small_modbus_port_rtdevice_t *smb_port_device = (small_modbus_port_rtdevice_t *)smb->port;
+    int rc = -1;
+    small_modbus_port_rtdevice_t *smb_port_device = (small_modbus_port_rtdevice_t *)smb->port;
 
-	rc = rt_sem_take(&(smb_port_device->rx_sem), timeout);
-	if (rc < RT_EOK)
-	{
-		return MODBUS_TIMEOUT;
-	}
-	if (smb_port_device->rx_size == 0)
-	{
-		return MODBUS_ERROR_READ;
-	}
-	return rc;
+    rc = rt_sem_take(&(smb_port_device->rx_sem), timeout);
+    if (rc < RT_EOK)
+    {
+        return MODBUS_TIMEOUT;
+    }
+    if (smb_port_device->rx_size == 0)
+    {
+        return MODBUS_ERROR_READ;
+    }
+    return rc;
 }
 
 small_modbus_port_rtdevice_t *modbus_port_rtdevice_get(small_modbus_t *smb)
 {
-	if ((smb->port->type == MODBUS_PORT_DEVICE) && (smb->port->magic == MODBUS_PORT_MAGIC))
-	{
-		return (small_modbus_port_rtdevice_t *)smb->port;
-	}
-	return NULL;
+    if ((smb->port->type == MODBUS_PORT_DEVICE) && (smb->port->magic == MODBUS_PORT_MAGIC))
+    {
+        return (small_modbus_port_rtdevice_t *)smb->port;
+    }
+    return NULL;
 }
 
 int modbus_port_rtdevice_init(small_modbus_port_rtdevice_t *port, const char *device_name)
 {
-	(*(uint32_t *)&(port->base.type)) = MODBUS_PORT_DEVICE;
-	(*(uint32_t *)&(port->base.magic)) = MODBUS_PORT_MAGIC;
-	port->base.open = _modbus_rtdevice_open;
-	port->base.close = _modbus_rtdevice_close;
-	port->base.read = _modbus_rtdevice_read;
-	port->base.write = _modbus_rtdevice_write;
-	port->base.flush = _modbus_rtdevice_flush;
-	port->base.wait = _modbus_rtdevice_wait;
+    (*(uint32_t *)&(port->base.type)) = MODBUS_PORT_DEVICE;
+    (*(uint32_t *)&(port->base.magic)) = MODBUS_PORT_MAGIC;
+    port->base.open = _modbus_rtdevice_open;
+    port->base.close = _modbus_rtdevice_close;
+    port->base.read = _modbus_rtdevice_read;
+    port->base.write = _modbus_rtdevice_write;
+    port->base.flush = _modbus_rtdevice_flush;
+    port->base.wait = _modbus_rtdevice_wait;
 
-	port->device_name = device_name;
-	port->device = rt_device_find(device_name);
-	if (port->device)
-	{
-		rt_sem_init(&(port->rx_sem), device_name, 0, RT_IPC_FLAG_FIFO);
-	}
-	return 0;
+    port->device_name = device_name;
+    port->device = rt_device_find(device_name);
+    if (port->device)
+    {
+        rt_sem_init(&(port->rx_sem), device_name, 0, RT_IPC_FLAG_FIFO);
+    }
+    return 0;
 }
 
 int modbus_port_rtdevice_deinit(small_modbus_port_rtdevice_t *port)
 {
-	if (port->device)
-	{
-		rt_device_close(port->device);
-	}
-	return 0;
+    if (port->device)
+    {
+        rt_device_close(port->device);
+    }
+    return 0;
 }
 
 small_modbus_port_rtdevice_t *modbus_port_rtdevice_create(const char *device_name)
 {
-	small_modbus_port_rtdevice_t *smb_port_device = rt_malloc_align(sizeof(small_modbus_port_rtdevice_t), 4);
-	if (smb_port_device)
-	{
-		rt_memset(smb_port_device, 0, sizeof(small_modbus_port_rtdevice_t));
-		modbus_port_rtdevice_init(smb_port_device, device_name);
-		return smb_port_device;
-	}
-	return NULL;
+    small_modbus_port_rtdevice_t *smb_port_device = rt_malloc_align(sizeof(small_modbus_port_rtdevice_t), 4);
+    if (smb_port_device)
+    {
+        rt_memset(smb_port_device, 0, sizeof(small_modbus_port_rtdevice_t));
+        modbus_port_rtdevice_init(smb_port_device, device_name);
+        return smb_port_device;
+    }
+    return NULL;
 }
 
 int modbus_port_rtdevice_delete(void *port)
 {
-	small_modbus_port_rtdevice_t *port_device = port;
-	if (port_device && (port_device->base.type == MODBUS_PORT_DEVICE) && (port_device->base.magic == MODBUS_PORT_MAGIC))
-	{
-		modbus_port_rtdevice_deinit(port_device);
-		rt_free_align(port_device);
-	}
-	return 0;
+    small_modbus_port_rtdevice_t *port_device = port;
+    if (port_device && (port_device->base.type == MODBUS_PORT_DEVICE) && (port_device->base.magic == MODBUS_PORT_MAGIC))
+    {
+        modbus_port_rtdevice_deinit(port_device);
+        rt_free_align(port_device);
+    }
+    return 0;
 }
 
 int modbus_rtu_set_serial_rts(small_modbus_t *smb, int (*rts_set)(int on))
 {
-	small_modbus_port_rtdevice_t *smb_port_device = modbus_port_rtdevice_get(smb);
-	if (smb_port_device)
-	{
-		smb_port_device->rts_set = rts_set;
-	}
-	return 0;
+    small_modbus_port_rtdevice_t *smb_port_device = modbus_port_rtdevice_get(smb);
+    if (smb_port_device)
+    {
+        smb_port_device->rts_set = rts_set;
+    }
+    return 0;
 }
 
 int modbus_rtu_set_serial_name(small_modbus_t *smb, const char *device_name)
 {
-	small_modbus_port_rtdevice_t *smb_port_device = modbus_port_rtdevice_get(smb);
-	if (smb_port_device)
-	{
-		modbus_port_rtdevice_init(smb_port_device, device_name);
-	}
-	return 0;
+    small_modbus_port_rtdevice_t *smb_port_device = modbus_port_rtdevice_get(smb);
+    if (smb_port_device)
+    {
+        modbus_port_rtdevice_init(smb_port_device, device_name);
+    }
+    return 0;
 }
 
 int modbus_rtu_set_serial_config(small_modbus_t *smb, struct serial_configure *serial_config)
 {
-	small_modbus_port_rtdevice_t *smb_port_device = modbus_port_rtdevice_get(smb);
-	if (smb_port_device)
-	{
-		if (smb_port_device->device)
-		{
-			rt_device_control(smb_port_device->device, RT_DEVICE_CTRL_CONFIG, serial_config);
-		}
-	}
-	return 0;
+    small_modbus_port_rtdevice_t *smb_port_device = modbus_port_rtdevice_get(smb);
+    if (smb_port_device)
+    {
+        if (smb_port_device->device)
+        {
+            rt_device_control(smb_port_device->device, RT_DEVICE_CTRL_CONFIG, serial_config);
+        }
+    }
+    return 0;
 }
 int modbus_rtu_set_oflag(small_modbus_t *smb, int oflag)
 {
-	small_modbus_port_rtdevice_t *smb_port_device = modbus_port_rtdevice_get(smb);
-	if (smb_port_device)
-	{
-		smb_port_device->oflag = oflag;
-	}
-	return 0;
+    small_modbus_port_rtdevice_t *smb_port_device = modbus_port_rtdevice_get(smb);
+    if (smb_port_device)
+    {
+        smb_port_device->oflag = oflag;
+    }
+    return 0;
 }
 
 #endif
@@ -310,163 +310,163 @@ int modbus_rtu_set_oflag(small_modbus_t *smb, int oflag)
 
 static int _modbus_rtsocket_open(small_modbus_t *smb)
 {
-	return modbus_tcp_connect(smb);
+    return modbus_tcp_connect(smb);
 }
 
 static int _modbus_rtsocket_close(small_modbus_t *smb)
 {
-	return modbus_tcp_disconnect(smb);
+    return modbus_tcp_disconnect(smb);
 }
 
 static int _modbus_rtsocket_write(small_modbus_t *smb, uint8_t *data, uint16_t length)
 {
-	small_modbus_port_rtsocket_t *smb_port_socket = (small_modbus_port_rtsocket_t *)smb->port;
+    small_modbus_port_rtsocket_t *smb_port_socket = (small_modbus_port_rtsocket_t *)smb->port;
 
-	send(smb_port_socket->socket_fd, data, length, 0);
+    send(smb_port_socket->socket_fd, data, length, 0);
 
-	return length;
+    return length;
 }
 
 static int _modbus_rtsocket_read(small_modbus_t *smb, uint8_t *data, uint16_t length)
 {
-	small_modbus_port_rtsocket_t *smb_port_socket = (small_modbus_port_rtsocket_t *)smb->port;
+    small_modbus_port_rtsocket_t *smb_port_socket = (small_modbus_port_rtsocket_t *)smb->port;
 
-	uint32_t read_len = rt_ringbuffer_data_len(&(smb_port_socket->rx_ringbuff));
-	if (read_len > length)
-	{
-		read_len = length; // min
-	}
-	if (read_len > 0)
-	{
-		rt_ringbuffer_get(&(smb_port_socket->rx_ringbuff), data, read_len);
-	}
-	return read_len;
+    uint32_t read_len = rt_ringbuffer_data_len(&(smb_port_socket->rx_ringbuff));
+    if (read_len > length)
+    {
+        read_len = length; // min
+    }
+    if (read_len > 0)
+    {
+        rt_ringbuffer_get(&(smb_port_socket->rx_ringbuff), data, read_len);
+    }
+    return read_len;
 }
 
 static int _modbus_rtsocket_flush(small_modbus_t *smb)
 {
-	small_modbus_port_rtsocket_t *smb_port_socket = (small_modbus_port_rtsocket_t *)smb->port;
+    small_modbus_port_rtsocket_t *smb_port_socket = (small_modbus_port_rtsocket_t *)smb->port;
 
-	uint32_t read_len = rt_ringbuffer_data_len(&(smb_port_socket->rx_ringbuff));
+    uint32_t read_len = rt_ringbuffer_data_len(&(smb_port_socket->rx_ringbuff));
 
-	rt_ringbuffer_reset(&(smb_port_socket->rx_ringbuff));
+    rt_ringbuffer_reset(&(smb_port_socket->rx_ringbuff));
 
-	return read_len;
+    return read_len;
 }
 
 static int _modbus_rtsocket_wait(small_modbus_t *smb, int timeout)
 {
-	int rc = -1;
-	int socket_status = 0;
-	socklen_t slen;
-	small_modbus_port_rtsocket_t *smb_port_socket = (small_modbus_port_rtsocket_t *)smb->port;
-
-	struct timeval tv = {
-			timeout / 1000,
-			(timeout % 1000) * 1000};
-
-	if ((tv.tv_sec == 0 && tv.tv_usec <= 0))
-	{
-		tv.tv_sec = 0;
-		tv.tv_usec = 1000 * 10;
-	}
-	setsockopt(smb_port_socket->socket_fd, SOL_SOCKET, SO_RCVTIMEO, (void *)&tv, sizeof(struct timeval));
-
-	rc = recv(smb_port_socket->socket_fd, smb_port_socket->rx_temp, sizeof(smb_port_socket->rx_temp), 0);
-	if (rc == 0) // socket wait_close
-	{
-		modbus_debug_error(smb, "rtsocket[%d] recv rc:%d wait_close\n", smb_port_socket->socket_fd, rc);
-		rc = MODBUS_ERROR_READ;
-	}
-	else if (rc < 0) // socket error
-	{
-		slen = sizeof(socket_status);
-		getsockopt(smb_port_socket->socket_fd, SOL_SOCKET, SO_ERROR, (void *)&socket_status, &slen);
-
-		if ((socket_status == 0 || socket_status == EINTR || socket_status == EWOULDBLOCK || socket_status == EAGAIN))
-		{
-			// rt_kprintf("rtsocket timeout :%d\n",rc);
-			rc = MODBUS_TIMEOUT;
-		}
-		else
-		{
-			modbus_debug_error(smb, "rtsocket[%d] recv err(%d)\n", smb_port_socket->socket_fd, socket_status);
-			rc = MODBUS_ERROR_READ;
-		}
-	}
-	else
-	{
-		rt_ringbuffer_put(&(smb_port_socket->rx_ringbuff), smb_port_socket->rx_temp, rc);
-	}
-	return rc;
+    int rc = -1;
+    int socket_status = 0;
+    socklen_t slen;
+    small_modbus_port_rtsocket_t *smb_port_socket = (small_modbus_port_rtsocket_t *)smb->port;
+
+    struct timeval tv = {
+            timeout / 1000,
+            (timeout % 1000) * 1000};
+
+    if ((tv.tv_sec == 0 && tv.tv_usec <= 0))
+    {
+        tv.tv_sec = 0;
+        tv.tv_usec = 1000 * 10;
+    }
+    setsockopt(smb_port_socket->socket_fd, SOL_SOCKET, SO_RCVTIMEO, (void *)&tv, sizeof(struct timeval));
+
+    rc = recv(smb_port_socket->socket_fd, smb_port_socket->rx_temp, sizeof(smb_port_socket->rx_temp), 0);
+    if (rc == 0) // socket wait_close
+    {
+        modbus_debug_error(smb, "rtsocket[%d] recv rc:%d wait_close\n", smb_port_socket->socket_fd, rc);
+        rc = MODBUS_ERROR_READ;
+    }
+    else if (rc < 0) // socket error
+    {
+        slen = sizeof(socket_status);
+        getsockopt(smb_port_socket->socket_fd, SOL_SOCKET, SO_ERROR, (void *)&socket_status, &slen);
+
+        if ((socket_status == 0 || socket_status == EINTR || socket_status == EWOULDBLOCK || socket_status == EAGAIN))
+        {
+            // rt_kprintf("rtsocket timeout :%d\n",rc);
+            rc = MODBUS_TIMEOUT;
+        }
+        else
+        {
+            modbus_debug_error(smb, "rtsocket[%d] recv err(%d)\n", smb_port_socket->socket_fd, socket_status);
+            rc = MODBUS_ERROR_READ;
+        }
+    }
+    else
+    {
+        rt_ringbuffer_put(&(smb_port_socket->rx_ringbuff), smb_port_socket->rx_temp, rc);
+    }
+    return rc;
 }
 
 small_modbus_port_rtsocket_t *modbus_port_rtsocket_get(small_modbus_t *smb)
 {
-	if ((smb->port->type == MODBUS_PORT_SOCKET) && (smb->port->magic == MODBUS_PORT_MAGIC))
-	{
-		return (small_modbus_port_rtsocket_t *)smb->port;
-	}
-	return NULL;
+    if ((smb->port->type == MODBUS_PORT_SOCKET) && (smb->port->magic == MODBUS_PORT_MAGIC))
+    {
+        return (small_modbus_port_rtsocket_t *)smb->port;
+    }
+    return NULL;
 }
 
 int modbus_port_rtsocket_init(small_modbus_port_rtsocket_t *port, int devicemode, char *hostname, char *hostport)
 {
-	(*(uint32_t *)&(port->base.type)) = MODBUS_PORT_SOCKET;
-	(*(uint32_t *)&(port->base.magic)) = MODBUS_PORT_MAGIC;
-	port->base.open = _modbus_rtsocket_open;
-	port->base.close = _modbus_rtsocket_close;
-	port->base.read = _modbus_rtsocket_read;
-	port->base.write = _modbus_rtsocket_write;
-	port->base.flush = _modbus_rtsocket_flush;
-	port->base.wait = _modbus_rtsocket_wait;
-
-	rt_ringbuffer_init(&(port->rx_ringbuff), port->rx_ringbuff_pool, sizeof(port->rx_ringbuff_pool)); // static init ringbuff
-
-	if (hostname)
-	{
-		port->hostname = hostname;
-	}
-	if (hostport)
-	{
-		port->hostport = hostport;
-	}
-	port->devicemode = devicemode;
-	port->socket_fd = -1;
-	return 0;
+    (*(uint32_t *)&(port->base.type)) = MODBUS_PORT_SOCKET;
+    (*(uint32_t *)&(port->base.magic)) = MODBUS_PORT_MAGIC;
+    port->base.open = _modbus_rtsocket_open;
+    port->base.close = _modbus_rtsocket_close;
+    port->base.read = _modbus_rtsocket_read;
+    port->base.write = _modbus_rtsocket_write;
+    port->base.flush = _modbus_rtsocket_flush;
+    port->base.wait = _modbus_rtsocket_wait;
+
+    rt_ringbuffer_init(&(port->rx_ringbuff), port->rx_ringbuff_pool, sizeof(port->rx_ringbuff_pool)); // static init ringbuff
+
+    if (hostname)
+    {
+        port->hostname = hostname;
+    }
+    if (hostport)
+    {
+        port->hostport = hostport;
+    }
+    port->devicemode = devicemode;
+    port->socket_fd = -1;
+    return 0;
 }
 
 int modbus_port_rtsocket_deinit(small_modbus_port_rtsocket_t *port)
 {
-	if (port->socket_fd >= 0)
-	{
-		closesocket(port->socket_fd);
-		port->socket_fd = -1;
-	}
-	return 0;
+    if (port->socket_fd >= 0)
+    {
+        closesocket(port->socket_fd);
+        port->socket_fd = -1;
+    }
+    return 0;
 }
 
 small_modbus_port_rtsocket_t *modbus_port_rtsocket_create(int devicemode, char *hostname, char *hostport)
 {
-	small_modbus_port_rtsocket_t *port_socket = rt_malloc_align(sizeof(small_modbus_port_rtsocket_t), 4);
-	if (port_socket)
-	{
-		rt_memset(port_socket, 0, sizeof(small_modbus_port_rtsocket_t));
-		modbus_port_rtsocket_init(port_socket, devicemode, hostname, hostport);
-		return port_socket;
-	}
-	return NULL;
+    small_modbus_port_rtsocket_t *port_socket = rt_malloc_align(sizeof(small_modbus_port_rtsocket_t), 4);
+    if (port_socket)
+    {
+        rt_memset(port_socket, 0, sizeof(small_modbus_port_rtsocket_t));
+        modbus_port_rtsocket_init(port_socket, devicemode, hostname, hostport);
+        return port_socket;
+    }
+    return NULL;
 }
 
 int modbus_port_rtsocket_delete(void *port)
 {
-	small_modbus_port_rtsocket_t *port_socket = port;
-	if (port_socket && (port_socket->base.type == MODBUS_PORT_SOCKET) && (port_socket->base.magic == MODBUS_PORT_MAGIC))
-	{
-		modbus_port_rtsocket_deinit(port_socket);
-		rt_free_align(port_socket);
-	}
-	return 0;
+    small_modbus_port_rtsocket_t *port_socket = port;
+    if (port_socket && (port_socket->base.type == MODBUS_PORT_SOCKET) && (port_socket->base.magic == MODBUS_PORT_MAGIC))
+    {
+        modbus_port_rtsocket_deinit(port_socket);
+        rt_free_align(port_socket);
+    }
+    return 0;
 }
 
 /*
@@ -474,209 +474,209 @@ int modbus_port_rtsocket_delete(void *port)
  */
 int modbus_tcp_status(small_modbus_t *smb)
 {
-	small_modbus_port_rtsocket_t *port_socket = (small_modbus_port_rtsocket_t *)smb->port;
+    small_modbus_port_rtsocket_t *port_socket = (small_modbus_port_rtsocket_t *)smb->port;
 
-	int socket_status = 0;
-	socklen_t slen;
+    int socket_status = 0;
+    socklen_t slen;
 
-	if ((port_socket) && (port_socket->socket_fd >= 0))
-	{
-		slen = sizeof(socket_status);
-		getsockopt(port_socket->socket_fd, SOL_SOCKET, SO_ERROR, (void *)&socket_status, &slen);
-	}
-	return socket_status;
+    if ((port_socket) && (port_socket->socket_fd >= 0))
+    {
+        slen = sizeof(socket_status);
+        getsockopt(port_socket->socket_fd, SOL_SOCKET, SO_ERROR, (void *)&socket_status, &slen);
+    }
+    return socket_status;
 }
 
 int modbus_tcp_disconnect(small_modbus_t *smb)
 {
-	small_modbus_port_rtsocket_t *port_socket = (small_modbus_port_rtsocket_t *)smb->port;
-	if ((port_socket) && (port_socket->socket_fd >= 0))
-	{
-		closesocket(port_socket->socket_fd);
-		port_socket->socket_fd = -1;
-	}
-	return 0;
+    small_modbus_port_rtsocket_t *port_socket = (small_modbus_port_rtsocket_t *)smb->port;
+    if ((port_socket) && (port_socket->socket_fd >= 0))
+    {
+        closesocket(port_socket->socket_fd);
+        port_socket->socket_fd = -1;
+    }
+    return 0;
 }
 
 int modbus_tcp_connect(small_modbus_t *smb)
 {
-	small_modbus_port_rtsocket_t *port_socket = modbus_port_rtsocket_get(smb);
-	if ((port_socket) && (port_socket->socket_fd < 0))
-	{
-		int ret = 0;
-		unsigned long mode = 0;
-		struct addrinfo hints, *addr_list, *cur;
-		struct timeval timeout;
-
-		struct sockaddr_in *socket_addr;
-		char addr_str[64];
-
-		/* Do name resolution with both IPv6 and IPv4 */
-		memset(&hints, 0, sizeof(hints));
-		hints.ai_family = AF_INET;
-		hints.ai_socktype = SOCK_STREAM;
-		hints.ai_protocol = IPPROTO_TCP;
-		// hints.ai_protocol = PROTOCOL_TLS;
-
-		ret = getaddrinfo(port_socket->hostname, port_socket->hostport, &hints, &addr_list);
-		if (ret != 0)
-		{
-			modbus_debug_info(smb, "rtsocket getaddrinfo fail [%d]\n", ret);
-			return ret;
-		}
-		for (cur = addr_list; cur != NULL; cur = cur->ai_next)
-		{
-			port_socket->socket_fd = socket(cur->ai_family, SOCK_STREAM, IPPROTO_TCP);
-			if (port_socket->socket_fd < 0)
-			{
-				continue;
-			}
-			mode = 0;
-			ioctlsocket(port_socket->socket_fd, FIONBIO, &mode);
-
-			ret = connect(port_socket->socket_fd, cur->ai_addr, cur->ai_addrlen);
-
-			socket_addr = (struct sockaddr_in *)(cur->ai_addr);
-
-			inet_ntoa_r(socket_addr->sin_addr.s_addr, addr_str, sizeof(addr_str) - 1);
-
-			modbus_debug_info(smb, "rtsocket[%d] connect: %s:%d  ret:%d\n", port_socket->socket_fd, addr_str, ntohs(socket_addr->sin_port), ret);
-			if (ret == 0)
-			{
-				break; //连接成功
-			}
-			closesocket(port_socket->socket_fd);
-		}
-		freeaddrinfo(addr_list);
-
-		timeout.tv_sec = smb->timeout_frame / 1000;
-		timeout.tv_usec = (smb->timeout_frame % 1000) * 1000;
-
-		setsockopt(port_socket->socket_fd, SOL_SOCKET, SO_RCVTIMEO, (void *)&timeout, sizeof(timeout));
-
-		setsockopt(port_socket->socket_fd, SOL_SOCKET, SO_SNDTIMEO, (void *)&timeout, sizeof(timeout));
-	}
-	return port_socket->socket_fd;
+    small_modbus_port_rtsocket_t *port_socket = modbus_port_rtsocket_get(smb);
+    if ((port_socket) && (port_socket->socket_fd < 0))
+    {
+        int ret = 0;
+        unsigned long mode = 0;
+        struct addrinfo hints, *addr_list, *cur;
+        struct timeval timeout;
+
+        struct sockaddr_in *socket_addr;
+        char addr_str[64];
+
+        /* Do name resolution with both IPv6 and IPv4 */
+        memset(&hints, 0, sizeof(hints));
+        hints.ai_family = AF_INET;
+        hints.ai_socktype = SOCK_STREAM;
+        hints.ai_protocol = IPPROTO_TCP;
+        // hints.ai_protocol = PROTOCOL_TLS;
+
+        ret = getaddrinfo(port_socket->hostname, port_socket->hostport, &hints, &addr_list);
+        if (ret != 0)
+        {
+            modbus_debug_info(smb, "rtsocket getaddrinfo fail [%d]\n", ret);
+            return ret;
+        }
+        for (cur = addr_list; cur != NULL; cur = cur->ai_next)
+        {
+            port_socket->socket_fd = socket(cur->ai_family, SOCK_STREAM, IPPROTO_TCP);
+            if (port_socket->socket_fd < 0)
+            {
+                continue;
+            }
+            mode = 0;
+            ioctlsocket(port_socket->socket_fd, FIONBIO, &mode);
+
+            ret = connect(port_socket->socket_fd, cur->ai_addr, cur->ai_addrlen);
+
+            socket_addr = (struct sockaddr_in *)(cur->ai_addr);
+
+            inet_ntoa_r(socket_addr->sin_addr.s_addr, addr_str, sizeof(addr_str) - 1);
+
+            modbus_debug_info(smb, "rtsocket[%d] connect: %s:%d  ret:%d\n", port_socket->socket_fd, addr_str, ntohs(socket_addr->sin_port), ret);
+            if (ret == 0)
+            {
+                break; //杩炴帴鎴愬姛
+            }
+            closesocket(port_socket->socket_fd);
+        }
+        freeaddrinfo(addr_list);
+
+        timeout.tv_sec = smb->timeout_frame / 1000;
+        timeout.tv_usec = (smb->timeout_frame % 1000) * 1000;
+
+        setsockopt(port_socket->socket_fd, SOL_SOCKET, SO_RCVTIMEO, (void *)&timeout, sizeof(timeout));
+
+        setsockopt(port_socket->socket_fd, SOL_SOCKET, SO_SNDTIMEO, (void *)&timeout, sizeof(timeout));
+    }
+    return port_socket->socket_fd;
 }
 
 int modbus_tcp_listen(small_modbus_t *smb, int max_connection)
 {
-	small_modbus_port_rtsocket_t *port_socket = modbus_port_rtsocket_get(smb);
-	if ((port_socket) && (port_socket->socket_fd < 0))
-	{
-		int ret = 0;
-		unsigned long mode = 0;
-		struct addrinfo hints, *addr_list, *cur;
-
-		struct sockaddr_in *socket_addr;
-		char addr_str[64];
-
-		/* Do name resolution with both IPv6 and IPv4 */
-		memset(&hints, 0, sizeof(hints));
-		hints.ai_family = AF_INET;
-		hints.ai_socktype = SOCK_STREAM;
-		hints.ai_protocol = IPPROTO_TCP;
-		// hints.ai_protocol = PROTOCOL_TLS;
-
-		ret = getaddrinfo(port_socket->hostname, port_socket->hostport, &hints, &addr_list);
-		if (ret != 0)
-		{
-			modbus_debug_info(smb, "rtsocket getaddrinfo fail [%d]\n", ret);
-			return ret;
-		}
-		for (cur = addr_list; cur != NULL; cur = cur->ai_next)
-		{
-			port_socket->socket_fd = socket(cur->ai_family, SOCK_STREAM, IPPROTO_TCP);
-			if (port_socket->socket_fd < 0)
-			{
-				continue;
-			}
-			mode = 0;
-			ioctlsocket(port_socket->socket_fd, FIONBIO, &mode);
-			mode = 1;
-			setsockopt(port_socket->socket_fd, SOL_SOCKET, SO_REUSEADDR, (void *)&mode, sizeof(mode));
-
-			ret = bind(port_socket->socket_fd, cur->ai_addr, cur->ai_addrlen);
-			if (ret == 0)
-			{
-				ret = listen(port_socket->socket_fd, max_connection);
-
-				socket_addr = (struct sockaddr_in *)(cur->ai_addr);
-				inet_ntoa_r(socket_addr->sin_addr.s_addr, addr_str, sizeof(addr_str) - 1);
-
-				modbus_debug_info(smb, "rtsocket[%d] listen: %s:%d  ret:%d\n", port_socket->socket_fd, addr_str, ntohs(socket_addr->sin_port), ret);
-				if (ret == 0)
-				{
-					break; //连接成功
-				}
-			}
-			else
-			{
-				modbus_debug_info(smb, "rtsocket[%d] bind:err ret:%d\n", port_socket->socket_fd, ret);
-			}
-			closesocket(port_socket->socket_fd);
-		}
-		freeaddrinfo(addr_list);
-	}
-	return port_socket->socket_fd;
+    small_modbus_port_rtsocket_t *port_socket = modbus_port_rtsocket_get(smb);
+    if ((port_socket) && (port_socket->socket_fd < 0))
+    {
+        int ret = 0;
+        unsigned long mode = 0;
+        struct addrinfo hints, *addr_list, *cur;
+
+        struct sockaddr_in *socket_addr;
+        char addr_str[64];
+
+        /* Do name resolution with both IPv6 and IPv4 */
+        memset(&hints, 0, sizeof(hints));
+        hints.ai_family = AF_INET;
+        hints.ai_socktype = SOCK_STREAM;
+        hints.ai_protocol = IPPROTO_TCP;
+        // hints.ai_protocol = PROTOCOL_TLS;
+
+        ret = getaddrinfo(port_socket->hostname, port_socket->hostport, &hints, &addr_list);
+        if (ret != 0)
+        {
+            modbus_debug_info(smb, "rtsocket getaddrinfo fail [%d]\n", ret);
+            return ret;
+        }
+        for (cur = addr_list; cur != NULL; cur = cur->ai_next)
+        {
+            port_socket->socket_fd = socket(cur->ai_family, SOCK_STREAM, IPPROTO_TCP);
+            if (port_socket->socket_fd < 0)
+            {
+                continue;
+            }
+            mode = 0;
+            ioctlsocket(port_socket->socket_fd, FIONBIO, &mode);
+            mode = 1;
+            setsockopt(port_socket->socket_fd, SOL_SOCKET, SO_REUSEADDR, (void *)&mode, sizeof(mode));
+
+            ret = bind(port_socket->socket_fd, cur->ai_addr, cur->ai_addrlen);
+            if (ret == 0)
+            {
+                ret = listen(port_socket->socket_fd, max_connection);
+
+                socket_addr = (struct sockaddr_in *)(cur->ai_addr);
+                inet_ntoa_r(socket_addr->sin_addr.s_addr, addr_str, sizeof(addr_str) - 1);
+
+                modbus_debug_info(smb, "rtsocket[%d] listen: %s:%d  ret:%d\n", port_socket->socket_fd, addr_str, ntohs(socket_addr->sin_port), ret);
+                if (ret == 0)
+                {
+                    break; //杩炴帴鎴愬姛
+                }
+            }
+            else
+            {
+                modbus_debug_info(smb, "rtsocket[%d] bind:err ret:%d\n", port_socket->socket_fd, ret);
+            }
+            closesocket(port_socket->socket_fd);
+        }
+        freeaddrinfo(addr_list);
+    }
+    return port_socket->socket_fd;
 }
 
 int modbus_tcp_accept(small_modbus_t *smb, int socket_fd)
 {
-	small_modbus_port_rtsocket_t *port_socket = modbus_port_rtsocket_get(smb);
+    small_modbus_port_rtsocket_t *port_socket = modbus_port_rtsocket_get(smb);
 
-	struct sockaddr_storage addr;
-	socklen_t addrlen;
-	int ret_socket = -1;
+    struct sockaddr_storage addr;
+    socklen_t addrlen;
+    int ret_socket = -1;
 
-	if ((port_socket) && (socket_fd >= 0))
-	{
-		ret_socket = accept(socket_fd, (struct sockaddr *)&addr, &addrlen);
-		if (ret_socket < 0)
-		{
-			closesocket(ret_socket);
-		}
-	}
-	return ret_socket;
+    if ((port_socket) && (socket_fd >= 0))
+    {
+        ret_socket = accept(socket_fd, (struct sockaddr *)&addr, &addrlen);
+        if (ret_socket < 0)
+        {
+            closesocket(ret_socket);
+        }
+    }
+    return ret_socket;
 }
 
 int modbus_tcp_get_socket(small_modbus_t *smb)
 {
-	small_modbus_port_rtsocket_t *port_socket = modbus_port_rtsocket_get(smb);
-	if (port_socket)
-	{
-		return port_socket->socket_fd;
-	}
-	return 0;
+    small_modbus_port_rtsocket_t *port_socket = modbus_port_rtsocket_get(smb);
+    if (port_socket)
+    {
+        return port_socket->socket_fd;
+    }
+    return 0;
 }
 
 int modbus_tcp_set_socket(small_modbus_t *smb, int socket)
 {
-	small_modbus_port_rtsocket_t *port_socket = modbus_port_rtsocket_get(smb);
-	if (port_socket)
-	{
-		port_socket->socket_fd = socket;
-	}
-	return 0;
+    small_modbus_port_rtsocket_t *port_socket = modbus_port_rtsocket_get(smb);
+    if (port_socket)
+    {
+        port_socket->socket_fd = socket;
+    }
+    return 0;
 }
 
 int modbus_tcp_set_socket_block(small_modbus_t *smb, int isblock)
 {
-	small_modbus_port_rtsocket_t *port_socket = modbus_port_rtsocket_get(smb);
-	unsigned long mode = 0;
-	if (port_socket)
-	{
-		if (isblock)
-		{
-			mode = 0;
-		}
-		else
-		{
-			mode = 1;
-		}
-		ioctlsocket(port_socket->socket_fd, FIONBIO, &mode);
-	}
-	return 0;
+    small_modbus_port_rtsocket_t *port_socket = modbus_port_rtsocket_get(smb);
+    unsigned long mode = 0;
+    if (port_socket)
+    {
+        if (isblock)
+        {
+            mode = 0;
+        }
+        else
+        {
+            mode = 1;
+        }
+        ioctlsocket(port_socket->socket_fd, FIONBIO, &mode);
+    }
+    return 0;
 }
 
 #endif

src/small_modbus_port_win32.c

@@ -1,7 +1,7 @@
 /*
  * Change Logs:
  * Date           Author       Notes
- * 2021-06     		chenbin      small_modbus_port_win32.c  for win32
+ * 2021-06          chenbin      small_modbus_port_win32.c  for win32
  */
 #include "small_modbus_port_win32.h"
 /*

src/small_modbus_utils.c

@@ -10,47 +10,47 @@
 
 uint16_t modbus_crc16(uint8_t *buffer, uint16_t buffer_length)
 {
-	uint16_t CRC = 0XFFFF;
-	uint16_t CRC_count = 0;
-	uint16_t i = 0;
-	for (CRC_count = 0; CRC_count < buffer_length; CRC_count++)
-	{
-		CRC = CRC ^ *(buffer + CRC_count);
-		for (i = 0; i < 8; i++)
-		{
-			if (CRC & 1)
-			{
-				CRC >>= 1;
-				CRC ^= 0xA001;
-			}
-			else
-			{
-				CRC >>= 1;
-			}
-		}
-	}
-	return CRC;
+    uint16_t CRC = 0XFFFF;
+    uint16_t CRC_count = 0;
+    uint16_t i = 0;
+    for (CRC_count = 0; CRC_count < buffer_length; CRC_count++)
+    {
+        CRC = CRC ^ *(buffer + CRC_count);
+        for (i = 0; i < 8; i++)
+        {
+            if (CRC & 1)
+            {
+                CRC >>= 1;
+                CRC ^= 0xA001;
+            }
+            else
+            {
+                CRC >>= 1;
+            }
+        }
+    }
+    return CRC;
 }
 
 int dio_get_val(uint8_t *array, uint16_t index)
 {
-	uint8_t offset_bit = (index & 0x07);	//(index%8);  //
-	uint8_t offset_arr = (index >> 0x03); //(index/8);  //
-	return (array[offset_arr] & (0x01 << offset_bit)) ? 1 : 0;
+    uint8_t offset_bit = (index & 0x07);    //(index%8);  //
+    uint8_t offset_arr = (index >> 0x03); //(index/8);  //
+    return (array[offset_arr] & (0x01 << offset_bit)) ? 1 : 0;
 }
 
 void dio_set_val(uint8_t *array, uint16_t index, int status)
 {
-	uint8_t offset_bit = (index & 0x07);	//(index%8);  //
-	uint8_t offset_arr = (index >> 0x03); //(index/8);  //
-	if (status)
-	{
-		array[offset_arr] |= (0x01 << offset_bit);
-	}
-	else
-	{
-		array[offset_arr] &= ~(0x01 << offset_bit);
-	}
+    uint8_t offset_bit = (index & 0x07);    //(index%8);  //
+    uint8_t offset_arr = (index >> 0x03); //(index/8);  //
+    if (status)
+    {
+        array[offset_arr] |= (0x01 << offset_bit);
+    }
+    else
+    {
+        array[offset_arr] &= ~(0x01 << offset_bit);
+    }
 }
 
 int aio_get_val(uint16_t *array, uint16_t index)
@@ -58,7 +58,7 @@ int aio_get_val(uint16_t *array, uint16_t index)
     uint8_t *buf = (uint8_t*)array;
     uint16_t status = (buf[(index * 2)]) + (buf[(index * 2) + 1] << 8);
 
-	return status; //array[index];
+    return status; //array[index];
 }
 
 void aio_set_val(uint16_t *array, uint16_t index, int status)
@@ -66,86 +66,86 @@ void aio_set_val(uint16_t *array, uint16_t index, int status)
     uint8_t *buf = (uint8_t*)array;
     buf[(index * 2)] = (status & 0x00FF);
     buf[(index * 2) + 1] = (status >> 8);
-	//array[index] = status;
+    //array[index] = status;
 }
 
 int modbus_check_addr_num(uint8_t function, uint16_t address, uint16_t num)
 {
-	switch (function)
-	{
-	case MODBUS_FC_READ_HOLDING_COILS:
-	case MODBUS_FC_READ_INPUTS_COILS:
-	{
-		if ((0 < num) && (num <= MODBUS_MAX_READ_BITS)) //¶ÁÈ¡µ½µÄÏßȦÊýÁ¿´óÓÚ0ÇÒСÓÚ2000¸ö
-		{
-			return 1;
-		}
-	}
-	break;
-	case MODBUS_FC_READ_HOLDING_REGISTERS:
-	case MODBUS_FC_READ_INPUT_REGISTERS:
-	{
-		if ((0 < num) && (num <= MODBUS_MAX_READ_REGISTERS)) //¶ÁÈ¡µ½µÄ¼Ä´æÆ÷ÊýÁ¿´óÓÚ0ÇÒСÓÚ125¸ö
-		{
-			return 1;
-		}
-	}
-	break;
-	case MODBUS_FC_WRITE_MULTIPLE_COILS:
-	{
-		if ((0 < num) && (num <= MODBUS_MAX_WRITE_BITS)) //¶ÁÈ¡µ½µÄ¼Ä´æÆ÷ÊýÁ¿´óÓÚ0ÇÒСÓÚ1968¸ö
-		{
-			return 1;
-		}
-	}
-	break;
-	case MODBUS_FC_WRITE_MULTIPLE_REGISTERS:
-	{
-		if ((0 < num) && (num <= MODBUS_MAX_WRITE_REGISTERS)) //¶ÁÈ¡µ½µÄ¼Ä´æÆ÷ÊýÁ¿´óÓÚ0ÇÒСÓÚ123¸ö
-		{
-			return 1;
-		}
-	}
-	break;
-	case MODBUS_FC_WRITE_SINGLE_COIL:
-	case MODBUS_FC_WRITE_SINGLE_REGISTER:
-	{
-		return 1;
-	}
-	}
-	return 0;
+    switch (function)
+    {
+    case MODBUS_FC_READ_HOLDING_COILS:
+    case MODBUS_FC_READ_INPUTS_COILS:
+    {
+        if ((0 < num) && (num <= MODBUS_MAX_READ_BITS)) //读�到的线圈数�大于0且�于2000个
+        {
+            return 1;
+        }
+    }
+    break;
+    case MODBUS_FC_READ_HOLDING_REGISTERS:
+    case MODBUS_FC_READ_INPUT_REGISTERS:
+    {
+        if ((0 < num) && (num <= MODBUS_MAX_READ_REGISTERS)) //读�到的寄存器数�大于0且�于125个
+        {
+            return 1;
+        }
+    }
+    break;
+    case MODBUS_FC_WRITE_MULTIPLE_COILS:
+    {
+        if ((0 < num) && (num <= MODBUS_MAX_WRITE_BITS)) //读�到的寄存器数�大于0且�于1968个
+        {
+            return 1;
+        }
+    }
+    break;
+    case MODBUS_FC_WRITE_MULTIPLE_REGISTERS:
+    {
+        if ((0 < num) && (num <= MODBUS_MAX_WRITE_REGISTERS)) //读�到的寄存器数�大于0且�于123个
+        {
+            return 1;
+        }
+    }
+    break;
+    case MODBUS_FC_WRITE_SINGLE_COIL:
+    case MODBUS_FC_WRITE_SINGLE_REGISTER:
+    {
+        return 1;
+    }
+    }
+    return 0;
 }
 
 void modbus_byte_copy(uint8_t *des, uint8_t *src, int num)
 {
-	while (num--)
-	{
-		*des = *src;
-		des++;
-		src++;
-	}
+    while (num--)
+    {
+        *des = *src;
+        des++;
+        src++;
+    }
 }
 
 void modbus_coil_h2m(uint8_t *des, uint8_t *src, int coil_num)
 {
-	int num = (coil_num / 8) + ((coil_num % 8) ? 1 : 0);
-	do
-	{
-		*des = *src;
-		des++;
-		src++;
-	} while (--num);
+    int num = (coil_num / 8) + ((coil_num % 8) ? 1 : 0);
+    do
+    {
+        *des = *src;
+        des++;
+        src++;
+    } while (--num);
 }
 
 void modbus_coil_m2h(uint8_t *des, uint8_t *src, int coil_num)
 {
-	int num = (coil_num / 8) + ((coil_num % 8) ? 1 : 0);
-	do
-	{
-		*des = *src;
-		des++;
-		src++;
-	} while (--num);
+    int num = (coil_num / 8) + ((coil_num % 8) ? 1 : 0);
+    do
+    {
+        *des = *src;
+        des++;
+        src++;
+    } while (--num);
 }
 
 /*