• 基于stm32的shell实现

    首先
    思考一下，想要和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


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134

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

    
//定义一个函数指针类型
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) }



    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25

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

    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);
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43

    在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);    
	}	 
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    测试使用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);
	} 
} 

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    到这里我的想法是做一个轻量级的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;
		}
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40

    键值：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)

    • 1
    • 2
    • 3
    • 4

    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;
		}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    获取的用户输入的数据后，由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	

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32

    到这里，用户输入的数据已经分别保存到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;
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23

    pos->run_command();//执行命令
    这里对应的是文章开头的do_help、do_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__);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

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

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

  • 相关阅读:
    二进制部署Docker
    阿里云服务器快照收费怎么停止？
    java毕业设计—— 基于java+JSP+SSH的婴幼儿产品销售系统设计与实现（毕业论文+程序源码）——婴幼儿产品销售系统
    基础算法篇——归并排序
    柔顺机构学读书笔记1：悬臂梁变形
    ZYNQ--MIG核配置
    Windows下Java程序自启动
    JAVA自定义注解
    netstat 竟然还能这么玩儿？
    【计算机网络】HTTPS协议详解
  • 原文地址：https://blog.csdn.net/weixin_44748127/article/details/126028463