异步串口通信框架

最新推荐文章于 2024-09-20 09:06:07 发布
最新推荐文章于 2024-09-20 09:06:07 发布
阅读量3.2k 收藏 10
点赞数 2
分类专栏： C++/C 文章标签： 串口通信 异步串口通信框架 Ｃ 跨平台 源代码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wjb123sw99/article/details/98664069
版权

前言：

　　前段时间，服务器增加串口通信需求，早期串口框架仅仅只能支持单串口通信，还不支持热插拔。

　　由于在网上找了下没有自己想要的框架，因此，自己搭建了一个异步串口通信框架, 目前该框架已投入使用，没有发现内存泄露或者其他问题。该框架运用了【libserialport】【libuv】开源库，二者都支持跨平台，因此在可以放心在其他平台下使用该框架。

　　如果你确定要使用我的框架，请阅读最后的框架分点讲解部分，里面涉及到部分细节设置的地方。

功能：异步串口服务器框架（支持热插拔、多COM口通信框架）

源代码：链接：https://pan.baidu.com/s/1XmwsXP8UbG1l-AFESogFiQ   提取码：qdz7 

平台：Linux_X86（该平台已验证）（支持跨平台）

语言：C

工程：

　　下载源代码后，直接在QCom目录下运行【make】命令即可生成测试程序【com】。框架代码在【QCom/src/ComFarme】目录下

框架主体：

我先把整体代码放出来，在分点讲解。

框架头文件：【comfarme.h】

#ifndef COMFARME_H
#define COMFARME_H

#ifdef __cplusplus
extern "C" {
#endif

int ComFarme_NewHandle(void **handle);

void ComFarme_FreeHandle(void *handle);

int ComFarme_WaitHandle(void *handle);

#ifdef  __cplusplus
	}
#endif  /* #ifdef  __cplusplus */

#endif

框架测试DEMO： 【main.c】

#include <stdio.h>
#include <unistd.h>
#include "libserialport.h"
#include "uv.h"
#include "../ComFarme/comfarme.h"

volatile sig_atomic_t _running = 1;

static void catch_signal(int nsig)
{
	_running = 0;
}

int main()
{
	void *handle = NULL;
	int ret = 0;

	signal(SIGINT, catch_signal);
	signal(SIGTERM, catch_signal);

	ret = ComFarme_NewHandle(&handle);
	if (ret)
	{
		printf("ComFarme_NewHandle error\n");
		return -1;
	}
	else
	{
		printf("ComFarme_NewHandle success\n");
	}

	while (_running)
	{
		sleep(2);
	}

	printf("begin free\n");
	ComFarme_FreeHandle(handle);
	return 0;
}

框架代码：【comfarme.c】

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include "libserialport.h"
#include "uv.h"
#include "comfarme.h"

#define COMFARME_RUN 1
#define COMFARME_STOP 2
#define COMFARME_LOOPTIME 3
#define COMFARME_WAIETIME 2000
#define CONFARME_MAXCOM 1024
#define CONFARME_BUFLEN 1024
#define CONFARME_ADAPTER "/dev/ttyUSB"

typedef struct
{
	void *hand;
	void *next;
	void *handle;

	struct sp_port *list_ptr;
	uv_thread_t thread_communicate;

	unsigned char buf[CONFARME_BUFLEN];

}COMFARME_LIST;

typedef struct
{
	uv_thread_t thread_findcom;

	struct sp_port_config *config_ptr;

	COMFARME_LIST *list;
	pthread_mutex_t list_lock;

	int comfarme_switch;
}COMFARME_HANDLE;

static int ComFarme_ListDelete(COMFARME_HANDLE *handle, struct sp_port *list_ptr);

/* 打印二进制数据 */
static void ComFarme_PrintfData(unsigned char *data, int len)
{
	int i = 0;
	for (i = 0; i < len; i++)
	{
		printf("%02x ", data[i]);
	}
	printf("\n");
}

/* 数据通信模块 */
static void ComFarme_Communicate(void* arg)
{
	COMFARME_LIST *data = (COMFARME_LIST *)arg;
	COMFARME_HANDLE *handle = (COMFARME_HANDLE *)data->handle;
	struct sp_event_set *result_ptr = NULL;
	enum sp_return  sp_ret = SP_OK;

	/* 打开串口 */
	sp_ret = sp_open(data->list_ptr, SP_MODE_READ_WRITE);
	if (sp_ret != SP_OK)
	{
		printf("sp_open error @ret %d @errmsg %s\n", sp_ret, sp_last_error_message());
		goto ERR_OPEN;
	}
	else
	{
		printf("sp_open success\n");
	}
	/* 配置串口 */
	sp_ret = sp_set_config(data->list_ptr, handle->config_ptr);
	if (sp_ret != SP_OK)
	{
		printf("sp_set_config error @ret %d @errmsg %s\n", sp_ret, sp_last_error_message());
		goto ERR_CONFIG;
	}
	else
	{
		printf("sp_set_config success\n");
	}
	
	/* 添加触发器 */
	sp_ret = sp_new_event_set(&result_ptr);
	if (sp_ret != SP_OK)
	{
		printf("sp_new_event_set error @ret %d @errmsg %s\n", sp_ret, sp_last_error_message());
		goto ERR_CONFIG;
	}
	else
	{
		printf("sp_new_event_set success\n");
	}
	sp_ret = sp_add_port_events(result_ptr, data->list_ptr, SP_EVENT_ERROR);
	if (sp_ret != SP_OK)
	{
		printf("sp_add_port_events error1 @ret %d @errmsg %s\n", sp_ret, sp_last_error_message());
		goto ERR_EVENT;
	}
	sp_ret = sp_add_port_events(result_ptr, data->list_ptr, SP_EVENT_RX_READY);
	if (sp_ret != SP_OK)
	{
		printf("sp_add_port_events error2 @ret %d @errmsg %s\n", sp_ret, sp_last_error_message());
		goto ERR_EVENT;
	}
	/* 等待数据传输 */
	while (handle->comfarme_switch == COMFARME_RUN)
	{
		sp_ret = sp_wait(result_ptr, 0);
		if (sp_ret != SP_OK)
		{
			printf("sp_wait error @ret %d @errmsg %s\n", sp_ret, sp_last_error_message());
		}
		memset(data->buf, 0, CONFARME_BUFLEN);
		sp_ret = sp_nonblocking_read(data->list_ptr, data->buf, CONFARME_BUFLEN);
		if (sp_ret <= 0)
		{
			printf("sp_nonblocking_read error @ret %d @errmsg %s\n", sp_ret, sp_last_error_message());
			goto ERR_EVENT;
		}
		else
		{
			printf("sp_nonblocking_read success @ret %d\n", sp_ret);
			ComFarme_PrintfData(data->buf, (int)sp_ret);
			sp_ret = sp_blocking_write(data->list_ptr, data->buf, (size_t )sp_ret, COMFARME_WAIETIME);
			if (sp_ret <= 0)
			{
				printf("sp_nonblocking_write error @ret %d @errmsg %s\n", sp_ret, sp_last_error_message());
			}
			else
			{
				printf("send:\n");
				ComFarme_PrintfData(data->buf, sp_ret);
			}
		}
	}

ERR_EVENT:
	sp_free_event_set(result_ptr);
ERR_CONFIG:
	sp_close(data->list_ptr);
ERR_OPEN:
	ComFarme_ListDelete(handle, data->list_ptr);
}

/* 注册串口事件 */
static int ComFarm_EventAdd(COMFARME_LIST *data)
{
	return uv_thread_create(&(data->thread_communicate), ComFarme_Communicate, data);
}

/* 删除串口 */
static int ComFarme_ListDelete(COMFARME_HANDLE *handle, struct sp_port *list_ptr)
{
	COMFARME_LIST *list = handle->list;
	COMFARME_LIST *hand = NULL, *next = NULL;
	pthread_mutex_lock(&handle->list_lock);

	while ( list != NULL )
	{
		if (strcmp(sp_get_port_name(list->list_ptr), sp_get_port_name(list_ptr)) == 0 )
		{
			hand = (COMFARME_LIST *)list->hand;
			next = (COMFARME_LIST *)list->next;
			if (hand != NULL)
			{
				hand->next = next;
			}
			if (next != NULL)
			{
				next->hand = hand;
			}
			if (hand == NULL && next == NULL)
			{
				handle->list = NULL;
			}
			else if(hand == NULL)
			{
				handle->list = (COMFARME_LIST *)(handle->list)->next;
			}
			sp_free_port(list->list_ptr);
			free(list);
			pthread_mutex_unlock(&handle->list_lock);
			return 0;
		}
		list = (COMFARME_LIST *)list->next;
	}
	pthread_mutex_unlock(&handle->list_lock);
	return 0;
}

/* 增加串口 */
static int ComFarme_ListAdd(COMFARME_HANDLE *handle, struct sp_port *list_ptr)
{
	struct sp_port *ptr = NULL;
	enum sp_return  sp_ret = SP_OK;
	COMFARME_LIST *node = NULL;
	int ret = 0;

	pthread_mutex_lock(&handle->list_lock);

	sp_ret = sp_copy_port(list_ptr, &ptr);
	if (sp_ret != SP_OK)
	{
		pthread_mutex_unlock(&handle->list_lock);
		return -1;
	}

	node = (COMFARME_LIST *)malloc(sizeof(COMFARME_LIST));
	memset(node, 0, sizeof(COMFARME_LIST));

	node->list_ptr = ptr;
	node->handle = handle;
	if (handle->list == NULL)
	{
		node->hand = NULL;
		node->next = NULL;
		handle->list = node;
	}
	else
	{
		node->hand = NULL;
		node->next = handle->list;
		handle->list = node;
	}

	ret = ComFarm_EventAdd(node);
	if (ret)
	{
		pthread_mutex_unlock(&handle->list_lock);
		return -1;
	}

	pthread_mutex_unlock(&handle->list_lock);
	return 0;
}

static int ComFarme_ListCompare(COMFARME_HANDLE *handle, struct sp_port *list_ptr)
{
	COMFARME_LIST *list = handle->list;

	//printf("@ComFarme_ListCompare %s\n", sp_get_port_name(list_ptr));

	/* 过滤COM口 */
	if (memcmp(sp_get_port_name(list_ptr), CONFARME_ADAPTER, strlen(CONFARME_ADAPTER)) != 0)
	{
		//printf("@ComFarme_ListCompare -1 @len %d\n", strlen(CONFARME_ADAPTER));
		return -1;
	}

	pthread_mutex_lock(&handle->list_lock);
	while (list != NULL)
	{
		if ( strcmp(sp_get_port_name(list->list_ptr), sp_get_port_name(list_ptr) ) == 0 )
		{
			pthread_mutex_unlock(&handle->list_lock);
			//printf("@ComFarme_ListCompare -2");
			return -2;
		}
		list = (COMFARME_LIST *)list->next;
	}

	pthread_mutex_unlock(&handle->list_lock);
	printf("@new com %s\n", sp_get_port_name(list_ptr));
	return 0;
}

static int ComFarme_GetCom(COMFARME_HANDLE *handle)
{
	struct sp_port **list_ptr = NULL;
	enum sp_return  sp_ret = SP_OK;
	int i = 0, ret = 0;

	/* COM口配置 */
	if (!handle->config_ptr)
	{
		sp_ret = sp_new_config(&(handle->config_ptr));
		if (sp_ret != SP_OK)
		{
			printf("sp_new_config error\n");
			return -1;
		}
		sp_set_config_baudrate(handle->config_ptr, 115200);
		sp_set_config_bits(handle->config_ptr, 8);
		sp_set_config_parity(handle->config_ptr, SP_PARITY_NONE);
		sp_set_config_stopbits(handle->config_ptr, 1);
	}

	/* 获取列表 */
	sp_ret = sp_list_ports(&list_ptr);
	if (sp_ret != SP_OK)
	{
		printf("sp_list_ports error @ret %d\n", sp_ret);
		return -1;
	}

	for (i = 0; i < CONFARME_MAXCOM; i++)
	{
		if (list_ptr[i] == NULL)
		{
			break;
		}
		if (ComFarme_ListCompare(handle, list_ptr[i]) == 0 )
		{
			/* 增加串口 */
			ret = ComFarme_ListAdd(handle, list_ptr[i]);
			if (ret)
			{
				printf("ComFarme_ListAdd error @ret %d\n", ret);
				sp_free_port_list(list_ptr);
				return -1;
			}
			else
			{
				printf("ComFarme_ListAdd success @ret %d\n", ret);
			}
		}
	}

	/* 释放列表 */
	sp_free_port_list(list_ptr);
	return 0;
}

static void ComFarme_WaitList(COMFARME_LIST *data)
{
	if (data == NULL)
	{
		return;
	}
	ComFarme_WaitList((COMFARME_LIST *)data->next);
	uv_thread_join(&(data->thread_communicate));
}

static void ComFarme_CheckCom(void* arg)
{
	COMFARME_HANDLE *handle = (COMFARME_HANDLE *)arg;
	while (handle->comfarme_switch == COMFARME_RUN)
	{
		ComFarme_GetCom(handle);
		sleep(COMFARME_LOOPTIME);
	}

	/* 等待结束 */
	ComFarme_WaitList(handle->list);
}

int ComFarme_NewHandle(void **handle)
{
	int ret = 0;
	if (*handle != NULL)
	{
		return -1;
	}

	COMFARME_HANDLE *data = (COMFARME_HANDLE *)malloc(sizeof(COMFARME_HANDLE));
	memset(data, 0, sizeof(COMFARME_HANDLE));
	data->comfarme_switch = COMFARME_RUN;
	pthread_mutex_init(&data->list_lock, NULL);

	ret = uv_thread_create(&(data->thread_findcom), ComFarme_CheckCom, data);
	if (ret)
	{
		free(data);
		return -1;
	}

	*handle = data;
	return 0;
}

void ComFarme_FreeHandle(void *handle)
{
	COMFARME_HANDLE *data = (COMFARME_HANDLE *)handle;

	data->comfarme_switch = COMFARME_STOP;
	ComFarme_WaitHandle(handle);
	pthread_mutex_destroy(&data->list_lock);
	free(data);
}

int ComFarme_WaitHandle(void *handle)
{
	COMFARME_HANDLE *data = (COMFARME_HANDLE *)handle;
	return uv_thread_join(&(data->thread_findcom));
}

框架分点讲解：

框架入口：

【ComFarme_NewHandle】函数为框架入口，主要功能是启动监听服务器串口的线程【uv_thread_create(&(data->thread_findcom), ComFarme_CheckCom, data);】。

监听服务器串口：

【ComFarme_CheckCom】函数的功能定时监听服务器串口，每隔【COMFARME_LOOPTIME】秒监听一次；

【ComFarme_GetCom】函数的功能为检查是否有新增串口，【handle->config_ptr】为串口配置，可以在该函数中设置串口波特率、奇偶校验等参数，通过【sp_list_ports】函数获取当前服务器串口情况，并通过【ComFarme_ListCompare】函数判断当前串口是否已添加进链表，你可以在【ComFarme_ListCompare】函数过滤串口，比如本工程中在【ComFarme_ListCompare】函数中添加了下列代码，表示只对【ttyUSB*】提供串口读写服务，这块根据个人需求进行修改，如果你需要对所有串口提供服务，则可以删除该段：

	/* 过滤COM口 */
	if (memcmp(sp_get_port_name(list_ptr), CONFARME_ADAPTER, strlen(CONFARME_ADAPTER)) != 0)
	{
		//printf("@ComFarme_ListCompare -1 @len %d\n", strlen(CONFARME_ADAPTER));
		return -1;
	}

 

如果是新串口，则通过【ComFarme_ListAdd】函数添加进链表；

添加链表

【ComFarme_ListAdd】函数功能是将新串口添加进链表，并通过【ComFarm_EventAdd】函数,开启新的线程，该线程为新串口提供读写服务。

读写服务

【ComFarm_EventAdd】函数功能是为一个串口开启读写服务线程，【ComFarme_Communicate】函数主要功能是为串口提供读写服务；

【ComFarme_Communicate】函数，先通过【sp_open】函数将【ComFarme_ListAdd】函数传入的新串口打开，而后通过【sp_set_config】函数将串口波特率等参数进行设置，通过【sp_new_event_set】创建触发器，并通过【sp_add_port_events】函数将该串口的读写及插拔设置为触发事件，而后通过【sp_wait】函数进行阻塞，等待事件的发生。

当该串口数据传入服务器后，通过【sp_nonblocking_read】函数进行数据读取，通过【sp_blocking_write】函数进行数据回复。

当该串口被拔走后，则调用【ComFarme_ListDelete】函数，将该串口从链表中删除。

框架出口：

调用【ComFarme_FreeHandle】函数，可以结束该框架。

首先通过【data->comfarme_switch = COMFARME_STOP】语句将框架标志位设置为停止，然后等待【ComFarme_CheckCom】线程函数正常退出。

在【ComFarme_CheckCom】线程函数中【ComFarme_WaitList】函数的功能是等待链表中的串口服务线程【ComFarme_Communicate】正常退出。由于【ComFarme_Communicate】函数中【sp_wait】阻塞，因此只有串口发生通信或者串口被拔出后，【ComFarme_Communicate】函数才能正常退出。我在使用中，是先拔出串口再结束程序，如果该框架在你程序中只开启关闭一次，则可以在【ComFarme_CheckCom】线程函数删除下面这条语句：

	/* 等待结束 */
	ComFarme_WaitList(handle->list);

 

 

 

 

时暑
关注
专栏目录
推荐一个好用的串口通讯框架OkSerialPort
qq_30119131的博客
01-19 2152
推荐一个好用的串口通讯框架OkSerialPort接下来看一下OkSerialPort这个框架怎么使用 公司转型智能硬件几个月了多个项目都需要用到串口通讯，后续还会有很多新项目也是一样，最近在github上发现一个大牛新写的通讯框架OkSerialPort，使用起来简单，大大减少开发代码量提高开发效率，而且移植新项目变的很简单了，之前我们用的只是简单的结合Rxjava做成响应式，但是数据组装和解析...
libserialport 开源项目安装与使用手册
gitblog_00121的博客
09-10 488
libserialport 开源项目安装与使用手册 libserialportRead-only mirror of the official repo at git://sigrok.org/libserialport. Pull requests welcome. Please file bugreports at sigrok.org/bugzilla.项目地址:https://gitco...
libserailport交叉编译适配说明
最新发布
dujunqiu的博客
09-20 449
github路径自己的gitee路径libserialport 是一个跨平台的串口通信库，由 sigrok 项目开发。它简洁、易用，并且支持多种操作系统。libserialport 支持阻塞和非阻塞模式，可以根据你的需求选择适当的模式。阻塞模式下，操作会等待完成或超时，而非阻塞模式下，操作会立即返回。通过使用 sp_blocking_* 和 sp_nonblocking_* 函数，你可以轻松实现这两种模式。
[框架设计教程]C#通讯（串口和网络）插件式框架的设计与实现（SuperIO）v1.0.pdf
10-16
SuperIO 框架介绍 SuperIO 是一个轻量级的插件式通讯框架，二次开发者可以快速构建自己（公司）的通讯平台。 并且在此平台上可以挂载自己二次开发的设备驱动、显示驱动、数据格式化驱动以及服务组件驱动， 以满足不同的应用场景使用。 并且在Demo中有完整的事例代码，设备驱动、显示驱动、OPC服务端和客户端组件、WebApi、 手机App等，提供完整的系统解决方案。
串口通信框架
fz835304205的专栏
12-23 2599
好久没更新技术博客了，前段时间看了MODBUS，写了一份主从机通信框架分享给大家 #include "comm.h" #define COM_BUF_SIZE 30 #define COM_ADDR_BASE 0xA0 //slave address #define COM_FRAME_SIZE_MIN (6-2*C
[连载]《C#通讯（串口和网络）框架的设计与实现》-1.通讯框架介绍
weixin_34419321的博客
11-20 563
[连载]《C#通讯（串口和网络）框架的设计与实现》- 0.前言 目 录 第一章 通讯框架介绍... 2 1.1 通讯的本质... 2 1.2 框架简介... 3 1.3 解决现实问题... 4 1.4 应用场景... 5 1.5...
rk3308应用篇 —— Linux 串口异步I/O框架
u010119959的专栏
10-13 868
主框架Demo代码，初始版本V1.0.0，主要帮助大家对框架的熟悉。 整个结构基于link（link.h link.c）的异步I/O机制，框架结构： 实际上，整个应用程序包含的模块远比这个复杂；为了能让学者比较容易上手，这里面其实只是把最基础的部分拿出来。 serial :串口程序 zb_msg : 串口协议解析 device :设备管理 iot_schd : 调度器 serial 串口通信类，非常简洁，serial.h 和 serial.cpp可以直接移植到产品...
linux c串口异步通信,linux串口异步通信开发源代码
weixin_39602737的博客
05-08 361
#include /* These are the hash definitions */#define USERBAUD1200 '1'+'2'#define USERBAUD2400 '2'+'4'#define USERBAUD9600 '9'+'6'#define USERBAUD1920 '1'+'9'#define USERBAUD3840 '3'+'8'#define DEV "/d...
Android串口开发框架
04-10
为了克服这一难题，开发者们构建了各种Android串口开发框架，以便于应用程序能够方便地与外部硬件设备（如传感器、打印机等）通过串行接口进行数据交换。本文将深入探讨“Android串口开发框架”的核心概念、应用场景...
Android实现otg或usb通讯，异步串口功能
08-28
在Android平台上实现OTG（On-The-Go）或USB通讯，以及异步串口功能，是许多物联网和嵌入式项目的关键技术。Android系统通过USB Host API和Android开放设备访问框架（ADK）提供了对USB设备的支持，允许开发者直接与...
Qt5异步串口通信源代码
07-19
首先，我们要了解QSerialPort类是Qt5为串行通信提供的核心工具。它提供了一系列接口来打开、配置和读写串口。在异步模式下，这些操作可以通过信号和槽机制来实现非阻塞的通信。 1. **创建QSerialPort对象** 在程序...
C#，串口通信，简洁界面，初学
10-30
简单的串口通信工具，可以实现串口一些属性的设置，文件是在VS2017下的整个工程文件，方便修改、学习。C#语言实现。
SerialPortLibs:序列化串口封装库（包含源码）
03-23
串行端口库 序列化串口封装库（包含源码） 相关问题 问题1 java.lang.UnsatisfiedLinkError：dlopen失败：/data/app/com.shizhi.usp-1/lib/arm/libserial_port.so：具有文本重定位 在Android 6.0之前的版本中，文本reloactions问题，会在编译的过程中，作为警告报出来，登录大致如下：ActivityManager：警告：链接程序：libdvm.so具有文本重定位。 这浪费了内存，并且存在安全风险。 >请解决。 ？ ？在Android 6.0中，原来的警告被升级为错误了。因此，同样的库文件，在Android 6.0前的环境运行，不报错，6.0下就会崩溃掉。 解决方案：
serialport-lib-dotnet：.Net Mono的串行端口库
02-05
.Net的串行端口库 产品特点 易于使用 事件驱动 热插拔 错误/断开连接时自动重新建立连接 与单声道兼容 它克服了Mono中缺少DataReceived事件的问题 NuGet软件包 SerialPortLib可作为。 在运行Install-Package SerialPortLib ，或在IDE的程序包管理插件中搜索“ SerialPortLib”。 .Net Standard 2.0注释 在Linux下运行时，您可能会遇到以下错误： Unable to load shared library 'libnserial.so.1' or one of its dependencies. 在
AndroidSerialPort android串口库lib aar 文件
05-01
tcgetattr() failed 编译的aar文件解决打开串口报错tcgetattr() failed 最低支持 android 4.2 系统比官方的低到api 17
PIC单片机与PC机异步串行通信的设计.pdf
11-26
通过软件模拟实现串行通信，文中讨论了相关的接口电路设计和通信程序框架，并介绍了C51单片机的中断驱动软件模拟串行通信。 【标签】: "单片机设计 C51 PIC单片机 MCS51单片机 msp430f149单片机" 【内容概述】: ...
VS2010串口通讯架构设计初探
softdragon777的专栏
06-14 1190
串口通讯架构设计初探----及其在VS 2010下的实现          串口以其物理线路少、传输距离远、工作稳定可靠而在微机通讯中得以广泛运用。近来由于机缘巧合，有机会得到真实的通过串口通讯控制LED显示屏及感应式读卡控制器的机会，本指望在网上能得到一些有益的指导，但在网上搜索多日，只见到一些串口方面较基础的、偏重编程方面的文章，鲜少有涉及其架构设计的，于是不揣冒昧，把一些真实的实践体会，撰
[连载]《C#通讯（串口和网络）框架的设计与实现》- 10.宿主程序详细设计
weixin_33774883的博客
12-17 144
目 录 第十章 宿主程序详细设计... 2 10.1 配置文件设计... 3 10.2 加载设备驱动... 4 10.3 加载界面视图... 8 10.4 加载数据导出... 12 10.5 加载服务组件... 14 10.6 全局异常监测...
linux串口异步通信开发源代码
granty32的专栏
03-10 3041
//gcc -o querySerial querySerial.c#include #include #include #include #include /* These are the hash definitions */#define USERBAUD1200 1+2#define USERBAUD2400 2+4#define USERBAUD9600 9+6#
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值