串口调试系统

最新推荐文章于 2024-09-18 10:25:23 发布
最新推荐文章于 2024-09-18 10:25:23 发布
阅读量554 收藏 10
点赞数 9
分类专栏： 总结记录 文章标签： 单片机 stm32 mcu 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43669764/article/details/135358644
版权

单片机串口调试系统实现

1.1前言

​ 在调试单片机程序时，一般我们通过仿真器进行调试，让程序一步一步的执行，或者通过打印的方式看关键的位置的参数对不对。这样调试对于不是很复杂的系统确实可以，但是当系统比较复杂时，不可能一步一步的看，效率太低了，需要不断修改程序，烧写，调试。

​ 我们可以针对我们比较关心的地方，设置一些调试指令以及对应的函数，我们可以根据我们的需要通过指令去执行我们想要执行的功能模块，来在运行期间发现可能出现的问题。

1.2 串口调试框架

在这里插入图片描述
​ 串口调试系统框架图如上图所示，一般在单片机开发中，我们会为我们用到的单片机资源编写对应的业务功能函数，在应用逻辑上调用这些功能函数完成我们需要实现的应用功能。这样系统是正常运行的，但是当系统出现异常时，我们不能快速判断出问题出在什么地方，因为可能是多个模块在一起时导致了异常，我们无法判断出是哪个模块出现了问题，这时候我们通过仿真调试一步步找到出问题的模块，或者通过日志的方式。这两种方式都需要反复烧写程序运行调试，浪费时间，而且当在现场时，也不方便调试程序。

​ 这时候我们需要加入串口调试，或者网络调试等，我们可以为我们的实际业务逻辑创建一个镜像，模拟不同场景，和实际场景作对比，我们可以快速找到问题在哪。

1.3 实现

​ 遵循高内聚低耦合的设计思想，我们将串口调试系统分为三个部分。

在这里插入图片描述
​ 我们可以将硬件设备如串口，网络等抽象出来，调试管理者向硬件设备注册，功能模块向串口调试管理者注册。这样设计的好处就是当硬件设备从串口变成了网络，我们只需要向新设备注册对应的接口就可以了，不需要做太多修改，功能模块和调试管理者之间也是这种关系。这样我们可以高度模块化，提高开发效率。降低了耦合性。

1.3.1 硬件设备抽象

​ 以STM32F407ZGT6串口作为调试接口为例，使用HAl库。

uart.h

#ifndef __UART_H__
#define __UART_H__
#ifdef __cplusplus
extern "C"{
#endif
typedef void (*UARTRxCpltHandler)(void *);//接收完成回调指针
typedef void (*UARTTxCpltHandler)(void *);//发送完成回调指针
typedef struct{
    UART_HandleTypeDef *huart;
    void               *handle;
    UARTRxCpltHandler  handler;
} UARTRxCpltList;  //注册接收设备管理数组

typedef struct{
    UART_HandleTypeDef *huart;
    void                *handle;
    UARTTxCpltHandler handler;
} UARTTxCpltList;//注册发送设备管理数组
    
//注册接收完成回调
int UartRegisterRxCpltHandler(UART_HandleTypeDef *huart, UARTRxCpltHandler handler, void * handle);
//注销接收完成回调  
int UartUnRegisterRxCpltHandler(UART_HandleTypeDef *huart);
//注册发送完成回调   	
int UartRegisterTxCpltHandler(UART_HandleTypeDef *huart, UARTTxCpltHandler handler, void * handle);
//注销发送完成回调
int UartUnRegisterTxCpltHandler(UART_HandleTypeDef *huart);
    
#ifdef __cplusplus
}
#endif
#endif

uart.c

#include "uart.h"
#define UART_MAX_DEVICE_NUMBER          5	//串口设备数
UARTTxCpltList    g_UartTxCpltList[UART_MAX_DEVICE_NUMBER+1] = {0};
UARTRxCpltList    g_UartRxCpltList[UART_MAX_DEVICE_NUMBER+1] = {0};
int UartRegisterRxCpltHandler(UART_HandleTypeDef *huart, UARTRxCpltHandler handler, void * handle)
{
    int i;
    for (i = 0; i < UART_MAX_DEVICE_NUMBER; i++)
    {
        if (g_UartRxCpltList[i].huart == huart
            || NULL == g_UartRxCpltList[i].huart)
        {
            break;
        }
    }

    if (i >= UART_MAX_DEVICE_NUMBER)
    {
        return -1;
    }

    if (NULL == g_UartRxCpltList[i].huart)
    {
        g_UartRxCpltList[i].huart = huart;
    }

    g_UartRxCpltList[i].handler = handler;
    g_UartRxCpltList[i].handle = handle;
    return 0;
}

int UartUnRegisterRxCpltHandler(UART_HandleTypeDef *huart)
{
    int i;
    for (i = 0; i < UART_MAX_DEVICE_NUMBER; i++)
    {
        if (g_UartRxCpltList[i].huart == huart)
        {
            g_UartRxCpltList[i].huart = NULL;
            g_UartRxCpltList[i].handler = NULL;
            g_UartRxCpltList[i].handle = NULL;
            return 0;
        }
    }

    return -1;
}
int UartRegisterTxCpltHandler(UART_HandleTypeDef *huart, UARTTxCpltHandler handler, void *handle)
{
    int i;
    for (i = 0; i < UART_MAX_DEVICE_NUMBER; i++)
    {
        if (g_UartTxCpltList[i].huart == huart
            || NULL == g_UartTxCpltList[i].huart)
        {
            break;
        }
    }

    if (i >= UART_MAX_DEVICE_NUMBER)
    {
        return -1;
    }

    if (NULL == g_UartTxCpltList[i].huart)
    {
        g_UartTxCpltList[i].huart = huart;
    }

    g_UartTxCpltList[i].handler = handler;
    g_UartTxCpltList[i].handle = handle;

    return 0;
}

int UartUnRegisterTxCpltHandler(UART_HandleTypeDef *huart)
{
    int i;
    for (i = 0; i < UART_MAX_DEVICE_NUMBER; i++)
    {
        if (g_UartTxCpltList[i].huart == huart)
        {
            g_UartTxCpltList[i].huart = NULL;
            g_UartTxCpltList[i].handler = NULL;
            g_UartTxCpltList[i].handle = NULL;
           return 0;
        }
    }
    return -1;
}
//HAL库回调
void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
{
    INT16 i;
    for (i = 0; i < UART_MAX_DEVICE_NUMBER; i++)
    {
        if (huart == g_UartTxCpltList[i].huart)
        {
            if (g_UartTxCpltList[i].handler != NULL)
            {
                (g_UartTxCpltList[i].handler)(g_UartTxCpltList[i].handle);
            }
            return;
        }
    }
}
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
    INT16 i;
    for (i = 0; i < UART_MAX_DEVICE_NUMBER; i++)
    {
        if (huart == g_UartRxCpltList[i].huart)
        {
            if (g_UartRxCpltList[i].handler != NULL)
            {
                (g_UartRxCpltList[i].handler)(g_UartRxCpltList[i].handle);
            }
            return;
        }
    }
}

1.3.2 调试管理模块

cmd_ment.h

#ifndef __CMD_H__
#define __CMD_H__
#ifdef __cplusplus
extern "C"{
#endif
typedef int (*CommandHandler)(char *InBuf, int len);
typedef int (*CmdParamHandler)(char *pParam, int len);

typedef struct{
    const char cmdName[16]; //名称
    const char cmdDesc[64];	//描述
    CommandHandler pfCommandHandler; 
} CmdModuleInfo_S;

typedef struct tag_CmdModuleList {
    struct tag_CmdModuleList* pNext;
    const CmdModuleInfo_S *pInfo;
} CmdModuleList_S;

typedef struct tag_CmdParamInfo {
    const char szParam[16];
    const char szParamDesc[48];
    CmdParamHandler pHandler;
} CmdParamInfo_S;
   
void   CmdPrintf(const char* fmt, ...);
    
void CmdGeneralParamHelpHandler(const CmdParamInfo_S *pInfo, INT16 count);
void registerCmdModule(const CmdModuleInfo_S *pInfo);
void CmdInit(void);
#ifdef __cplusplus
}
#endif
#endif

1.3.3 功能模块

​ 这里为了方便没有将led驱动和cmd分开，按照高内聚低耦合的思想是要分开的,这里是标准库的，和HAL库差别不大，换成HAL函数就行。

ledcmd.h

#ifndef __LED_H
#define __LED_H	 
void LED_Init(void);//初始化
uint8_t LED_ReadState(uint8_t lednum);
void LED_On(uint8_t lednum);
void LED_Off(uint8_t lednum);
void LED_Toggle_Red(uint16_t ms);
void LED_Toggle_Gree(uint16_t ms);
void registerCMD_LED(void);				    
#endif

ledcmd.c

#include "led.h" 
#include "delay.h"
#include "usart.h"

int32_t CmdLedHandler(char *InBuf, uint32_t len);

const CmdModuleInfo_S g_stCmdInfoLed = {
    "Led",
    "led on/off/toggle commands",
     CmdLedHandler,
};

int32_t CmdLedParamHelpHandler(char *pParam,  uint32_t len);
int32_t CmdLedParamListHandler(char *pParam,  uint32_t len);
int32_t CmdLedParamOnHandler(char *pParam, uint32_t len);
int32_t CmdLedParamOffHandler(char *pParam, uint32_t len);
int32_t CmdLedParamtoggleHandler(char *pParam, uint32_t len);

const CmdParamInfo_S g_szCmdLedParams[] = {
    {"help", "show this help", CmdLedParamHelpHandler},
    {"list", "list current led state", CmdLedParamListHandler},
    {"on", "on led modules, eg on 0>>led0 on,on 1>>led1 on", CmdLedParamOnHandler},
    {"off", "off led modules,eg off 0>>led0 off,off 1>>led1 off", CmdLedParamOffHandler},
    {"toggle", "toggle led modules,eg toggle 0>>led0 toggle,toggle 1>>led1 toggle", CmdLedParamtoggleHandler},
};

int32_t CmdLedHandler(char *InBuf, uint32_t len)
{
	char *pContent = InBuf;
    char *pBlank;
    char *pParam;
    char i;
    printf("\r\n");
    pParam = strchr(pContent, ' ');
    while (*pParam == ' ') {
        pParam++;
    }
    pBlank = strchr(pParam, ' ');
    if (pBlank != NULL)
    {
        pContent = pBlank + 1;
        while (*pContent == ' ' && pContent < (InBuf + len))
        {
            ++pContent;
        }
    }
    for (i = 0; i < (sizeof(g_szCmdLedParams) / sizeof(CmdParamInfo_S)); i++)
    {
        if (0 == strncmp(g_szCmdLedParams[i].szParam, pParam, 			                              strlen(g_szCmdLedParams[i].szParam)))
        {
            if (NULL != g_szCmdLedParams[i].pHandler)
            {
                return (g_szCmdLedParams[i].pHandler)(pContent, (pParam + len - pContent));
            }
        }
    }
    return 0;
}

int32_t CmdLedParamListHandler(char *pParam,  uint32_t len)
{
		printf("\r\nLed0 State is %s\r\n",(LED_ReadState(0)? "off":"on"));
		printf("Led1 State is %s\r\n",(LED_ReadState(0)? "off":"on"));
		return 0;
}
int32_t CmdLedParamHelpHandler(char *pParam,  uint32_t len)
{
	CmdGeneralParamHelpHandler(g_szCmdLedParams, (sizeof(g_szCmdLedParams) / 			sizeof(CmdParamInfo_S)));
    return 0;
}
int32_t CmdLedParamtoggleHandler(char *pParam, uint32_t len)
{
    int enable;
    uint8_t filled = 0;
    filled = sscanf(pParam,"%d",&enable);
		if(filled == 1)
		{
			if(enable == 0)
			{
				LED_Toggle_Red(2);
				printf("set led0 toggle success!\r\n");
			}
			else
			{
				LED_Toggle_Gree(2);
				printf("set led1 toggle success!\r\n");
			}
		}
		return 0;
}
int32_t CmdLedParamOnHandler(char *pParam, uint32_t len)
{
    int enable;
    uint8_t filled = 0;
    filled = sscanf(pParam,"%d",&enable);
		if(filled == 1)
		{
			if(enable == 0)
			{
				LED_On(0);
				printf("set led0 on success!\r\n");
			}
			else
			{
				LED_On(1);
				printf("set led1 on success!\r\n");
			}
		}
		return 0;
}
int32_t CmdLedParamOffHandler(char *pParam, uint32_t len)
{
	
    int enable;
    uint8_t filled = 0;
    filled = sscanf(pParam,"%d",&enable);
		if(filled == 1)
		{
			if(enable == 0)
			{
				LED_Off(0);
				printf("set led0 off success!\r\n");
			}
			else
			{
				LED_Off(1);
				printf("set led1 off success!\r\n");
			}
		}

	  return 0;
}

void registerCMD_LED(void)
{
    registerCmdModule(&g_stCmdInfoLed);
}

//初始化PF9和PF10为输出口.并使能这两个口的时钟		    
//LED IO初始化
void LED_Init(void)
{    	 
  GPIO_InitTypeDef  GPIO_InitStructure;

  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOF, ENABLE);//使能GPIOF时钟

  //GPIOF9,F10初始化设置
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9 | GPIO_Pin_10;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;//普通输出模式
  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;//推挽输出
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;//100MHz
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;//上拉
  GPIO_Init(GPIOF, &GPIO_InitStructure);//初始化
	//GPIO_SetBits(GPIOF,GPIO_Pin_9 | GPIO_Pin_10);//GPIOF9,F10设置高，灯灭

}
void LED_Toggle_Red(uint16_t ms)
{
		//delay_ms(ms);
		GPIO_ToggleBits(GPIOF,GPIO_Pin_9);
}
void LED_Toggle_Gree(uint16_t ms)
{
		//delay_ms(ms);
		GPIO_ToggleBits(GPIOF,GPIO_Pin_10);
}
uint8_t LED_ReadState(uint8_t lednum)
{
		if(lednum == 0)
		{
			return GPIO_ReadOutputDataBit(GPIOF, GPIO_Pin_9);
		}
		else
		{
			return GPIO_ReadOutputDataBit(GPIOF, GPIO_Pin_10);
		}	
}
void LED_On(uint8_t lednum)
{
		if(lednum == 0)
		{
			 GPIO_ResetBits(GPIOF, GPIO_Pin_9);
		}
		else
		{
			 GPIO_ResetBits(GPIOF, GPIO_Pin_10);
		}	
}
void LED_Off(uint8_t lednum)
{
		if(lednum == 0)
		{
			 GPIO_SetBits(GPIOF, GPIO_Pin_9);
		}
		else
		{
			 GPIO_SetBits(GPIOF, GPIO_Pin_10);
		}	
}
执笔-叙写流年
关注
专栏目录
单片机串口调试工具
06-20
串口调试工具是功能齐全,操作方便的串口调试工具,是单片机通讯开发的最佳助手!<br><br>主要功能如下:<br>1.可设置各种通讯速率、奇偶校验、数据位和停止位；<br>2.以十六进制(HEX)数据格式的发送模式和接收模式；<br>3.能将接收数据保存成文本文件,便于观察分析；<br>4.自动保存设置参数，无需每次重新设置；<br>5.可以设置每条数据发送后的延时时间,格式为“#”加上延迟时间(单位毫秒),例如“#1500”是延迟1.5秒；<br>6.支持CRC8校验,发送数据前选中所要校验的数据点击“CRC8”按钮可自动计算；<br>7.DTR自动控制是为了方便RS485通讯测试而添加的功能；
串口调试程序（简单易懂版）
08-19
最简单的串口调试程序，作为初学者容易理解、容易上手。
怎样远程调试串口
最新发布
supreme_1226的博客
09-18 1018
在信息技术飞速发展的今天，软硬件工程师们面临着前所未有的挑战和机遇。随着物联网、工业4.0及互联网技术的兴起，设备的远程管理和调试已成为行业趋势。在这一背景下，《串口网口远程调试软件》应运而生，旨在为工程师们提供一种全新的远程调试解决方案，让设备调试跨越地域限制，变得更加高效便捷。
串口调试助手vc源程序及其详细编写过程
ricks的专栏
07-09 8378
目次：1.建立项目  2.在项目中插入MSComm控件 3.利用ClassWizard定义CMSComm类控制变量4.在对话框中添加控件  5.添加串口事件消息处理函数OnComm()6.打开和设置串口参数7.发送数据　8.发送十六进制字符9.在接收框中以十六进制显示10.如何设置自动发送11.什么是VARIANT数据类型？如何使用VARIANT数据类型
串口调试程序串口调试程序
02-20
串口调试程序。让学习如何对串口编程更加方便。
串口调试程序
mars_Vessalius的博客
03-08 770
串口调试程序调试程序 之前为了调试linux串口驱动，写了一个简单的调试应用程序，为了方便调试我选择了预留传递设备文件路径的接口。 调试程序 #include <stdio.h> #include <stdlib.h> #include <string.h> #include <strings.h> #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h>
串口调试工具串口调试精灵 串口助手PLC串口通信调试大全（40个）.zip
12-31
串口调试工具串口调试精灵 串口助手PLC串口通信调试大全（40个）： AccessPort 1.33.rar Awen串口调试助手 4.0.rar BOAST串口调试工具Ver3.69.rar COMDEBUG共享版.rar ComFilter V2.0.rar Commix V1.4.rar ComTone ...
VC++ 串口调试精灵源代码.rar_VB串口调试软件_VC 串口_串口_串口调试
07-14
【标题】"VC++ 串口调试精灵源代码.rar" 提供的是一个基于VC++编写的串口调试工具的源代码。这个工具主要用于帮助开发者在进行串口通信开发时进行测试和调试。串口，也称为COM端口，是计算机硬件的一部分，用于与...
串口调试软件 串口调试助手
09-17
串口调试软件是电子工程师和开发者在进行单片机、嵌入式系统或者通信协议调试时不可或缺的工具。本文将详细介绍“串口调试助手”这一软件的特点和使用方法，以及如何利用它进行有效的串口通信调试。 串口，即通用...
串口调试小程序
02-28
可用于物联网试验箱以及温湿度传感器，可扩展性强，通过改变发送的数据包命令可实现其他传感器。相当于diy的串口调试小程序。
MFC 串口调试小程序
08-24
自己写的一个小工具，使用MFC制作的串口调试小程序及源码。
STM8串口调试程序
09-06
STM8串口调试程序 在实际的例程中可以学到更多，让你开房起来更方便，更快捷！
android串口调试工具
07-31
ANDROID 的串口调试工具 apk 能接收 能发送 loopback！ANDROID 的串口调试工具 apk 能接收 能发送 loopback！
一些常用的串口调试助手合集
02-27
SerialHunter 是一款功能强大的串口调试工具，除了基础的串口通讯功能，它还具备查找和枚举系统中的所有串口、捕获和分析串口数据流、实时监视串口活动等功能。对于开发者来说，SerialHunter 可以帮助定位串口通信...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值