c#界面 libmodbus封装使用实例（update）

最新推荐文章于 2024-07-05 09:29:05 发布
最新推荐文章于 2024-07-05 09:29:05 发布
阅读量2.7k 收藏 7
点赞数 1
分类专栏： c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ericwuhk/article/details/80076950
版权

在libmodbus基础上增加封装读取配置文件ini的功能（未能按照section待完善），增加三轴控制功能，包括复位、步进调试等，功能已经完成，界面如下：


记录关键代码如下：



c语言底层库 rotControl.c , rotControl.h

void readIni()
{
	m_platform_setup.comIndex = (short)getValue("Serial");
	/*m_platform_setup.comIndex = hw_config->value("/COM/COM").toInt();  //QT移植
	m_platform_setup.Axis1_PulsePerRoll = hw_config->value("/AXIS1/PulsePerRoll").toInt();
	m_platform_setup.Axis1_Ratio = hw_config->value("/AXIS1/Ratio").toInt();
	m_platform_setup.Axis1_RangeMax = hw_config->value("/AXIS1/RangeMax").toInt();
	m_platform_setup.Axis1_RangeMin = hw_config->value("/AXIS1/RangeMin").toInt();

	m_platform_setup.Axis2_PulsePerRoll = hw_config->value("/AXIS2/PulsePerRoll").toInt();
	m_platform_setup.Axis2_Ratio = hw_config->value("/AXIS2/Ratio").toInt();
	m_platform_setup.Axis2_RangeMax = hw_config->value("/AXIS2/RangeMax").toInt();
	m_platform_setup.Axis2_RangeMin = hw_config->value("/AXIS2/RangeMin").toInt();

	m_platform_setup.Axis3_PulsePerRoll = hw_config->value("/AXIS3/PulsePerRoll").toInt();
	m_platform_setup.Axis3_Ratio = hw_config->value("/AXIS3/Ratio").toInt();
	m_platform_setup.Axis3_RangeMax = hw_config->value("/AXIS3/RangeMax").toInt();
	m_platform_setup.Axis3_RangeMin = hw_config->value("/AXIS3/RangeMin").toInt();*/
}

void paraInit()
{
	b_stop = false;
	b_isInitial = false;
	m_ctx = NULL;	

	readIni();
}

/*https://www.cnblogs.com/lvdongjie/p/4553815.html*/
void usleep(ULONG ulMicroSeconds)
{
	LARGE_INTEGER varFrequency = { 0 }, varCounter_Start = { 0 }, varCounter_End = { 0 };
	LONGLONG llCount = 0;

	QueryPerformanceFrequency(&varFrequency);
	QueryPerformanceCounter(&varCounter_Start);

	while (true)
	{
		QueryPerformanceCounter(&varCounter_End);

		llCount = varCounter_End.QuadPart - varCounter_Start.QuadPart;

		if (1000000 * llCount > ulMicroSeconds*varFrequency.QuadPart)
		{
			break;
		}
	}
}

int rot_plat_home(int id, int vel)
{
	if (!b_isInitial) {
		return -1;
	}
	int ret = 0;
	if (id == Rot_Axis_1) {
		ret = modbus_write_bit(m_ctx, Emgency, OFF);
		ret = modbus_write_bit(m_ctx, CylinderEnable, OFF);
		ret = modbus_write_bit(m_ctx, CylinderRotateSwitch, OFF);

		ret = modbus_write_bit(m_ctx, AlarmClear_1, ON);
		ret = modbus_write_bit(m_ctx, AlarmClear_1, OFF);
		ret = modbus_write_bit(m_ctx, AlarmClear_1, ON);

		ret = modbus_write_bit(m_ctx, ResetVel_1, ON); 

		if (ret == -1) {
		return -1;
		}

		int overtime = 20;
		int i=0;
		do
		{
			ret=modbus_read_bits(m_ctx, ResetStatus, 1, m_buf_8);
			Sleep(1000);
			i++;
		} while ((m_buf_8[0] == 0)&&(i<overtime));

		if (i >= overtime)
		{
			i = 0;
			return -2;
		}

		return ret;		
	}
	else if (id == Rot_Axis_2)
	{
		ret = modbus_write_bit(m_ctx, AlarmClear_2, ON);
		ret = modbus_write_bit(m_ctx, AlarmClear_2, OFF);
		ret = modbus_write_bit(m_ctx, AlarmClear_2, ON);
		ret = modbus_write_bit(m_ctx, ResetVel_2, ON);
		if (ret == -1) {
			return -1;
		}
	}
	else if (id == Rot_Axis_3) {
		ret = modbus_write_bit(m_ctx, CylinderEnable, ON);
		usleep(50);
		ret = modbus_write_bit(m_ctx, CylinderRotateSwitch, OFF);//气缸

		int overtime = 10;
		int i = 0;
		do
		{
			ret = modbus_read_bits(m_ctx, Cylinder0Status, 1, m_buf_8);
			Sleep(1000);
		} while ((m_buf_8[0] == 0) && (i++<overtime));

		if (i >= overtime)
		{
			i = 0;
			return i;
		}

		/*int cnt = 0; revised 20180421
		while ((0 != modbus_read_bits(m_ctx, Cylinder0Status, 1, m_buf_8)) && cnt++ < 30)
		{
		}
		if (cnt >= 30) {
			return -1;
		}
		else
		{
			return (cnt < 30);
		}*/
	}
	//else if (id == Rot_Axis_All)
	//{

	//}

	return ret;
}
int rot_plat_moveto(int id, int pos, int vel, int acc)
{
	int ret = 0;
	if (!b_isInitial) {
		return -1;
	}
	if (id == Rot_Axis_1) {
		ret = modbus_write_bit(m_ctx, MoveAbsMode, ON);
		ret = modbus_write_bit(m_ctx, MoveStepMode, OFF);
		uint16_t ang[2];
		ang[0] = (uint16_t)(pos);
		ang[1] = (uint16_t)(pos >> 16);
		ret = modbus_write_registers(m_ctx, ObjAngles_1, 2, ang);

		modbus_read_registers(m_ctx, ObjAngles_1, 2, m_buf_16);

		if (m_buf_16[0] != ang[0] || m_buf_16[1] != ang[1]) {
			ret = -1;
		}

		uint16_t ve[2];
		ve[0] = (uint16_t)(vel);
		ve[1] = (uint16_t)(vel >> 16);
		ret = modbus_write_registers(m_ctx, ObjVel_1, 2, ve);
		modbus_read_registers(m_ctx, ObjVel_1, 2, m_buf_16);
		if (m_buf_16[0] != ve[0] || m_buf_16[1] != ve[1]) {
			ret = -1;
		}

		if (ret == -1) {
			return -1;
		}
		if (acc != 0) {
			modbus_write_register(m_ctx, AccTime_1, (uint16_t)acc);
			ret = modbus_write_bit(m_ctx, AccUpdate, ON);
			ret = modbus_write_bit(m_ctx, AccUpdate, OFF);
		}
		ret = modbus_write_bit(m_ctx, MoveSwitch_1, ON);
		int cnt = 0;
		// 		while ((0!=modbus_read_bits(m_ctx, Busy_1, 1, m_buf_8)) && cnt++ < 50)
		// 		{
		// 		}
		do
		{
			Sleep(20);
			modbus_read_bits(m_ctx, Busy_1, 1, m_buf_8);

		} while (m_buf_8[0] != 0 && cnt++<50);

		if (cnt >= 50)
			return cnt;

		ret = modbus_write_bit(m_ctx, MoveSwitch_1, OFF);
		cnt = 0;
		do
		{
			modbus_read_bits(m_ctx, Arrived_1, 1, m_buf_8);
		} while (m_buf_8[0] == 0 && cnt++<50);

		if (cnt >= 50)
			return cnt;
		// 		while (m_buf_8[0]==0 && cnt++ < 100)
		// 		{
		// 			modbus_read_bits(m_ctx, Arrived_1, 1, m_buf_8);
		// 			//usleep(100);
		// 		}

	}
	else if (id == Rot_Axis_2) {
		ret = modbus_write_bit(m_ctx, MoveAbsMode, ON);
		ret = modbus_write_bit(m_ctx, MoveStepMode, OFF);
		uint16_t ang[2];
		ang[0] = (uint16_t)(pos);
		ang[1] = (uint16_t)(pos >> 16);
		ret = modbus_write_registers(m_ctx, ObjAngles_2, 2, ang);
		uint16_t ve[2];
		ve[0] = (uint16_t)(vel);
		ve[1] = (uint16_t)(vel >> 16);
		ret = modbus_write_registers(m_ctx, ObjVel_2, 2, ve);
		if (ret == -1) {
			return -1;
		}
		if (acc != 0) {
			modbus_write_register(m_ctx, AccTime_2, (uint16_t)acc);
			ret = modbus_write_bit(m_ctx, AccUpdate, ON);
			ret = modbus_write_bit(m_ctx, AccUpdate, OFF);
		}
		ret = modbus_write_bit(m_ctx, MoveSwitch_2, ON);
		int cnt = 0;
		do
		{
			Sleep(20);
			modbus_read_bits(m_ctx, Busy_2, 1, m_buf_8);
		} while (m_buf_8[0] != 0 && cnt++<50);

		if (cnt >= 50)
			return cnt;
		// 		while ((0 != modbus_read_bits(m_ctx, Busy_2, 1, m_buf_8)))
		// 		{
		// 		}
		ret = modbus_write_bit(m_ctx, MoveSwitch_2, OFF);
		cnt = 0;
		do
		{
			modbus_read_bits(m_ctx, Arrived_2, 1, m_buf_8);
		} while ((m_buf_8[0] == 0) && (cnt++<50));

		// 		while ((0 != modbus_read_bits(m_ctx, Arrived_2, 1, m_buf_8)) && cnt++ < 100)
		// 		{
		// 			usleep(100);
		// 		}

		if (cnt >= 50)
			return cnt;
	}
	else if (id == Rot_Axis_3) {
		if (pos > 0) {
			ret = modbus_write_bit(m_ctx, CylinderEnable, ON);
			ret = modbus_write_bit(m_ctx, CylinderRotateSwitch, ON);

			if (ret == -1) {
				return -1;
			}

			int cnt = 0;

			do
			{
				modbus_read_bits(m_ctx, Cylinder90Status, 1, m_buf_8);
				//usleep(1);
			} while ((m_buf_8[0] == 0) && (cnt++<50));

			if (cnt >= 50)
				return cnt;
			/*do
			{
				modbus_read_bits(m_ctx, Cylinder90Status, 1, m_buf_8);
			} while (m_buf_8[0] == 0);*/

			// 			while ((0 != modbus_read_bits(m_ctx, Cylinder90Status, 1, m_buf_8)) && cnt++ < 30)
			// 			{
			// 			}
			// 			if (cnt >= 30) {
			// 				return -1;
			// 			}
			// 			else
			// 			{
			// 				return (cnt < 30);
			// 			}
		}
		else
		{
			ret = modbus_write_bit(m_ctx, CylinderEnable, ON);
			ret = modbus_write_bit(m_ctx, CylinderRotateSwitch, OFF);

			if (ret == -1) {
				return -1;
			}
			int cnt = 0;

			do
			{
				modbus_read_bits(m_ctx, Cylinder0Status, 1, m_buf_8);
			} while ((m_buf_8[0] == 0) && (cnt++<50));

			if (cnt >= 50)
				return cnt;
			// 			int cnt = 0;
			// 			while ((0 != modbus_read_bits(m_ctx, Cylinder90Status, 1, m_buf_8)) && cnt++ < 30)
			// 			{
			// 			}
			// 			if (cnt >=30) {
			// 				return -1;
			// 			}
			// 			else
			// 			{
			// 				return (cnt < 30);
			// 			}
		}

	}

	return ret;
}
int rot_plat_step(int id, int step, int vel, int acc)
{
	int ret = 0;
	if (!b_isInitial) {
		return -1;
	}
	if (id == Rot_Axis_1) {
		//ret = modbus_write_bit(m_ctx, MoveAbsMode, ON);
		// = modbus_write_bit(m_ctx, MoveStepMode, OFF);
		ret = modbus_write_bit(m_ctx, MoveAbsMode, OFF);
		ret = modbus_write_bit(m_ctx, MoveStepMode, ON);
		uint16_t ang[2];
		ang[0] = (uint16_t)(step);
		ang[1] = (uint16_t)(step >> 16);
		ret = modbus_write_registers(m_ctx, ObjAngles_1, 2, ang);
		uint16_t ve[2];
		ve[0] = (uint16_t)(vel);
		ve[1] = (uint16_t)(vel >> 16);
		ret = modbus_write_registers(m_ctx, ObjVel_1, 2, ve);
		if (ret == -1) {
			return -1;
		}
		ret = modbus_write_bit(m_ctx, MoveSwitch_1, ON);
		int cnt = 0;
		do
		{
			modbus_read_bits(m_ctx, Busy_1, 1, m_buf_8);
			Sleep(20);
		} while (m_buf_8[0] != 0 && cnt++<50);

		if (cnt >= 50)
			return cnt;

		/*while ((0 != modbus_read_bits(m_ctx, Busy_1, 1, m_buf_8)) && cnt++ < 50)
		{
		}*/
		ret = modbus_write_bit(m_ctx, MoveSwitch_1, OFF);
		cnt = 0;
		/*while ((0 != modbus_read_bits(m_ctx, Arrived_1, 1, m_buf_8)) && cnt++ < 100)
		{
			usleep(100);
		}*/
		do
		{
			modbus_read_bits(m_ctx, Arrived_1, 1, m_buf_8);
			usleep(100);
		} while (m_buf_8[0] == 0 && cnt++<100);

		if (cnt >= 50)
			return cnt;

		//ret = (cnt < 100);
	}
	else if (id == Rot_Axis_2) {
		ret = modbus_write_bit(m_ctx, MoveAbsMode, OFF);
		ret = modbus_write_bit(m_ctx, MoveStepMode, ON);
		uint16_t ang[2];
		ang[0] = (uint16_t)(step);
		ang[1] = (uint16_t)(step >> 16);
		ret = modbus_write_registers(m_ctx, ObjAngles_2, 2, ang);
		uint16_t ve[2];
		ve[0] = (uint16_t)(vel);
		ve[1] = (uint16_t)(vel >> 16);
		ret = modbus_write_registers(m_ctx, ObjVel_2, 2, ve);
		if (ret == -1) {
			return -1;
		}
		ret = modbus_write_bit(m_ctx, MoveSwitch_2, ON);
		int cnt = 0;
		do
		{
			modbus_read_bits(m_ctx, Busy_2, 1, m_buf_8);
			Sleep(50);
		} while (m_buf_8[0] != 0 && cnt++<50);

		if (cnt >= 50)
			return cnt;
		/*while ((0 != modbus_read_bits(m_ctx, Busy_2, 1, m_buf_8)) && cnt++ < 50)
		{
		}*/
		ret = modbus_write_bit(m_ctx, MoveSwitch_2, OFF);
		cnt = 0;
		do
		{
			modbus_read_bits(m_ctx, Arrived_2, 1, m_buf_8);
			usleep(100);
		} while (m_buf_8[0] == 0 && cnt++<100);

		if (cnt >= 50)
			return cnt;

		/*while ((0 != modbus_read_bits(m_ctx, Arrived_2, 1, m_buf_8)) && cnt++ < 100)
		{
			usleep(100);
		}*/

		//ret = (cnt < 100);
	}

	else if (id == Rot_Axis_3)
	{
		ret = modbus_read_bits(m_ctx, Cylinder0Status, 1, m_buf_8);
		if (m_buf_8[0] == 1)
		{
			ret = modbus_write_bit(m_ctx, CylinderEnable, ON);
			ret = modbus_write_bit(m_ctx, CylinderRotateSwitch, ON);//气缸控制转到90度位置

			int overtime = 60;
			int i = 0;
			do
			{
				ret = modbus_read_bits(m_ctx, Cylinder90Status, 1, m_buf_8);
				Sleep(50);
			} while ((m_buf_8[0] == 0) && (i++<overtime));

			if (i >= overtime)
			{
				i = 0;
				return i;
			}
		}
		else
		{
			ret = modbus_read_bits(m_ctx, Cylinder90Status, 1, m_buf_8);
			if (m_buf_8[0] == 1)
			{
				ret = modbus_write_bit(m_ctx, CylinderEnable, ON);
				ret = modbus_write_bit(m_ctx, CylinderRotateSwitch, OFF);//气缸控制转到0度位置

				int overtime = 20;
				int i = 0;
				do
				{
					ret = modbus_read_bits(m_ctx, Cylinder0Status, 1, m_buf_8);
					Sleep(50);
				} while ((m_buf_8[0] == 0) && (i++<overtime));

				if (i >= overtime)
				{
					i = 0;
					return i;
				}
			}
		}

	}
	return ret;
}
int rot_plat_VelMove(int id, bool dir, int vel, int acc)
{
	int ret;
	if (!b_isInitial) {
		return -1;
	}
	if (id == Rot_Axis_1) {
		ret = modbus_write_bit(m_ctx, MoveAbsMode, ON);
		ret = modbus_write_bit(m_ctx, MoveStepMode, OFF);
		uint16_t ang[2];
		if (dir) {
			ang[0] = (uint16_t)(MaxInt32);
			ang[1] = (uint16_t)(MaxInt32 >> 16);
		}
		else
		{
			ang[0] = (uint16_t)(MinInt32);
			ang[1] = (uint16_t)(MinInt32 >> 16);
		}

		ret = modbus_write_registers(m_ctx, ObjAngles_1, 2, ang);
		uint16_t ve[2];
		ve[0] = (uint16_t)(vel);
		ve[1] = (uint16_t)(vel >> 16);
		ret = modbus_write_registers(m_ctx, ObjVel_1, 2, ve);
		if (ret == -1) {
			return -1;
		}
		if (acc != 0) {
			modbus_write_register(m_ctx, AccTime_1, (uint16_t)acc);
			ret = modbus_write_bit(m_ctx, AccUpdate, ON);
			ret = modbus_write_bit(m_ctx, AccUpdate, OFF);
		}
		ret = modbus_write_bit(m_ctx, MoveSwitch_1, ON);
		int cnt = 0;
		/*while ((0 != modbus_read_bits(m_ctx, Busy_1, 1, m_buf_8)) && cnt++ < 50)
		{
		}*/

		do
		{
			modbus_read_bits(m_ctx, Busy_1, 1, m_buf_8);
			usleep(100);
		} while (m_buf_8[0] == 0 && cnt++<50);

		if (cnt >= 50)
			return cnt;

		ret = modbus_write_bit(m_ctx, MoveSwitch_1, OFF);
		cnt = 0;
		/*while ((0 != modbus_read_bits(m_ctx, Arrived_1, 1, m_buf_8)) && cnt++ < 100)
		{
			usleep(100);
		}*/
		do
		{
			modbus_read_bits(m_ctx, Arrived_1, 1, m_buf_8);
			usleep(100);

		} while (m_buf_8[0] == 0 && cnt++<100);

		if (cnt >= 100)
			return cnt;


		//ret = (cnt < 100);
	}
	else if (id == Rot_Axis_2) {
		ret = modbus_write_bit(m_ctx, MoveAbsMode, ON);
		ret = modbus_write_bit(m_ctx, MoveStepMode, OFF);
		uint16_t ang[2];
		if (dir) {
			ang[0] = (uint16_t)(MaxInt32);
			ang[1] = (uint16_t)(MaxInt32 >> 16);
		}
		else
		{
			ang[0] = (uint16_t)(MinInt32);
			ang[1] = (uint16_t)(MinInt32 >> 16);
		}

		ret = modbus_write_registers(m_ctx, ObjAngles_2, 2, ang);
		uint16_t ve[2];
		ve[0] = (uint16_t)(vel);
		ve[1] = (uint16_t)(vel >> 16);
		ret = modbus_write_registers(m_ctx, ObjVel_2, 2, ve);
		if (ret == -1) {
			return -1;
		}
		if (acc != 0) {
			modbus_write_register(m_ctx, AccTime_2, (uint16_t)acc);
			ret = modbus_write_bit(m_ctx, AccUpdate, ON);
			ret = modbus_write_bit(m_ctx, AccUpdate, OFF);
		}
		ret = modbus_write_bit(m_ctx, MoveSwitch_2, ON);
		ret = modbus_write_bit(m_ctx, ServoEnable_2, ON);
		int cnt = 0;
		/*while ((0 != modbus_read_bits(m_ctx, Busy_2, 1, m_buf_8)) && cnt++ < 50)
		{
		}*/
		do
		{
			modbus_read_bits(m_ctx, Busy_2, 1, m_buf_8);
			usleep(100);
		} while (m_buf_8[0] != 0 && cnt++<50);

		if (cnt >= 50)
			return cnt;
		
		ret = modbus_write_bit(m_ctx, MoveSwitch_2, OFF);
		ret = modbus_write_bit(m_ctx, ServoEnable_2, OFF);
		cnt = 0;
		/*while ((0 != modbus_read_bits(m_ctx, Arrived_2, 1, m_buf_8)) && cnt++ < 100)
		{
			usleep(100);
		}*/

		do
		{
			modbus_read_bits(m_ctx, Arrived_2, 1, m_buf_8);
			usleep(100);
		} while (m_buf_8[0] == 0 && cnt++<100);

		if (cnt >= 100)
			return cnt;

		//ret = (cnt < 100);
	}

	return ret;
}
int rot_plat_Stop(int id)
{
	int ret = 0;
	if (!b_isInitial) {
		return -1;
	}
	ret = modbus_write_bit(m_ctx, Emgency, ON);
	int cnt = 0;
	/*while ((0 != modbus_read_bits(m_ctx, EmgencyStatus, 1, m_buf_8)) && cnt++ < 50)
	{
	}*/
	do
	{
		modbus_read_bits(m_ctx, EmgencyStatus, 1, m_buf_8);
	} while (m_buf_8[0] == 0 && cnt++<50);
	ret = modbus_write_bit(m_ctx, Emgency, OFF);

	return ret;
}

int rot_plat_Alarm(int id)
{
	int ret = 0;

	if (id == Rot_Axis_1)
		ret = modbus_read_bits(m_ctx, Alarm_1, 1, m_buf_8);
	else if (id == Rot_Axis_2)
		ret = modbus_read_bits(m_ctx, Alarm_2, 1, m_buf_8);
	else if (id == Rot_Axis_3)
		ret = 1;

	return ret;
}

bool modbusInit()
{	
	const char *device = getValue("Serial");
	//sprintf(device, "COM%s", device);
	if (m_ctx == NULL) {
		m_ctx = modbus_new_rtu(device, Baudrate, Parity, Databit, Stopbit);
	}
	int ret = modbus_set_slave(m_ctx, SLAVE); // set slave adress
	if (ret == -1) {
		return false;
	}
	ret = modbus_connect(m_ctx);
	if (ret == -1) {
		return false;
	}
	b_isInitial = true;
	//rot_plat_home(Rot_Axis_1, 0);

	return b_isInitial;
}

bool rotInit()
{	
	paraInit();//系统参数初始化以及读取配置文件	
	if (modbusInit())
	{
		b_isInitial = true;		
	}
	return b_isInitial;
}

void closeModbus()
{
	if(m_ctx!=NULL)
	{
		modbus_close(m_ctx);
		modbus_free(m_ctx); 
	}
	
}

/*
* Copyright © <wu_xx2008@hotmail.com>
*
* antoy wu
* 2018-4-16 21:16:30
*/

#ifndef ROTCONTROL_H
#define ROTCONTROL_H

/* Add this for macros that defined unix flavor */
#if (defined(__unix__) || defined(unix)) && !defined(USG)
#include <sys/param.h>
#endif

#ifndef _MSC_VER
#include <stdint.h>
#else
#include "stdint.h"
#endif

#include "modbus-version.h"
#include <stdbool.h>
#include "RotationPlatformDefine.h"

#if defined(_MSC_VER)
# if defined(DLLBUILD)
/* define DLLBUILD when building the DLL */
#  define ROT_API __declspec(dllexport)
# else
#  define ROT_API __declspec(dllimport)
# endif
#else
# define MODBUS_API
#endif

char*       messageStr;
volatile bool b_stop;
bool		  b_isInitial;

modbus_t*	m_ctx;
int				m_rc;
int				m_nb_fail;
int				m_nb_loop;
int				m_addr;
int				m_nb;
uint8_t*		m_tab_rq_bits;
uint8_t*		m_tab_rp_bits;
uint16_t*		m_tab_rq_registers;
uint16_t*		m_tab_rw_rq_registers;
uint16_t*		m_tab_rp_registers;

uint16_t		m_tab_reg[32] = { 0 };
uint8_t		    m_rec_reg[32] = { 0 };
uint8_t			m_buf_8[32] = { 0 };
uint16_t		m_buf_16[32] = { 0 };

int32_t			m_cur_pos[3] = { 0 };
int32_t			m_cur_vel[3] = { 0 };
int32_t			m_cur_acc[3] = { 0 };
bool			b_busy;
bool			b_alarm;
bool			b_emgency;

PlatformSetup m_platform_setup;


ROT_API bool rotInit();
ROT_API int rot_plat_home(int id, int vel);
ROT_API int rot_plat_moveto(int id, int pos, int vel, int acc);
ROT_API int rot_plat_step(int id, int step, int vel, int acc);
ROT_API int rot_plat_VelMove(int id, bool dir, int vel, int acc);
ROT_API int rot_plat_Stop(int id);
ROT_API int rot_plat_Alarm(int id);
ROT_API void closeModbus();

#endif  /* ROTCONTROL_H */

C# 上位机界面 CRotPlatformControl.cs  IMUDebugTool.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Runtime.InteropServices;

namespace RotPlatformControl_CsDll
{
    public class CRotPlatformControl
    {
        [DllImport("modbus.dll", EntryPoint = "sum", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
        public static extern int sum(int a, int b);

        [DllImport("modbus.dll", EntryPoint = "getValue", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
        public static extern IntPtr getValue(IntPtr intPtrKey);

        [DllImport("modbus.dll", EntryPoint = "setValue", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
        public static extern IntPtr setValue(IntPtr intPtrKey, IntPtr intPtrValue);

        [DllImport("modbus.dll", EntryPoint = "rotInit", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
        public static extern bool rotInit();

        [DllImport("modbus.dll", EntryPoint = "rot_plat_home", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
        public static extern int rot_plat_home(int id, int vel);

        [DllImport("modbus.dll", EntryPoint = "rot_plat_moveto", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
        public static extern int rot_plat_moveto(int id, int pos, int vel, int acc);

        [DllImport("modbus.dll", EntryPoint = "rot_plat_step", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
        public static extern int rot_plat_step(int id, int step, int vel, int acc);

        [DllImport("modbus.dll", EntryPoint = "rot_plat_VelMove", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
        public static extern int rot_plat_VelMove(int id, bool dir, int vel, int acc);

        [DllImport("modbus.dll", EntryPoint = "rot_plat_Stop", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
        public static extern int rot_plat_Stop(int id);

        [DllImport("modbus.dll", EntryPoint = "rot_plat_Alarm", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
        public static extern int rot_plat_Alarm(int id);

        [DllImport("modbus.dll", EntryPoint = "closeModbus", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
        public static extern int closeModbus();
    }

    public class CModbusDefine
    {
        public const int SLAVE = 1;
        public const int CharOvertime = 3;
        public const int ReplayOvertime = 300;

        public const int Baudrate = 19200;
        public const int Databit = 8;
        public const int Stopbit = 1;
        public const char Parity = 'E';

        public const int Rot_Axis_1 = 0;
        public const int Rot_Axis_2 = 1;
        public const int Rot_Axis_3 = 2;
        public const int Rot_Axis_ALL = 3;

        public const ushort ResetVel_1 = 110;
        public const ushort ResetVel_2 = 114;
        public const ushort ResetHomeVel_1 = 112;
        public const ushort ResetHomeVel_2 = 116;

        public const ushort AccTime_1 = 118;
        public const ushort AccTime_2 = 120;
        public const ushort HomeAccTime_1 = 119;
        public const ushort HomeAccTime_2 = 121;

        public const ushort ObjCycles_1 = 130;
        public const ushort ObjCycles_2 = 150;
        public const ushort ObjAngles_1 = 132;
        public const ushort ObjAngles_2 = 152;
        public const ushort ObjVel_1 = 122;
        public const ushort ObjVel_2 = 124;

        public const ushort CylinderOvertime = 154;
        public const ushort ResetOvertime = 156;

        public const ushort CurCycles_1 = 220;
        public const ushort CurCycles_2 = 224;
        public const ushort CurAngles_1 = 222;
        public const ushort CurAngles_2 = 226;

        public const ushort SystemReboot = 100;//pulse
        public const ushort SystemClear = 101;//pulse
        public const ushort Emgency = 102;
        public const ushort EmgencyStatus = 103;
        public const ushort Door = 106;
        public const ushort CommStatus = 107;

        public const ushort ResetSwitch = 110;
        public const ushort ResetStatus = 111;

        public const ushort ResetVelupdate = 115;//pulse
        public const ushort AccUpdate = 116;//pulse


        //cylinder
        public const ushort CylinderEnable = 120;
        public const ushort CylinderRotateSwitch = 121;
        public const ushort Cylinder0Status = 122;
        public const ushort Cylinder90Status = 123;
        public const ushort CylinderBusy = 124;

        //axis status
        public const ushort Busy_1 = 130;
        public const ushort Busy_2 = 150;
        public const ushort Arrived_1 = 131;
        public const ushort Arrived_2 = 151;
        public const ushort Alarm_1 = 132;
        public const ushort Alarm_2 = 152;

        //axis control
        public const ushort MoveStepMode = 142;
        public const ushort MoveAbsMode = 143;
        public const ushort ServoEnable_1 = 140;
        public const ushort ServoEnable_2 = 160;
        public const ushort AlarmClear_1 = 144;//pulse
        public const ushort AlarmClear_2 = 164;
        public const ushort MoveSwitch_1 = 141;
        public const ushort MoveSwitch_2 = 161;
        public const  ushort RunStatus = 170;
        public const  ushort SystemAlarm = 171;

        default parameters config (pulse)
        //public const unsigned short Default1Read = 203;//pulse
        //public const unsigned short Default1Write = 204;//pulse

        //public const unsigned short Default2Read = 205;//pulse
        //public const unsigned short Default2Write = 206;//pulse

        public const int MaxInt32 = 2147483647;
        public const int MinInt32 = -2147483648;
    }

    public class CRotDefine
    {
       
        ...

        //[Precision]
        public const int Precision_Axis1=0;
        public const int Precision_Axis2=90;
        public const int Precision_Axis3=0;
        //[Accuracy]
        public const int Accuracy_step1_Axis1=90;
        public const int Accuracy_step2_Axis1=180;
        public const int Accuracy_step3_Axis1=270;
        public const int Accuracy_step4_Axis1=360;

        public const int Vel = 7000; //轴速度
        public const int Acc = 0;//轴加速度
    }
}

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Threading;
using System.Runtime.InteropServices;
using System.Security;
using System.Security.Principal;
using DeviceLibrary.PlatformBase;
using RotPlatformControl_CsDll;
using DeviceLibrary.ImuPlatformMirage2B;
using BaseLibrary.Extension;
using BaseLibrary.Object;

namespace Mirage2B_IMU_Test
{
    public partial class IMUDebugTool : Form
    {
        public bool isRotInit = false;
        public IRotPlatform _platform = new ImuRotPlatformMirage2B();
        //public CRotPlatformControl CRPC = new CRotPlatformControl();
        //public CModbusDefine CMD = new CModbusDefine();
        //public CRotDefine CRD=new CRotDefine();

        public IMUDebugTool()
        {
            InitializeComponent();
            InitData();
            InitializeRotPlatform();
        }
        private void InitData()
        {
            _platform.Load();
        }

        private void InitializeRotPlatform()
        {
            isRotInit = CRotPlatformControl.rotInit();
            lblMessage.Text = $"转台Mobus初始化状态为 {isRotInit}";

            radioButtonRotX.Checked = false;
            radioButtonRotY.Checked = false;
            radioButtonRotZ.Checked = false;
            radioButtonALL.Checked = true;

            comboBoxMoveToPos.Text = "InstallPos";
            comboBoxStepMoveStep.Text = "60";
            comboBoxVelMoveVelocity.Text = "60";

            InitDgv_AxisStatus();
            InitDgv_AxisPos();
        }
        private void IMUDebugTool_FormClosing(object sender, FormClosingEventArgs e)
        {
            CRotPlatformControl.closeModbus();
        }

        private void buttonHome_Click(object sender, EventArgs e)
        {
            log("转台开始复位!");
            Cursor.Current = Cursors.WaitCursor;
            int id = 0;
            if (radioButtonRotX.Checked)
            {
                id = CModbusDefine.Rot_Axis_1;
            }

            else if (radioButtonRotY.Checked)
            {
                id = CModbusDefine.Rot_Axis_2;
            }

            else if (radioButtonRotZ.Checked)
            {
                id = CModbusDefine.Rot_Axis_3;
            }

            else if (radioButtonALL.Checked)
            {
                id = CModbusDefine.Rot_Axis_ALL;
                if ((getHomeResult(CModbusDefine.Rot_Axis_1) == 1) && (getHomeResult(CModbusDefine.Rot_Axis_2) == 1) && (getHomeResult(CModbusDefine.Rot_Axis_3) == 1))
                    log($"三轴转台复位成功！");
                else
                    log($"三轴转台复位失败！");
            }

            if (id < 3)
            {
                getHomeResult(id);
            }

            Cursor.Current = Cursors.Default;
        }

        private int getHomeResult(int id)
        {
            int res = CRotPlatformControl.rot_plat_home(id, 0);
            if (res == 1)
                log($"轴{id}复位成功");
            else
                log($"轴{id}复位失败!code:{res}");


            return res;
        }


        private void buttonStop_Click(object sender, EventArgs e)
        {
            log("转台开始停止!");
            int res = CRotPlatformControl.rot_plat_Stop(CModbusDefine.Rot_Axis_1);
            if (res == 1)
                lblMessage.Text = $"转台停止成功";
        }


        private void setIniTest()
        {
            string strKey = "Hello";
            string strValue = "Kitty";
            string res = setvalue(strKey, strValue);
            lblMessage.Text = res.ToString();
        }


        private string Getvalue(string strKey)
        {
            IntPtr key = Marshal.StringToHGlobalAnsi(strKey);
            IntPtr temp = CRotPlatformControl.getValue(key);
            string res = Marshal.PtrToStringAnsi(temp).ToString();
            temp = IntPtr.Zero;
            return res;
        }


        private string setvalue(string strKey, string strValue)
        {
            IntPtr key = Marshal.StringToHGlobalAnsi(strKey);
            IntPtr value = Marshal.StringToHGlobalAnsi(strValue);
            IntPtr temp = CRotPlatformControl.setValue(key, value);
            string res = Marshal.PtrToStringAnsi(temp).ToString();
            temp = IntPtr.Zero;
            return res;
        }

        private void log(string strMsg)
        {
            ShowMsg(strMsg, Color.Blue);
        }
        private void error(string strErrMsg)
        {
            ShowMsg(strErrMsg, Color.Red);
        }

        private delegate void ShowMsgHandle(string msgString, Color color);
        private void ShowMsg(string msgString, Color color)
        {
            if (!lblMessage.InvokeRequired)
            {
                lblMessage.Text = msgString;
                lblMessage.ForeColor = color;
                lblMessage.Refresh();
            }
            else
            {
                Invoke(new ShowMsgHandle(ShowMsg), msgString, color);
            }
        }


        #region controls init
        private void InitDgv_AxisStatus()
        {
            if (_platform == null)
            {
                return;
            }
            dgvAxisStatus.Columns.Clear();
            dgvAxisStatus.Columns.Add("Properties", "Properties");
            dgvAxisStatus.Columns[0].SortMode = DataGridViewColumnSortMode.NotSortable;

            foreach (var axis in _platform.Axis.Values)
            {
                var index = dgvAxisStatus.Columns.Add(axis.Name, axis.Name);
                dgvAxisStatus.Columns[index].SortMode = DataGridViewColumnSortMode.NotSortable;
            }

            foreach (var prop in RotPlcAxis.GetProps())
            {
                var row = dgvAxisStatus.Rows.Add();
                dgvAxisStatus.Rows[row].Cells[0].Value = prop;
            }
            UpdateDgv_Axis();
        }

        private void UpdateDgv_Axis()
        {
            if (_platform == null)
            {
                return;
            }
            var axisIndex = 1;
            foreach (var axis in _platform.Axis.Values)
            {
                var row = 0;
                foreach (var status in axis.GetStatus())
                {
                    dgvAxisStatus.Rows[row++].Cells[axisIndex].Value = status;
                }
                axisIndex++;
            }
        }

        private void InitDgv_AxisPos()
        {
            if (_platform == null)
            {
                return;
            }
            foreach (var axis in _platform.Axis.Values)
            {
                comboBoxMoveToPos.Items.Clear();
                comboBoxPosName.Items.Clear();
                foreach (var posname in axis.Positions.Keys)
                {
                    comboBoxMoveToPos.Items.Add(posname);
                    comboBoxPosName.Items.Add(posname);
                }
                break;
            }

            dgvAxisPos.Columns.Clear();
            dgvAxisPos.Columns.Add("Properties", "Properties");
            dgvAxisPos.Columns[0].SortMode = DataGridViewColumnSortMode.NotSortable;
            foreach (var axis in _platform.Axis.Values)
            {
                var index = dgvAxisPos.Columns.Add(axis.Name, axis.Name);
                dgvAxisPos.Columns[index].SortMode = DataGridViewColumnSortMode.NotSortable;
            }

            dgvAxisPos.Rows.Clear();
            dgvAxisPos.Rows.Add(100);

            var axisIndex = 1;
            foreach (var axis in _platform.Axis.Values)
            {
                var row = 0;
                foreach (var pos in axis.Positions)
                {
                    dgvAxisPos.Rows[row].Cells[0].Value = $"[{row}] {pos.Key}";
                    dgvAxisPos.Rows[row++].Cells[axisIndex].Value = pos.Value;
                }
                axisIndex++;
            }
        }
        #endregion

        private void buttonMoveTo_Click(object sender, EventArgs e)
        {
            log("转台开始移动到指定位置!");
            Cursor.Current = Cursors.WaitCursor;
            int id = 0;
            if (radioButtonRotX.Checked)
            {
                id = CModbusDefine.Rot_Axis_1;
            }


            else if (radioButtonRotY.Checked)
            {
                id = CModbusDefine.Rot_Axis_2;
            }


            else if (radioButtonRotZ.Checked)
            {
                id = CModbusDefine.Rot_Axis_3;
            }

            else if (radioButtonALL.Checked)
            {
                id = CModbusDefine.Rot_Axis_ALL;
                error($"请选择单轴！MoveTo功能只能选择单轴，不能选择全部三轴！");
            }

            if (id < 3)
            {
                getMoveToResult(id);
            }

            Cursor.Current = Cursors.Default;
        }

        private int getMoveToResult(int id)
        {
            //int res = CRotPlatformControl.rot_plat_Alarm(id);
            //if (res != 1)
            //{
            //    log($"轴{id}报警");
            //    return res;
            //}
            int pos = Convert.ToInt32(comboBoxMoveToPos.Text);
            int res = CRotPlatformControl.rot_plat_moveto(id, pos * 100, 7000, 0);
            if (res == 1)
                log($"轴{id}移动至指定位置{pos}成功!");
            else
                log($"轴{id}移动至指定位置{pos}失败!code:{res}");
            return res;
        }

        private void buttonStep_Click(object sender, EventArgs e)
        {
            Cursor.Current = Cursors.WaitCursor;
            int id = 0;
            if (radioButtonRotX.Checked)
            {
                id = CModbusDefine.Rot_Axis_1;
            }


            else if (radioButtonRotY.Checked)
            {
                id = CModbusDefine.Rot_Axis_2;
            }

            else if (radioButtonRotZ.Checked)
            {
                id = CModbusDefine.Rot_Axis_3;
                //error($"请选择X或Y轴！Step功能不支持Z轴！");
            }

            else if (radioButtonALL.Checked)
            {
                id = CModbusDefine.Rot_Axis_ALL;
                error($"请选择单轴！MoveTo功能只能选择单轴，不能选择全部三轴！");
            }


            if (id < 3)
            {
                getStepResult(id);
            }


            Cursor.Current = Cursors.Default;

        }


        private int getStepResult(int id)
        {
            int step = Convert.ToInt32(comboBoxStepMoveStep.Text);
            int res = CRotPlatformControl.rot_plat_step(id, step, 7000, 0);
            if (res == 1)
               log($"轴{id}单步{step}移动成功!");
            else
               error($"轴{id}单步{step}移动失败!code:{res}");
            return res;
       }


        private void buttonVel_Click(object sender, EventArgs e)
        {
            Cursor.Current = Cursors.WaitCursor;
            int id = 0;
            if (radioButtonRotX.Checked)
            {
                id = CModbusDefine.Rot_Axis_1;
            }

            else if (radioButtonRotY.Checked)
            {
                id = CModbusDefine.Rot_Axis_2;
            }

            else if (radioButtonRotZ.Checked)
            {
                id = CModbusDefine.Rot_Axis_3;
                error($"请选择X/0或Y/1轴！Step功能不支持Z/2轴!");
            }

            else if (radioButtonALL.Checked)
            {
                id = CModbusDefine.Rot_Axis_ALL;
                error($"请选择单轴！MoveTo功能只能选择单轴，不能选择全部三轴！");
            }

            if (id < 2)
            {
                getVelMoveResult(id);
            }
            Cursor.Current = Cursors.Default;
        }

        private int getVelMoveResult(int id)
        {
            int vel = Convert.ToInt32(comboBoxVelMoveVelocity.Text);
            bool dir=(vel>0) ? true : false;
            int res = CRotPlatformControl.rot_plat_VelMove(id, dir, vel, 0);
            if (res == 1)
                log($"轴{id}按照速度{vel}运动设置成功!");
            else
                error($"轴{id}按照速度{vel}运动设置失败!code:{res}");


            return res;
        }


        private void buttonTeach_Click(object sender, EventArgs e)
        {

        }


        private void buttonDelete_Click(object sender, EventArgs e)
        {

        }
    }
}



Antony_WU_SZ
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C#实现的封装CURD到SqlHelper类用法简单分析
08-28
本文将详细解析如何在C#中封装一个SqlHelper类，并结合App.config文件配置数据库连接，以及讲解其主要功能和使用方法。 首先，数据库连接字符串是访问数据库的关键信息，通常存储在项目的配置文件App.config中。在...
C#操作SQLite方法实例详解
09-03
本文将详细介绍如何使用C#操作SQLite数据库，包括建立连接、执行查询、插入数据、更新数据以及一些基本的封装。 首先，为了在C#中使用SQLite，需要引入`System.Data.SQLite`命名空间。这个库提供了对SQLite数据库的...
libmodus源码解读
weixin_29898767的博客
05-13 1875
modbus 软件开发指南 https://download.csdn.net/download/qq_25648927/10714399?utm_medium=distribute.pc_relevant_download.none-task-download-2~default~OPENSEARCH~Rate-5.dl_default&depth_1-utm_source=distribute.pc_relevant_download.none-task-download-2~default~
【Qt Modbus通信】libmodbus实现modbus的主机功能/从机功能 源码分享
热门推荐
qq_37373742的博客
02-07 1万+
【Qt Modbus通信】基于libmodbus库实现的运行在子线程中的modbus主从机 (RTU模式) 项目源码分享 modbus调试工具分享 QModbus 项目源码
C#Modbus通信
最新发布
lingxiao16888的博客
07-05 621
虚拟串口工具（vspd.exe），Modubus模拟主站(Modbus Poll)，Modbus模拟从站(Modbus Slave)，OPC服务软件(KEPServerEx V4.0)。F=01表示从站地址为01，功能码为01（即读取线圈，具体参考前面报文格式阐述）第2步，使用ModbusSlave软件建立虚拟Modbus从站。目的：通过标准Modbus协议完成对线圈，寄存器的读写。第1步，使用虚拟串口软件创建虚拟串口。3，基础ModbusRTU的通信。3.5，详细文档连接。2，初识Modbus。
libmodbus
天道酬勤
03-16 2618
libmodbus1 简介2 库使用2.1 直接加入工程中3 函数接口流程参考 1 简介 A Modbus library for Linux, Mac OS X, FreeBSD, QNX and Win32. libmodbus is a free software library to send/receive data according to the Modbus protocol. This library is written in C and supports RTU (serial) a
libmodbus库的使用:编译和部分代码示例
qq_34248512的博客
03-02 1762
1. libmodbus库的获取 在https://github.com/stephane/libmodbus/releases/tag/v3.1.6下载 2. Windows版本的编译 进入到libmodbus\src\win32文件夹下, 双击configure.js文件进行编译,成功后会弹出编译完成窗口,点击关闭 然后在双击modbus-9.sln通过VS打开项目,打开项目完成后编译即可 编译完成后libmodbus\src\win32文件夹下就会出现modbus.dll和modbus.l
libmodbus 开源库（第一部分）
QCZL_CC的博客
04-30 3920
下载地址 libmodbus 开源库地址：https://github.com/stephane/libmodbus 编译方式 安装必要的软件 sudo apt-get installpkg-configautoconf automake 编译 libmodbus ./autogen.sh &&./configure --prefix=/usr && && make && sudo make install 测试代码...
DBO_C#数据库调用封装类_
09-29
"DBO_C#数据库调用封装类_"是一个旨在简化数据库访问的工具，通过封装常见的数据库操作，提供更高效、简洁的API给开发者使用。这个类库可能包含了一系列静态方法或实例方法，以处理SQL查询、存储过程调用等各种任务...
用C#实现的SqlServer封装类
12-29
"用C#实现的SqlServer封装类"正是为了实现这一目标。这个项目旨在为开发者提供一个便捷的工具，以便在处理SQL Server数据库操作时减少重复性工作，使他们能够更专注于业务逻辑和SQL语句的设计。 C#是一种广泛使用的...
C#的SQL操作类实例
09-04
C#中的SQL操作类是用于与数据库交互的重要工具，它封装了连接数据库、执行SQL语句和处理数据的基本操作。在C#编程中，我们通常使用System.Data.SqlClient命名空间中的类来实现这些功能。以下是对标题和描述中所述...
modbus dll
12-09
modbus 的动态库 dll 文件 ，可下载添加到工程中使用
把modbus开源库libmodbus-3.1.4提取成源码文件
08-05
由于要使用libmodbus-3.1.4使用，必须先编译生成动态库才能使用，尤其是在交叉编译的时候容易出现错误，所以索性把libmodbus-3.1.4的源码提取出来，提取成两个文件DrvModbus.h和DrvModbus.cpp，使用时只需要把这两个文件导入到工程就可以使用libmodbus-3.1.4，方便易用。减少了编译的麻烦。
C#源码 ModBusTCP封装实现
09-17
C#源代码 ModBusTCP用类封装实现，直接调用即可，项目中通信部分源码，亲测可用。按照标准ModBus协议实现，也可用于普通TCP通信
C#modbus 开源类库
03-25
C# modbus 开源类库，NModbus4-3.0.0,支持visual studio 2015
modbus上位机C#类库
09-08
国外牛人编写的C#modbus协议解析，适合于下位机PLC等。方便您的快速开发
c++ modbusTCP
weixin_39926429的博客
06-09 4130
/Modbus TCP是一种基于TCP/IP协议的Modbus协议，它允许Modbus协议通过以太网进行通信。//在C++中，可以使用第三方库来实现Modbus TCP通信，例如libmodbus和QModbus。// 断开Modbus连接并释放上下文。// 创建Modbus TCP上下文。// 创建Modbus TCP客户端。// 连接到Modbus从设备。// 连接到Modbus从设备。// 读取Modbus寄存器。// 读取Modbus寄存器。// 打印读取到的寄存器值。
Modbus API函数知识点小结
百叶书的博客
09-16 7528
Modbus知识点小结Modbus知识点小结malloc函数memset函数uint8_t和uint16_t注释格式modbus_write_bit() 函数 用法modbus_read_bits() 函数用法modbus_set_bits_from_bytes() 函数用法modbus_get_byte_from_bits() 函数用法modbus_write_register() 函数用法modbus_read_registers() 函数用法modbus_write_registers() 函数用法参
Modbus介绍与函数使用及项目示例
yuxingyang_的博客
02-15 5630
简介Modbus与函数使用,通过程序项目演示帮助更清晰理解
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值