基于stm32的shell实现

7 篇文章 4 订阅
3 篇文章 0 订阅

首先
思考一下,想要和linux一样使用命令,通过命令执行对应的操作,第一步就需要定义命令,人为的添加与删除这些命令,保存到我们可以找到命令的存储位置,在代码中实现命令的底层原理是通过链表的形式将每个命令彼此链接起来的。

下面我将uboot中关于链表的代码copy出来, 也可以自行去uboot中查找

#ifndef LIST_H
#define LIST_H

struct list_head {
    struct list_head *next, *prev;
};


/****************************************************************/
#define LIST_HEAD_INIT(name) { &(name), &(name) }

#define LIST_HEAD(name) \
    struct list_head name = LIST_HEAD_INIT(name)

//这种宏定义的方法,将节点定义的同时,并且初始化,如果定义好了,就不适合这种方法了

/****************************************************************/
static inline void INIT_LIST_HEAD(struct list_head *list)
{
    list->next = list;
    list->prev = list;
}
//这种方法是节点在外部定义完成后,调用该函数,给成员赋值
/****************************************************************/
/*
 * Insert a new entry between two known consecutive entries.
 *
 * This is only for internal list manipulation where we know
 * the prev/next entries already!
 */
#ifndef CONFIG_DEBUG_LIST
static inline void __list_add(struct list_head *new,
                  struct list_head *prev,
                  struct list_head *next)
{
    next->prev = new;
    new->next = next;
    new->prev = prev;
    prev->next = new;
}
#else
extern void __list_add(struct list_head *new,
                  struct list_head *prev,
                  struct list_head *next);
#endif

/**
 * list_add - add a new entry
 * @new: new entry to be added
 * @head: list head to add it after
 *
 * Insert a new entry after the specified head.
 * This is good for implementing stacks.
 */
static inline void list_add(struct list_head *new, struct list_head *head)
{
    __list_add(new, head, head->next);
}


/**
 * list_add_tail - add a new entry
 * @new: new entry to be added
 * @head: list head to add it before
 *
 * Insert a new entry before the specified head.
 * This is useful for implementing queues.
 */
static inline void list_add_tail(struct list_head *new, struct list_head *head)
{
    __list_add(new, head->prev, head);
}

/*
 * Delete a list entry by making the prev/next entries
 * point to each other.
 *
 * This is only for internal list manipulation where we know
 * the prev/next entries already!
 */
static inline void __list_del(struct list_head * prev, struct list_head * next)
{
    next->prev = prev;
    prev->next = next;
}

/**
 * list_del - deletes entry from list.
 * @entry: the element to delete from the list.
 * Note: list_empty() on entry does not return true after this, the entry is
 * in an undefined state.
 */
#ifndef CONFIG_DEBUG_LIST
static inline void list_del(struct list_head *entry)
{
    __list_del(entry->prev, entry->next);
}
#else
extern void list_del(struct list_head *entry);
#endif




#define offsetof(TYPE, MEMBER)  ((size_t)&((TYPE *)0)->MEMBER)


/**
 * container_of - cast a member of a structure out to the containing structure 根据结构体重的一个成员变量地址导出包含这个成员变量mem的struct地址
 * @ptr:    the pointer to the member. 结构体变量中某个成员的地址
 * @type:   the type of the container struct this is embedded in. 结构体类型
 * @member: the name of the member within the struct.  该结构体变量的具体名字
 *
 */

#define container_of(ptr, type, member) ({                      \
        const typeof( ((type *)0)->member ) *__mptr = (ptr);    \
        (type *)( (char *)__mptr - offsetof(type,member) );})


#define list_entry(ptr, type, member) \
        container_of(ptr, type, member)



#define list_for_each_entry(pos, head, member)              \
    for (pos = list_entry((head)->next, typeof(*pos), member);  \
         &pos->member != (head);    \
         pos = list_entry(pos->member.next, typeof(*pos), member)) \



#endif // LIST_H

到此,链表的数据结构与方法已经实现了,但这只是单纯的链表结构体,并没有什么太大用处,让其包含更多的参数,重新封装一下,如下代码


//定义一个函数指针类型
typedef void (*pfunc_t)(void);

//栈内存
struct node
{

	char	*name;
	char	*usage;
	int		 maxargs;
    pfunc_t run_command;
    struct list_head list;
	
};


/* 此代码的作用是初始化一个自定义名称的链表,把成员变量赋初值,并且将纯链表指向自己*/
/*链表节点*/
#define Struct_Section  __attribute__ ((used,section (".shell")))

#define create_list(name,usage,maxargs,cmd) \
    struct node name Struct_Section = { #name,usage,maxargs,cmd, &(name.list), &(name.list) }


以上是关于命令的数据结构的定义。
以下是使用数据结构定义专属于自己的命令。

LIST_HEAD(Head);

void CMD_LIST_Init(void)
{
	
	static create_list(led,"select led mode\r\n"
							"	led 	0	Led_Dark\r\n"
							"	led 	1	Led_Light\r\n"
							"	led 	2	Led_Light100ms\r\n"
							"	led 	3	Led_Blink1\r\n"
							"	led 	4	Led_Blink2\r\n"
							"	led 	5	Led_Blink3\r\n"
							"	led 	6	Led_Blink4\r\n"
							"	led 	7	Led_FLOW\r\n",1,do_leds);
    list_add_tail(&(led.list),&Head);
	
    static create_list(help,"      print command usage",1,do_help);
    list_add_tail(&(help.list),&Head);
		
	static create_list(echo,"      echo args to console",1,do_echo);
    list_add_tail(&(echo.list),&Head);
	
	static create_list(board,"     echo slot board type",1,do_board);
    list_add_tail(&(board.list),&Head);
	
	static create_list(reboot,"    Reboot System",1,do_reboot);
    list_add_tail(&(reboot.list),&Head);
	
	static create_list(DP,"        echo DP Input status",1,do_DP);
    list_add_tail(&(DP.list),&Head);
	
	static create_list(readedid,"  Read EDID info",1,do_ReadEDID);
    list_add_tail(&(readedid.list),&Head);
	
	static create_list(earseedid," earse EDID",1,do_WriteEDID);
    list_add_tail(&(earseedid.list),&Head);
	
	static create_list(reset,"     reset xxx",1,do_reset);
    list_add_tail(&(reset.list),&Head);
	
	static create_list(HPD,"       HPD on or off",1,do_HPD);
    list_add_tail(&(HPD.list),&Head);
}

在main函数中初始化CMD_LIST_Init后,运行一下看一下效果
在这里插入图片描述
使用help将定义好的usage打印出来,上面是打印效果。

仅仅使用以上代码无法完成正常使用者的交互工作,上面的打印信息也是我调试好的,当无法获取到用户的输入就无法进行交互。
使用SecureCRT打开串口,当打开串口接收时会发现,我们在键盘上输入一个按键,会进入到串口中断,也就是说SecureCRT是通过当前界面进行发送与接收数据。

这里可以做一个测试,使用串口发送回显的代码进行操作,正常使用其他工具可能是下图这样
在这里插入图片描述
原理很简单,串口接收到数据,并打印数据

// 串口中断服务函数
void DEBUG_USART_IRQHandler(void)
{
  uint8_t ucTemp;
	if(USART_GetITStatus(DEBUG_USARTx,USART_IT_RXNE)!=RESET)
	{		
		ucTemp = USART_ReceiveData(DEBUG_USARTx);
		USART_SendData(DEBUG_USARTx,ucTemp);    
	}	 
}

测试使用SecureCRT测试,在键盘上敲击的按键可以被打印出来,也就是说SecureCRT可以将输入到该窗口的按键数据直接通过串口发送到接收设备,stm32或者其他设备接收到数据后,将接收到的数据打印出来,也就是说,我们所看到的下图的数据并不是键盘直接输入到该窗口的,而是单片机发送的数据。SecureCRT的这个属性为下面的shell代码书写定义出一个场景。
在这里插入图片描述

重新定义串口中断,如下所示,关于串口的DMA可以不管,shell没有使用

//串口1接收中断
void USART1_IRQHandler(void)
{
	u8 num=0;     
	if(USART_GetITStatus(USART1,USART_IT_IDLE) == SET)//空闲中断
	{
		num = USART1->SR;
		num = USART1->DR;
		DMA_Cmd(DMA1_Channel5,DISABLE);
		num = U1_BUFFER_LEN - DMA_GetCurrDataCounter(DMA1_Channel5);
		u1_RxBuffer[num] = 0;
		DMA1_Channel5->CNDTR=U1_BUFFER_LEN;
		DMA_Cmd(DMA1_Channel5,ENABLE);
		u1_flag = num;
	} 
	else if(USART_GetITStatus(USART1,USART_IT_RXNE) == RESET)//接收中断
	{
		char ch;
		ch = USART_ReceiveData(USART1);
		Termial_get_str(&ch);
	} 
} 

到这里我的想法是做一个轻量级的shell调试与测试的工具,而不是复杂的shell,基于此目标,并不做太多的兼容性设计。

当获取到一个字符串时,直接进入Termial_get_str()进行数据解析。贴出解析代码,这也是此文中的精髓部分,但也没有什么技术含量

char buf[256] = {0};		// 用来暂存用户输入的命令
char *p_Move = buf;

void Termial_get_str(char* ch)
{
	switch(*ch)
	{
		case 0x03:{/*CTRL C*/
			DP_input =0;
		}
		case 0x0D:{/*换行*/
			parse_line(buf);	/*命令解析*/
			find_run_cmd();		/*查找命令*/
		
			Usart_SendString(USART1,"\r\n");
			Usart_SendString(USART1,"shell:~$ ");
			
			memset(buf, 0, sizeof(buf));
			p_Move = buf;
			break;
		}
		case 0x08:{
			if (p_Move > buf)
			{
				Usart_SendByte(USART1,0x08);
				Usart_SendString(USART1," ");
				Usart_SendByte(USART1,0x08);
			
				p_Move--;								// 退一格,指针指向了要删除的那个格子
				*p_Move = '\0';					// 填充'\0'以替换要删除的那个字符
			}
			break;			
		}
		default:{
			USART_SendData(USART1,*ch);				// 回显
			*p_Move++ = *ch;							// 存储ch,等效于 *p = ch; p++;
			break;
		}
	}
}

键值:0x03 CTRL + C
键值:0x0D 换行
键值:0x08 Backspace
键值:其余 正常输出

0x03是按键上CTRL + C的键值,当接收到数据等于0x03时,进行对数据的标志位清除,通过宏定义的方式进行打印输出有一定的效果,例如

#define DEBUG(fmt,arg...)          do{\
                                   if(DP_input)\
                                   printf("[ DEBUG ] [%d]"fmt"\r\n",__LINE__, ##arg);\
                                   }while(0)

Backspace原理与上面相同,如果觉得不够直观,可以通过使用keil的Debug直接查看数位的数据进行验证。

当接收到换行,进行一次命令的解析,并将shell的命令行重新刷新一次。

case 0x0D:{/*换行*/
			parse_line(buf);	/*命令解析*/
			find_run_cmd();		/*查找命令*/
		
			Usart_SendString(USART1,"\r\n");
			Usart_SendString(USART1,"shell:~$ ");
			
			memset(buf, 0, sizeof(buf));
			p_Move = buf;
			break;
		}

获取的用户输入的数据后,由Termial_get_str可知,数据是保存在buf中,接收到换行,定义为用户输入一个命令。获取到命令后,需要对一个长的字符串进行分解,原理是通过空格进行分解,如下是拆解函数,调试回显函数可以不要

void parse_line(char* buf)
{
	int count = 0;
	
	char *p = strtok(buf," ");
	while(p)  //遍历输出
	{       
		argv[count] = p;
		p = strtok(NULL," ");  //指向下一个
		count++;
		if(count >= ARGC_MAX)//最多接收10个
		{
			break;
		}
	}
	argc = count;
	
#if 0
	/**********调试回显区间**********/
	if(count != 0)
	{
		msg("\r\nargc = %d",argc);
	}
	
	for (int i = 0; i<count; i++)
	{
		msg("\r\nargv[%d] = %s",i,argv[i]);
	}
	/**********调试回显区间**********/
#endif	

}

到这里,用户输入的数据已经分别保存到argv中,最后对字符串进行解析就可以执行对应的动作了

int find_run_cmd(void)
{
	struct node *pos;
	int find_cmd = 0;


	list_for_each_entry(pos,&Head,list)
	{
		if(strcmp(pos->name,argv[0]) == 0) /* '\0'的ascii码是0 */
		{
			pos->run_command();//执行命令	
			find_cmd = 1;					
		}
	}

	if( *(argv[0]) != 0 && *(argv[0]) != 0x20 && find_cmd == 0)
	{
		msg(\r\nunknown command: "%s" \r\n,argv[0]);
	}
	
	return 1;
}

pos->run_command();//执行命令
这里对应的是文章开头的do_helpdo_leds等的这些执行函数

演示一个打印功能,比较直观,逻辑比较简单

static create_list(board,"     echo slot board type",1,do_board);
list_add_tail(&(board.list),&Head);

在初始化时定义`board`命令,下面是 do_board函数

msg(\r\n\r\n);
msg(" _____  _____    ____   ____          _____  _____  "\r\n);
msg("|  __ \|  __ \  |  _ \ / __ \   /\   |  __ \|  __ \ "\r\n);
msg("| |  | | |__) | | |_) | |  | | /  \  | |__) | |  | |"\r\n);
msg("| |  | |  ___/  |  _ <| |  | |/ /\ \ |  _  /| |  | |"\r\n);
msg("| |__| | |      | |_) | |__| / ____ \| | \ \| |__| |"\r\n);
msg("|_____/|_|      |____/ \____/_/    \_\_|  \_\_____/ "\r\n);
msg("____________________________________________________"\r\n);
msg("[ DP App Version: 1.2.0 ] -- [ DATE: %s ] -- [ TIME: %s ]"\r\n,__DATE__,__TIME__);

在这里插入图片描述
后续也会有补充说明,有什么疑问也可以在下方留言。

最后同时分享一份简易的shell代码,解压即用,芯片用的stm32f103c8t6
https://download.csdn.net/download/weixin_44748127/45073339

  • 6
    点赞
  • 33
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
内置 "cmd-list" 命令获取所有命令列表 支持 tab 键补全命令 支持 backspace 回退,这个在 putty 上有 bug ,还没修复。在secureCRT正常。 支持上下箭头回溯历史,这个功能没有做的很好; 支持左右箭头编辑当前命令行输入; 提供 shell_cmdparam()函数转换命令后所跟的数字参数(字符串转整型),详见 demo 提供 shell_option_suport() 函数,使命令行支持 getopt()函数,详见 demo 系统共有9个文件,全部与硬件无关,编译语言要在 C99 以上(keil 在 project -> Options .. -> c/c++ -> C99 勾上) kernel.h // 一些必要的宏定义 shell.c,shell.h //具体的命令行解释的实现 ustdio.c,ustdio.h //非标准输出文件,重新链接 printf ,并提供一个小巧型的 printk 函数 avltree.c,avltree.h //平衡二叉树支持,shell 默认用链表建立查询机制,有必要可在shell.h 中开启二叉树 getopt.c,getopt.h //网上找的 getopt() 源码 除了 getopt.c,getopt.h 两个文件是我从网上找的源码,主要实现命令行的 getopt()解析,其他的都是笔者所写。 使用: 1,首先把 shell.c ustdio.c 加入工程,这两个文件是必须的。 如果不用 getopt()函数可以不添加getopt.c文件。 shell默认使用链表来构建查询系统,但也提供了平衡二叉树的方式,在shell.h中有开启的开关,如不需要可以不添加avltree.c。 include "shell.h" 2,先对硬件进行基本的初始化。 撰写串口发送函数,形如 void usart_puts(char * str , uint16_t len) ; 调用函数 shell_init("shell >",usart_puts); //初始化shell的输入标志和默认输出指向 串口接收以包为单位。 3,新建全局变量 struct shell_input serial_shell ; 并初始化 SHELL_INPUT_INIT(&serial;_shell ,usart_puts);初始化输入缓存和输出交互; 4,串口接收到一整包函数后,调用 shell_input(&serial;_shell , packet , pktlen) ;
### 回答1: STM32H7是一种高性能微控制器,具有丰富的处理能力和存储空间。实现视频压缩需要使用专业的图像处理算法,如JPEG、H.264等。 如果您想使用STM32H7实现视频压缩,您需要: 1. 学习图像处理和视频压缩的相关知识。 2. 了解STM32H7的处理能力和存储空间,并选择合适的算法。 3. 编写程序,使用STM32H7的处理器和存储空间实现视频压缩。 4. 在硬件上进行测试,并评估系统的性能。 如果您不熟悉图像处理和视频压缩的相关知识,建议您先学习相关课程,再尝试实现视频压缩。 ### 回答2: 基于STM32H7实现视频压缩需要以下步骤: 1. 硬件准备:选取合适的STM32H7系列芯片,具备足够的处理性能和存储容量来处理视频数据。同时需要添加外部存储器,如SD卡或外部SRAM,以存储压缩后的视频数据。 2. 视频数据输入:连接视频输入设备(如摄像头或其他视频源),将视频数据输入到STM32H7芯片。 3. 视频压缩算法选择:选择合适的视频压缩算法,常用的包括H.264、H.265等。根据芯片性能和存储容量的限制,确定可以实现的压缩比例。 4. 数据处理和压缩:通过STM32H7的高性能处理器,对视频数据进行预处理、压缩编码和解码等操作。压缩算法会将视频数据转换为更小的数据量,以减少存储和传输的需求。 5. 压缩数据存储:使用外部存储器将压缩后的视频数据存储下来,以便后续使用或传输。如果需要实时压缩和传输视频,可以考虑使用网络传输或其他实时通信方式。 6. 解压缩和数据传输:如果需要对压缩后的视频进行解码和播放,将压缩数据从外部存储器读取出来,进行解码处理,然后传输到显示设备(如LCD显示屏)进行播放。 需要注意的是,实现视频压缩需要较高的计算性能和存储容量,因此可能需要选择适当的STM32H7系列芯片,并进行性能和存储容量的优化。同时,还需要了解视频压缩算法的原理和工作流程,以便合理选择和实现算法。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

腿毛都能控

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值