增加调试信息串口输出和网络输出功能

最新推荐文章于 2021-05-11 20:57:32 发布
最新推荐文章于 2021-05-11 20:57:32 发布
阅读量1.3k 收藏
点赞数
分类专栏： 项目班 文章标签： 项目班
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dream890527/article/details/22301891
版权

一、debug_manager.h  

#ifndef _DEBUG_MANAGER_H
#define _DEBUG_MANAGER_H

#define APP_EMERG	"<0>"	/* system is unusable			*/
#define APP_ALERT	"<1>"	/* action must be taken immediately	*/
#define APP_CRIT		"<2>"	/* critical conditions			*/
#define APP_ERR		"<3>"	/* error conditions			*/
#define APP_WARNING	"<4>"	/* warning conditions			*/
#define APP_NOTICE	"<5>"	/* normal but significant condition	*/
#define APP_INFO		"<6>"	/* informational			*/
#define APP_DEBUG	"<7>"	/* debug-level messages			*/

#define DefaultDebugLevel    4

typedef struct DebugOpr {
	char *name;
	int   isCanUse;
	int   (*DebugInit)(void);
	int   (*DebugExit)(void);
//	int   (*DebugPrintf)(const char *format, ...);
	int   (*DebugPrintf)(char* strData);
	struct DebugOpr *ptNext;
}T_DebugOpr, *PT_DebugOpr;
int StdoutInit(void);
int NetInit(void);
int RegisterDebugOpr(PT_DebugOpr ptDebugOpr);
void ShowDebugOpr(void);
int SetDebugLevel(char *ucRecvBuf);
PT_DebugOpr GetDebugOpr(char *pcName);
int setDebugChannel(char * ucRecvBuf);
int DebugPrintf(const char * format,...);
int DebugInit(void);     
int SelectAndInitChannel(void);
#endif /* _DEBUG_MANAGER_H */


二、debug_manager.c

#include <config.h>
#include <debug_manager.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>



static PT_DebugOpr g_ptDebugOprHead;

static int g_iDebugLevelLimit = 8;

int RegisterDebugOpr(PT_DebugOpr ptDebugOpr)
{
	PT_DebugOpr ptTmp;

	if (!g_ptDebugOprHead)
	{
		g_ptDebugOprHead   = ptDebugOpr;
		ptDebugOpr->ptNext = NULL;
	}
	else
	{
		ptTmp = g_ptDebugOprHead;
		while (ptTmp->ptNext)
		{
			ptTmp = ptTmp->ptNext;
		}
		ptTmp->ptNext	  = ptDebugOpr;
		ptDebugOpr->ptNext= NULL;
	}
	return 0;
}
void ShowDebugOpr(void)
{
	int i = 0;
	PT_DebugOpr ptTmp = g_ptDebugOprHead;

	while (ptTmp)
	{
		printf("%02d %s\n", i++, ptTmp->name);
		ptTmp = ptTmp->ptNext;
	}
}

int DebugInit(void)
{
	int iError;
	iError = StdoutInit();
	iError |= NetInit();
	return iError;
}

/*debuglevel=1,2,3...*/
int SetDebugLevel(char *ucRecvBuf)
{
	g_iDebugLevelLimit = ucRecvBuf[12] - '0';
	return 0;
}

PT_DebugOpr GetDebugOpr(char *pcName)
{
	PT_DebugOpr ptTmp = g_ptDebugOprHead;
	
	while (ptTmp)
	{
		if (strcmp(ptTmp->name, pcName) == 0)
		{
			return ptTmp;
		}
		ptTmp = ptTmp->ptNext;
	}
	return NULL;
}

/*stdout = 0
*  stdout = 1
*  net      =0
*  net      =1
**/
int setDebugChannel(char * ucRecvBuf)
{
	char* pstrTmp;
	char   pstrName[100];
	PT_DebugOpr ptTmp;  
	pstrTmp = strchr(ucRecvBuf, '=');
	if(pstrTmp)
	{
		strncpy(pstrName, ucRecvBuf, pstrTmp - ucRecvBuf);
		pstrName[pstrTmp-ucRecvBuf] = '\0';
		ptTmp = GetDebugOpr(pstrName);
		if(ptTmp)
		{
			if(pstrTmp[1] == '0')
			{
				ptTmp->isCanUse = 0;
			}
			else
			{
				ptTmp->isCanUse = 1;
			}
			return 0;
		}
		else
		{
			return -1;
		}
	}
	else
	{
		return -1;
	}
}
int DebugPrintf(const char * format,...)
{
	/*Ö±½ÓʹÓÃvfprintf´òÓ¡*/
	va_list tArgs;
	int iRet;
	char strTmpBuff[1024];
	char *pcTmp;
	
	int debuglevel = DefaultDebugLevel;
	PT_DebugOpr ptTmp = g_ptDebugOprHead;

	va_start(tArgs, format);
	iRet = vsprintf(strTmpBuff, format, tArgs);
	va_end(tArgs);	
	strTmpBuff[iRet] = '\0';
	
	pcTmp = strTmpBuff;
	
/*ÉèÖôòÓ¡¼¶±ð, ÕâÀﲢδÓõ½´òÓ¡¼¶±ð*/
#if 0
	if((strTmpBuff[0] == '<') && (strTmpBuff[2] == '>'))
	{
		debuglevel = strTmpBuff[1] - '0';
		if((debuglevel >= 0) && (debuglevel <= 7))
		{
			pcTmp = strTmpBuff + 3;
		}
		else
		{
			debuglevel = DefaultDebugLevel;
		}
	}
	if(debuglevel > g_iDebugLevelLimit)
	{
		return -1;
	}
#endif
	while(ptTmp)
	{
		if (ptTmp->isCanUse == 1)
		{
			ptTmp->DebugPrintf(pcTmp);
		}
		ptTmp = ptTmp->ptNext;
	}
	return 0;
}
int SelectAndInitChannel(void)
{
	PT_DebugOpr ptTmp = g_ptDebugOprHead;
	while(ptTmp)
	{
		if(ptTmp->isCanUse && ptTmp->DebugInit)
		{
			ptTmp->DebugInit();
		}
		ptTmp = ptTmp->ptNext;
	}
	return 0;
}
 三、stdout.c //串口输出 

#include <config.h>
#include <debug_manager.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>


static int stdoutDebugInit(void);
static int stdoutDebugExit(void);
static int stdoutDebugPrintf(char* strData);


static T_DebugOpr g_tStdoutDebugOpr = {
	.name  		= "stdout",
	.isCanUse 		= 1,
	.DebugInit 	= stdoutDebugInit,
	.DebugExit 	= stdoutDebugExit,
	.DebugPrintf 	= stdoutDebugPrintf, 
};
static int stdoutDebugInit(void)
{
	return 0;
}
static int stdoutDebugExit(void)
{
	return 0;
}

static int stdoutDebugPrintf(char* strData)
{
	printf("%s", strData);
	return strlen(strData);
}

int StdoutInit(void)
{
	return RegisterDebugOpr(&g_tStdoutDebugOpr);
}

四、netprintf.c  //远程网络打印 

#include <config.h>
#include <debug_manager.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <string.h>
#include <stdio.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <signal.h>
#include <stdlib.h>
#include <stdarg.h>
#include <pthread.h>

static int netDebugInit(void);
static int netDebugExit(void);
static int netDebugPrintf(char* strData);
static int g_iSocketFd;
static struct sockaddr_in	g_tServerSocketAddr;
static struct sockaddr_in  g_tClinetSocketAddr;
#define PortNum 8888

#define NET_BUFF_SIZE  (16*1024)
static unsigned char* g_pucNetBuff;
//static unsigned char* g_pucTmpBuff;

static int g_iReadPos = 0;
static int g_iWritePos = 0;

static pthread_t g_tSendThreadID;
static pthread_t g_tRecvThreadID;

static pthread_mutex_t g_tNetSendMutex   		=  PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t    g_tNetSendCondvar  	=  PTHREAD_COND_INITIALIZER;

static int g_isClinetConnected = 0;


static T_DebugOpr g_tNetDebugOpr = {
	.name  		= "net",
	.isCanUse 		= 1,
	.DebugInit 	= netDebugInit,
	.DebugExit 	= netDebugExit,
	.DebugPrintf 	= netDebugPrintf, 
};
/*»·Ðλº³åÇøº¯ÊýÉùÃ÷*/
static int isEmpty(void);
static int isFull(void);
static int PutData(char cVal);
static int GetData(char *pcVal);


static void *NetRecvThreadFunction(void *pvoid)
{
	 int iRecvLen;
	 int iSinSizeLen;
	 char ucRecvBuff[1000]; /*²»ÄÜʹÓÃunsigned char,·ñÔò²úÉú±àÒ뾯¸æ*/
	 struct sockaddr_in  tClinetSocketAddr;
	while(1)
	{
		iSinSizeLen = sizeof(struct sockaddr);
		iRecvLen = recvfrom(g_iSocketFd, ucRecvBuff, 999, 0, (struct sockaddr*)&tClinetSocketAddr, (socklen_t *)&iSinSizeLen);
		 if(iRecvLen > 0)
		 {
			/*½âÎöÊý¾Ý*/
			/* debuglevel 	= 0,1,2...
			*   stdout 		= 0|1 
			*   net      		= 0|1
			*   setclinet     	
			*/
			ucRecvBuff[iRecvLen] = '\0';
			if (strcmp(ucRecvBuff, "setclient")  == 0)
			{
				g_tClinetSocketAddr = tClinetSocketAddr;
				g_isClinetConnected  = 1;
			}
			else if(strncmp(ucRecvBuff, "debuglevel=", 11) == 0)
			{
				SetDebugLevel(ucRecvBuff);
			}
			else
			{
				setDebugChannel(ucRecvBuff);
			}

		 }
		
		
	}
	return NULL;          

}
static void *NetSendThreadFunction(void *pvoid)
{
	int iSinSizeLen;
	int iSendlen;
	char  strTmpBuf[512];
	int i ;
	char cVal;
	while(1)
	{
		/*ƽʱÐÝÃß*/
		pthread_mutex_lock(&g_tNetSendMutex);
		pthread_cond_wait(&g_tNetSendCondvar, &g_tNetSendMutex);
		/*  ±»»½ÐÑÖ®ºó*/
		/*ʹÓÃsendtoº¯Êý°Ñ´Ó»·Ðλº³åÇøµÄÊý¾Ý·¢Ë͵½¿Í»§¶Ë*/

	
		while(g_isClinetConnected && (!isEmpty()))
		{
			i = 0;
			while((i<512) && (0 == GetData(&cVal)))
			{
				strTmpBuf[i] = cVal;
				i++;
			}
			iSinSizeLen = sizeof(struct sockaddr);
			iSendlen = sendto(g_iSocketFd, strTmpBuf, i, 0, (struct sockaddr *)&g_tClinetSocketAddr, (socklen_t)iSinSizeLen);
		}
		
		pthread_mutex_unlock(&g_tNetSendMutex);
	}
	return NULL;
}


static int netDebugInit(void)
{
	/*socket³õʼ»¯*/
       /* ·þÎñÆ÷¶Ë¿ªÊ¼½¨Á¢socketÃèÊö·û */
	g_iSocketFd = socket( AF_INET, SOCK_DGRAM, 0);
	if(g_iSocketFd == -1)
	{
		printf("socket error!\n");	
		return -1;
	}
	  /* ·þÎñÆ÷¶ËÌî³ä sockaddr½á¹¹  */ 
	  g_tServerSocketAddr.sin_family = AF_INET;
	  g_tServerSocketAddr.sin_port   =  htons(PortNum);
	  g_tServerSocketAddr.sin_addr.s_addr = htonl(INADDR_ANY);
	memset(&(g_tServerSocketAddr.sin_zero), 0 , 8);
	
	 /* À¦°óg_iSocketFdÃèÊö·û  */ 
	 if(bind( g_iSocketFd,  (struct  sockaddr  *)(&g_tServerSocketAddr),  sizeof(struct sockaddr)) == -1)
	 {
		printf("bind error !\n");
		return -1;
	 }
	g_pucNetBuff =  malloc(NET_BUFF_SIZE);
	if(NULL ==  g_pucNetBuff)
	{
		printf("malloc g_pucNetBuff error!\n");
		close(g_iSocketFd);
	}
//	g_pucTmpBuff = malloc(2*1024);
//	if(NULL == g_pucTmpBuff)
//	{
//		printf("malloc g_pucTmpBuff error!\n");
//		close(g_iSocketFd);
//		free(g_pucNetBuff);
//	}
	/*´´½¨½ÓÊÕÏß³Ì*/
	/*´´½¨·¢ËÍÏß³Ì*/
	if(pthread_create(&g_tRecvThreadID, NULL, NetRecvThreadFunction, NULL))
	{
		printf("g_tRecvThreadID thread_create error!\n");
		return -1;
	}
	if(pthread_create(&g_tSendThreadID, NULL, NetSendThreadFunction, NULL))
	{
		printf("g_tSendThreadID thread_create error!\n");
		return -1;
	}
	return 0;
}
static int netDebugExit(void)
{
	/*¹Ø±Õsocket*/
	close(g_iSocketFd);
	free(g_pucNetBuff);
//	free(g_pucTmpBuff);
	return 0;
}
/*¹¹Ôì»·Ðλº³åÇø*/
static int isFull(void)
{
	return ((g_iWritePos + 1)%NET_BUFF_SIZE == g_iReadPos);
}

static int isEmpty(void)
{
	return (g_iWritePos == g_iReadPos);
}
static int PutData(char cVal)
{
	if(!isFull())
	{
		g_pucNetBuff[g_iWritePos] = cVal;
		g_iWritePos = (g_iWritePos+1)%NET_BUFF_SIZE;
		return 0;
	}
	else
	{
		return -1;
	}
}

static int GetData(char *pcVal)
{
	if(!isEmpty())
	{
		*pcVal = g_pucNetBuff[g_iReadPos];
		g_iReadPos = (g_iReadPos+1)%NET_BUFF_SIZE;
		return 0;
	}
	else
	{
		return -1;
	}
}

static int netDebugPrintf(char * strData)
{
	/*Êý¾Ý·ÅÈ뻺³åÇø£¬²Î¿¼vsprintfº¯Êý*/
//	va_list tArgs;
//	int iRet;
	int i;
//	int iNum = 2*1024;
//	va_start(tArgs, format);
//	iRet = vsprintf(g_pucTmpBuff, format, tArgs);
//	va_end(tArgs);
//	return iRet;	
	for(i=0; i< strlen(strData); i++)
	{
		if(PutData(strData[i]) == -1)
			break;
	}
	/* µÈ´ý¿Í»§¶ËÁ¬½Ó*/
	/*»½ÐÑÏß³Ì*/
	pthread_mutex_lock(&g_tNetSendMutex);  
	pthread_cond_signal(&g_tNetSendCondvar);
	pthread_mutex_unlock(&g_tNetSendMutex);		
	
	return i;
}

int NetInit(void)
{
	return RegisterDebugOpr(&g_tNetDebugOpr);
}

五、客户端测试程序 

netPrintfClinet.c

/*
 *	Usage:
 *     ./netPrintfClinet <server_IP> debuglevel =<0-8>
 *     ./netPrintfClinet <server_IP> stdout=0|1
 *     ./netPrintfClinet <server_IP> net=0|1 
 *     ./netPrintfClinet <server_IP> show
 */

#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdio.h>

/* socket
 * connect
 * sendto/recvfrom
 */
#define PortNum 8888
 #define MAX_MSG_SIZE	1024
int main(int argc , char ** argv)
{
	int iSocketFd;
	unsigned char ucSendBuff[MAX_MSG_SIZE];
	unsigned char ucRecvBuff[MAX_MSG_SIZE];
	int iSendlen;
	int iRecvLen;
	struct sockaddr_in	 tServerSocketAddr;
	int iSinSizeLen;
	if(argc != 3)
	{
		printf("Usage:\n");
		printf(" %s <server_IP> debuglevel =<0-8>\n",argv[0]);
		printf(" %s <server_IP> stdout=0|1\n",argv[0]);
		printf(" %s <server_IP> net=0|1\n",argv[0]);
		printf(" %s <server_IP> show\n",argv[0]);
		return -1;
	}
	
	 /* ¿Í»§¶Ë¿ªÊ¼½¨Á¢socketÃèÊö·û */
	iSocketFd = socket( AF_INET, SOCK_DGRAM, 0);
	if(iSocketFd == -1)
	{
		printf("socket error!\n");
		return -1;
	}
	  /* ·þÎñÆ÷¶ËÌî³ä sockaddr½á¹¹  */ 
	  tServerSocketAddr.sin_family = AF_INET;
	  tServerSocketAddr.sin_port   =  htons(PortNum);
//	  tServerSocketAddr.sin_addr  = htonl(INADDR_ANY);
	if (0 == inet_aton(argv[1], &tServerSocketAddr.sin_addr))
 	{
		printf("invalid Server_Ip\n");
		return -1;
	}
	memset(&(tServerSocketAddr.sin_zero), 0 , 8);
	
	iSinSizeLen = sizeof(struct sockaddr);
	if(strncmp(argv[2], "show", 4) == 0)
	{
		 /*ÉèÖÿͻ§¶Ë£¬½ÓÊÕÊý¾Ý£¬ÏÔʾ*/
		iSendlen = sendto(iSocketFd, "setclient", 9, 0, (struct sockaddr *)&tServerSocketAddr, (socklen_t)iSinSizeLen);		
		while(1)
		{
			iRecvLen = recvfrom(iSocketFd, ucRecvBuff, MAX_MSG_SIZE-1, 0, (struct sockaddr*)&tServerSocketAddr, (socklen_t *)&iSinSizeLen);		
			if(iRecvLen > 0)
			{
				ucRecvBuff[iRecvLen] = '\0';
				printf("%s\n",ucRecvBuff);
			}					
		}
	}
	else
	{
		/* ·¢ËÍ¿ØÖÆÃüÁî*/
		iSendlen = sendto(iSocketFd, argv[2], strlen(argv[2]), 0, (struct sockaddr *)&tServerSocketAddr, (socklen_t)iSinSizeLen);		
	}
	return 0;
}



VC 的DEBUG模式下 STL 默认启用编译宏_ITERATOR_DEBUG_LEVEL=1，容器析构的时候有BUG，接近死循环
THORNHILL_UTILITIES的博客
05-07 441
偶然发现的一个问题，VS版本为2013static std::list&lt;int&gt; s_list;void TestIteratorDestructTiming(){    s_list.push_back(0);    DWORD64 dwStartTick = GetTickCount64();    struct tagStruct    {        std::list&lt...
关于send to 的问题
xurongj的博客
07-28 399
下面这是我写的一段代码， 这是在main 函数里面为了调用 send to函数所写的一段如下： 目的是往192.168.0.19 端口号4567 中发送指令 30 02 06 00 00 00 串口打印YES 和 CCC 网口打印指令。 现在遇到一个问题就是 串口可以打印 YES 和CCC ，网口接收不到指令 30 02 06 00 00 00 串口的错误提示是： YES [DEBUG] >> -1 [DEBUG] >> ccc1Error:..\FreeRTO
调试信息之网络打印
weixin_45609638的博客
09-05 414
使用串口打印调试信息，通常设置为115200bps, N81,这种设置每秒打印10K+字节的调试信息。 比如打印信息：[I:ERROR][T:19/09/04 16:15:19:649][F:ca.c][C:ca_update_sys_mode][L:1979] Get CA status failed，有100+字节，打印这条信息耗时约为10ms。 目前应用，只打印关键信息，每次操作有120+条...
关于debug level的学习
03-23 3752
debug level就是在代码中增加的一些日志信息，其目的是为了debug。 既然是代码中增加的日志信息，那为何还要debug level呢？直接使用printf输出不行吗？ 因为如果将所有的日志信息都打印出来，那必须会极大的降低程序的执行效率。 log level该如何定义？ 像linux printk就定义了8个级别的log level： #define KERN_EMERG ""
Debuglog
小菜鸟的博客
10-17 2890
思路： 分别用urllib.request.HTTPHander()和urllib.request.HTTPSHander()将debuglevel设置为1 使用urllib.request.build_opener()创建自定义的opener对象，并使用1.中作为参数 用urllib.request.install_opener()创建全局默认的opener对象，在使用urlopen()时...
urllib设置debuglevel打开调试开关
weixin_30851867的博客
06-21 309
1. 参考 Turning on debug output for python 3 urllib https://bugs.python.org/issue26892 Python爬虫入门四之Urllib库的高级用法 5.使用DebugLog 2. 代码 (1) python2 1 # python2 2 import httplib 3 import urllib ...
linux内核调试串口输出,配置串口输出,如何修改安卓默认调试等级以及串口输出...
weixin_35817967的博客
05-11 1598
一、前言一般linux是通过printk来输出调试信息的，而输出的端口设置成串口0，配置的地方是在linux内核的cmdline。 可是这种修改方式并不适用于全志平台，修改完linux内核的cmdline后，再烧录到开发板，利用命令“cat /proc/cmdline”查看，发现并没有改变。shell@tulip-t1:/ # cat /proc/cmdlineenforcing=1 earlyp...
使用STM32cubeIDE 调试F103芯片，uart3串口printf输出信息
04-27
然后，通过设置断点、查看变量、单步执行等调试功能，我们可以监控程序运行状态并观察通过UART3输出的信息。 在实际应用中，可能还需要处理中断，以便在数据发送完成后接收新的数据。例如，可以使用USART的传输完成...
串口网络数据调试助手V1.5
最新发布
03-27
智联物联串口网络数据调试助手V1.5是一款非常好用的调试工具，串口网络数据调试助手V1.5显示流畅，不容易丢数据，支持字符串和十六进制方式显示，和加时间戳分数据包显示。 串口网络数据调试助手V1.5特点 1、显示...
串口调试功能 串口调试功能 串口调试功能 串口调试功能 串口调试功能
11-24
1. 开发嵌入式系统：在开发微控制器(MCU)或单片机项目时，通过串口输出系统状态信息。 2. IoT设备调试：调试物联网设备，如传感器、执行器等，确保数据准确传输。 3. 模拟通信：在没有实际硬件的情况下，通过虚拟...
串口模块.zip_串口接收解析_串口模块_串口解析_单片机调试输出接口_接受状态
07-15
在单片机调试中，串口输出接口是常用的调试手段，因为它能实时显示程序运行过程中的变量值和状态，帮助开发者快速定位问题。通过串口模块，开发者可以将单片机内部的运行信息发送到PC或其他设备，以文本形式显示，这...
C/C++常用接口: 调节打印日志级别的接口
Stay Hungry Stay Foolish
12-23 1206
 接口定义: #define INFOLEVEL 1 #define DEBUGLEVEL 2 #define WARNINGLEVEL 3 #define ERRORLEVEL 4 #define SDK_PRINT(level,fmt,...)\ do {\ if (level &gt; DEBUGLEVEL) {\ printf("%s:...
openwrt关闭串口打印信息
x13163303344的专栏
10-22 3434
mt7620n仅有一个串口 由于开发板只有一个UART lite接口，在原生的OpenWrt中作为了内核打印和tty控制台所用。 而在很多情况下，需要使用串口与外部芯片进行通讯，这时就需要从OpenWrt中释放串口。 其实这个任务只有两个步骤：（我们假定$(TOPDIR)为OpenWrt的编译目录） 关闭串口控制台 将$(TOPDIR)/target/linux/rami
TCP 服务端Service
12-14 1083
package com.java; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.io.OutputStream; import java.io.PrintWr
调试助手（网络调试助手、摄像头调试助手、串口调试助手）
07-04
这里我们主要关注三个类型的调试助手：网络调试助手、摄像头调试助手和串口调试助手。 **网络调试助手** 网络调试助手是用于监测和分析网络通信的专业工具。它能帮助开发者查看和解析网络数据包，包括TCP/IP、HTTP...
串口实验_串口输出实验_uart_
10-01
在STM32中，串口1（USART1）通常用于开发过程中的调试输出，因为它可以方便地通过USB转串口模块连接到电脑上，通过串口终端软件查看输出信息。要使用STM32的串口1，我们首先需要在STM32的HAL库或LL库中配置相关...
全志A33-串口的使用
ARM-Linux
08-05 5062
开发环境 开发板：A33-Vstar 开发板系统：Linux --------------------------   1. A33串口在设备文件下显示为： /dev/ttyS0 /dev/ttyS1 /dev/ttyS2 等。 2. 将A33 串口2通过ch340接到pc（Windows），打开串口调试助手。 3. 数据收发测试 登录A33终端，执行：ls/dev 可看到ttyS...
【android】全志T3 android6.0串口6不能正常使用的问题
三言两语
12-21 3348
今天移植全志提供的android6.0sdk到我们自己的平台上，在验证相关功能时发现串口6无法正常进行收发，排除本身测试代码问题后，排查sdk，发现其提供的sdk中对于串口6的配置有坑，记录下解决方法，希望帮助到其他人。 1、问题描述 sys_config.fex中配置了串口6，init.rc中增加其对应的读写权限，然后编写测试程序对串口进行，读写，发现无法收到测试程序写入的数据，接收估计可以
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值