串口调试系统

最新推荐文章于 2024-05-14 11:49:22 发布
最新推荐文章于 2024-05-14 11:49:22 发布
阅读量424 收藏 10
点赞数 9
分类专栏： STM32小实验 文章标签： 单片机 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);
		}	
}
执笔-叙写流年
关注
  • 9
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
mcuisp 串口调试工具
09-10
mcuisp 串口调试工具
ESP8266-01的使用：固件烧录、串口调试、MCU控制
yourking_的博客
09-12 1011
ESP8266-01的使用：固件烧录、串口调试、MCU控制
零死角玩转stm32中级篇1-调试必备串口（UART）
孤夜的博客
03-19 2410
本篇博文主要讲解了串口通信相关知识。
新唐MCU之UART软硬件调试过程记录及总结
ALISAlwz的博客
08-23 2190
UART调试
【STM32】-串口调试中软硬件问题定位过程分享
m0_54916619的博客
03-25 2323
串口调试中难免会遇到问题，对于新手来说，会觉得无从下手，或急于修改代码，查找软件原因。本文将分享调试中遇到的问题及排故思路，供读者参考、学习。
Mac版本串口调试助手
04-12
系统要求：MacOS 10.15+ 界面简介，使用方便 （1）软件支持字符串和十六进制字符发送以及接收 （2）支持添加时间戳，支持更改发送和接收的颜色，支持深色/浅色 （3）支持更改返回字符的编码，支持更改中英文界面...
SSCOM串口调试助手
06-01
SSCOM串口调试助手是一款常用的串口调试工具，用于在Windows系统下与串口通信。它可以通过串口与单片机、传感器等硬件设备进行通信，并可以实时显示发送和接收的数据，方便用户进行调试和测试。 SSCOM串口调试助手的...
串口调试助手v20.7z
07-16
单片机、嵌入式开发常用的串口调试助手。支持文件发送、定时发送、数据保存、物联网模拟控制、ESP8266调试等等。
Linux 系统串口调试工具
04-10
Linux 系统串口调试工具
串口调试工具串口调试精灵 串口助手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 ...
MCUISP+串口调试工具
07-05
嵌入式课程的hex烧写工具，以及串口调试工具。可以直接安装使用
一个台湾某32位MCU的奇葩串口调试过程
sshyidishui的博客
10-17 541
近期，设计了一个基于台湾某32位MCU的带蓝牙功能的PCB，其它的部分都搞定了，唯独这个串口死活不通。我使用的蓝牙模块与MCU之间以串口通信。编写了一个简单的测试程序，然后仿真，发现只要运行到设置串口参数的语句(该语句使用了库函数的)处，再执行就跑飞了。WHY?确认看门狗已经关闭。然后怎么都无法运行正常。将改行程序屏蔽，再次仿真，没有串口时，运行OK，确认是这条语句的问题，可是，为什么是这条语句呢
单片机shell命令_MCU调试大法：使用串口实现简单shell功能
weixin_34352414的博客
01-14 1438
MCU调试大法：使用串口实现简单shell功能[复制链接]MCU程序调试方法有很多，比如软/硬件仿真、添加数据打印等。像KeilMDK就支持不少单片机的软件仿真，在没有拿到单片机的情况下，就可以先仿真调试部分功能，查看代码逻辑是否正确。硬件仿真则需要借助仿真器，如调试Cortex内核MCU常用的J-Link/ST-Link等。通过watch窗口可以查看变量的值：在代码中添加数据的打印，则需要借助...
单片机程序协助调试方法（一）串口调试(持续更新中)
刺客_阿瑞的专栏
03-31 7034
这里分享一下我在调试程序时常用的方法（一）：串口调试 （这部分代码只是作为调试的一种手段，只在需要测试的地方和不影响MCU和控制芯片通信的地方在使用，不可随意使用，随意使用可能会因为串口传输数据而错过MCU和控制芯片的通信数据而导致通信失败或异常，我就遇到过这样的问题，一定要注意！）   /*################uart.h start ################*/ #
MCU非常重要的通信接口--UART的调试
滴水藏海
04-18 1万+
1，在CubeMX中的配置步骤 （1）RCC  打开HSE 外设的时钟配置，HCLK = 72MHZ （2）USART1 异步收发 以上配置完成，生成keil工程的代码。 2， 测试程序的步骤：在串口调试助手中向UART1中发送数据，使用中断的方式，stm32f103中收到字符串后进入中断服务函数，然后像串口写
极海单片机串口调试记录
Super辉sir的博客
04-30 3276
极海单片机替换华大（极海作为备用），一路上遇到了很多问题，所以写一篇文章记录一下。
USB转串口那些事儿-串口调试常见问题和排查方法
热门推荐
PC小能手的博客
10-18 1万+
本文对于串口调试中经常遇到的问题进行了梳理，从原理到应用阶段，对串口通讯乱码，收发数据异常等情况予以举例说明，供工程师参考。
用Ai编写一个电机驱动程序
番茄蛋汤面
05-12 1026
对于有一定编程经验的人来说，这个回答还是能看懂的，但是如果是初学者，也不难理解，还是完整的提供了核心的程序，对于HAL库来说，不同的开发平台虽然不尽相同，但是基本有现成的程序接口，总的来是AI的这个回答还是可以的，但是和这个程序还没提涉及到产品逻辑，要想达到能用的状态还需要人工进行一些加工和修饰。
海思Hi3065H 200MHz 高性能 RISCV32 A² MCU
最新发布
skywalk8163的专栏
05-14 431
这是一款海思自研的RISCV32内核的高性能实时控制专用MCU， 具有高性能、高集成度、高可靠性、易开发的特点，同时还有嵌入式AI能力。
ubuntu串口调试
03-27
Ubuntu是一种流行的开源操作系统，它提供了丰富的工具和功能来进行串口调试。串口调试是一种通过串行通信接口与外部设备进行通信和调试的过程。在Ubuntu中，你可以使用以下步骤进行串口调试： 1. 确认串口设备：...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值