我的博客

数据结构与算法-03-链表

2023-07-17T05:36:16.000Z

链表

线性表的链式储存结构

有很多个结点，每个结点都有一个指针头，左后一个结点的指针为空，通常设置为null或者^表示，第一个结点称作为头结点

头指针	头结点
头指针是指链表指向第一个结点的指针，若链表有头结点，则指向头结点的指针	头结点是为了操作的统一和方便而设立的，放在第一元素的结点之前，其数据域一般无意义(也可以存放链表的长度)
头指针具有标识作用，所以常用头指针冠以链表的名字	有了头结点，在对第一元素结点前插入结点和删除第一结点，其操作与其他结点的操作就统一了
无论链表是否为空，头指针均不为空，头指针是链表的必要元素	头结点不一定是链表必须要素

单链表

空链表

链表结构

typedef struct Node{
	ElemType data;	//数据域
	struct Node *Next;	//指针域
}Node;
typedef struct Node *LinkList;

(1) 获取当前元素

初始条件：顺序线性表*L*存在，*1<=i<=ListLength(L)*，操作结果：用*e*返回*L*中第*i*个元素的值

Status GetElem(LinkList L, int i, ElemType *e)
{
	int j;
	LinkList p;
	p=L->next;
	j=1;
	while(p && j<i)			//若p不是尾节点，则将p的节点变为下一个元素，直到j=i-1，此时指针变为第i元素的地址
	{
		p = p->next;
		++j;
	}
	if(!p || j>i)			//若p是尾节点，或者j越界
	{
		return ERROR;
	}
	*e = p->data;			//获取第i地址的data数据
	return OK;
}

从头开始找，直到第个元素为止由于这个算法的时间复杂度取决于1的位置，当i=1时，则不需要遍历，而i=n时则遍历n-1次可以因此最坏情况的时间复杂度为O(n)。

(2) 链表插入

需要先把需要插入的数据的头指向原来的后一位，然后再将原来的前一位指向插入的数据的内容，否则操作相反会导致后一位没有上级

1
2
3

//正确的插入方式
s->next=p->next;
p->next=s;

初始条件：顺序线性表*L*已存在，*1<=i<=ListLength(L)*操作结果：在*L*中第*i*个位置之前插入新的数据元素*e*，*L*的长度加*1*

Status ListInsert(LinkList *L, int i, ElemType e)
{
	int j;
	LinkList p, s;
	p = *L;
	j=1;

	while(p && j<i)			//寻找第i个节点
	{
		p = p->next;
		++j;
	}
	if(!p || j>i)
	{
		return ERROR;
	}
	//动态分配一个内存给新创建需要插入的s
	s = (LinkList)malloc(sizeof(Node));
	s->data = e;
	s->next = p->next;
	p->next = s;
	return OK;
}

(3) 链表删除

初始条件：顺序线性表*L*已存在，*1<=i<=ListLength(L)*操作结果：删除在*L*中第*i*个位置的数据元素，并用*e*返回值，*L*的长度减*1*

Status ListDelete(LinkList *L, int i, ElemType *e)
{
	int j;
	LinkList p, q;
	p = *L;
	j = 1;
	while(p->next && j<i)
	{
		p = p->next;
		++j;
	}
	if(!(p->next) || j>i)
	{
		return ERROR;
	}
	q = p->next;
	p->next = q->next;

	*e = q->data;
	free(q);
	return OK;
}

时间复杂度为O(n)，对于插入或删除数据越频繁的操作，单链表的效率优势就越是明显

OLED-快速上手

2023-07-13T18:09:10.000Z

OLED

常见的OLED显示屏，0.96寸，128*64

通用流程

开启显示（进入工作模式）
关闭显示（进入睡眠模式）
设置复用率
设置列引脚硬件配置
设置显示时钟分频值/振荡频率（刷新率）
设置预充电周期
设置VCOMH反压值
设置电荷泵开启
屏幕控制指令，反色、镜像反转、滚动、淡出、闪烁等动画效果

设置坐标位置

//指定操作的像素坐标
/*
	X:0-127
	y:0-7
*/
void OLED_Set_Pos(uint8_t x, uint8_t y)
{
	OLED_WriteCommand(0xB0+y);
	OLED_WriteCommand(((x&0xf0)>>4)|0x10);
	OLED_WriteCommand((x&0x0f));
}

根据不同大小字体显示

//在指定位置显示一个字符,包括部分字符
//x:0~127
//y:0~63
//mode:0,反白显示;1,正常显示				 
//size:选择字体 16/12 
void OLED_ShowChar_Pos(uint8_t x,uint8_t y,uint8_t chr,uint8_t SIZE)
{    
	unsigned char c=0,i=0;
	c=chr-' ';//得到偏移后的值			
	if(x>Max_Column-1){x=0;y=y+2;}
	if(SIZE ==16)
	{
		OLED_Set_Pos(x,y);
		for(i=0;i<8;i++)
		OLED_WriteData((uint8_t)F8X16[c*16+i]);
		OLED_Set_Pos(x,y+1);
		for(i=0;i<8;i++)
		OLED_WriteData((uint8_t)F8X16[c*16+i+8]);
	}
	else 
	{
		OLED_Set_Pos(x,y+1);
		for(i=0;i<6;i++)
		OLED_WriteData((uint8_t)F6x8[c][i]);
		
	}
}

直接绘图

/***********功能描述：显示显示BMP图片128×64起始点坐标(x,y),x的范围0～127，y为页的范围0～7*****************/
void OLED_DrawBMP(uint8_t  x0, uint8_t  y0,uint8_t  x1, uint8_t  y1,uint8_t BMP[])
{ 
	unsigned int j=0;
 	unsigned char x,y;
  
	for(y=y0;y<y1;y++)
	{
		OLED_Set_Pos(x0,y);
		for(x=x0;x<x1;x++)
		{    
			OLED_WriteData(BMP[j++]);	  
		}
	}
}

谷歌恐龙字库

const uint8_t pic1[] = {
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,0xC0,0xF8,
0xF8,0xFE,0xFF,0xFF,0xFF,0x3F,0x3F,0x0F,0xCF,0xCF, 0x0F,0xCF, 0xCF, 0x0F, 0xCF,
0xFF,0xF8,0x78,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,0x80,0x80,0x80,0x00,0x00,
0x00,0x00,0x00,0x80,0x80,0x00,0x83,0xC7,0xEF,0xDF,0x7F,0xFF,0x71,0xC1,0x88,0x88,
0xB8,0xB9,0xB9,0xB8,0x99,0x99,0xC0,0xFF,0xFF,0xC0,0xC0,0xC0,0xC0, 0xC0,0xC0,0xC0,
0xC0,0x00,0x00,0x03,0x0F,0x1F,0x1E,0xFE,0xFE,0xEE,0x36,0x9B,0x4F,0xF7,0xE2,0x71,
0xBF,0x5D,0xFC,0xFB,0xE2,0x63,0x7F,0x61,0x61,0x61,0x7F,0x61,0xFF,0xFF,0x6F,0x63,
0x77,0x73,0x1F,0x1F,0x01,0x01,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x03,0x03,0x03,0x03,0xC5,0xEA,0xBD,0xAA,0xBD,0xAE,0xAB,0xBB,0xE7,0xC4,0x07,
0x04,0xE7,0xE4,0xBF,0xAB,0xBB,0xAC,0xA8,0xB8,0xE0,0xE0,0x00,0x00,0x00,0x00,0x00,0x00,
};

动画效果

使用绘图加上延时实现

FreeRTOS-10-CPU利用率

2023-07-12T16:33:47.000Z

CPU利用率

CPU利用率需要控制在一个较好的范围，能够完美响应紧急的事件

开启宏定义portCONFIGURE_TIMER_FOR_RUN_TIME_STATS 1、portGET_RUN_TIME_COUNTER_VALUE 1

创建CPU利用率监控

开启宏定义

//启用运行时间统计功能
#define configGENERATE_RUN_TIME_STATS                      1
//启用可视化跟踪调试
#define configUSE_TRACE_FACILITY                           1
/* 与宏 configUSE_TRACE_FACILITY 同时为 1 时会编译下面 3 个函数
* prvWriteNameToBuffer()
* vTaskList(),
* vTaskGetRunTimeStats()
*/
#define configUSE_STATS_FORMATTING_FUNCTIONS               1
extern volatile uint32_t CPU_RunTime;
#define portCONFIGURE_TIMER_FOR_RUN_TIME_STATS() (CPU_RunTime = 0ul)
#define portGET_RUN_TIME_COUNTER_VALUE() CPU_RunTime

创建一个引用，并不是创建一个真实的句柄

//CPU利用率
static TaskHandle_t LED0_Task_Handle=NULL;
static TaskHandle_t LED4_Task_Handle=NULL;
static TaskHandle_t CPU_Task_Handle=NULL;

开启定时中断服务

/* 用于统计运行时间 */
volatile uint32_t CPU_RunTime = 0UL;
void BASIC_TIM_IRQHandler (void)
{
	if ( TIM_GetITStatus( BASIC_TIM, TIM_IT_Update) != RESET ) {
	CPU_RunTime++;
	TIM_ClearITPendingBit(BASIC_TIM , TIM_FLAG_Update);
	}
}

创建LED0任务

static void LED0_Task(void *paramter)
{
	while(1)
	{
		LEDA_ON(GPIO_Pin_0);
		vTaskDelay(500);
		printf("led0_task running,LED0_ON\r\n");
		LEDA_OFF(GPIO_Pin_0);
		vTaskDelay(500);
		printf("led0_task running,LED0_OFF\r\n");
	}
}

创建LED4任务

static void LED4_Task(void *paramter)
{
	while(1)
	{
		LEDA_ON(GPIO_Pin_4);
		vTaskDelay(300);
		printf("led4_task running,LED4_ON\r\n");
		LEDA_OFF(GPIO_Pin_4);
		vTaskDelay(300);
		printf("led4_task running,LED4_OFF\r\n");
	}
}

创建CPU任务

static void CPU_Task(void *paramter)
{
	uint8_t CPU_RunInfo[400];				//保存运行时间信息
	while (1)
	{
		memset(CPU_RunInfo,0,400);			//缓冲区清零
		vTaskList((char *)&CPU_RunInfo);		//获取运行时间信息
		printf("-----------------------\r\n");
		printf("任务名 任务状态 优先级 剩余栈 任务序号\r\n");
		printf("%s", CPU_RunInfo);
		printf("---------------------------------------------\r\n");

		memset(CPU_RunInfo,0,400);			//信息缓冲区清零
		vTaskGetRunTimeStats((char *)&CPU_RunInfo);

		printf("任务名 运行计数 使用率\r\n");
		printf("%s", CPU_RunInfo);
		printf("---------------------------------------------\r\n\n");
		vTaskDelay(1000);
	}

}

需要注意的是定时中断服务要选用TIM1或者TIM2

FreeRTOS-09-中断管理

2023-07-12T06:10:36.000Z

中断管理

异常：同步异常和异步异常

同步异常：内部事件，处理器指令产生的事件。由内部产生
异步异常：被零除算术运算，读写异常等。由外部硬件装置

中断管理：

支持开关中断
支持恢复中断
支持使能
支持屏蔽
支持可选系统管理的中断优先级

中断种类：外设、中断控制器、CPU本身

中断名词

中断号：特定标志
中断请求：紧急事件需向CPU提出请求，这一过程称为中断请求
中断优先级：将中断源分为若干个级别，不能级别有不同的优先级
中断处理程序：外设产生中断请求后，CPU暂停当前任务，响应中断申请执行中断程序
中断触发：中断源给CPU发信号，将中断触发器置1
中断触发类型：外部中断申请通过物理信号发送到NVIC，可以是电平触发或边沿触发
中断向量：中断服务程序的入口程序
中断向量表：存储中断向量的区域，与中断号对应
临界段：也成为临界区，其中的代码开始执行，则不允许中断打断

硬件实时中不能出现中断嵌套，但是RTOS等软件实时中可以出现中断嵌套。

中断延迟

中断延迟是指中断发生到开始执行中断处理程序第一条指令的时间

FreeRTOS-08-内存管理

2023-07-11T17:42:21.000Z

内存管理

内存通常分为两种：内部存储空间（RAM）和外部存储空间（硬盘）

避免使用C语言标准库的malloc和free内存函数

嵌入式RAM可能不足，函数并不总是可用
实现可能很大，占用很大的代码空间
几乎不安全
调用时间不确定，每次可能都不一样
可能产生碎片
会使链接器配置复杂
如果允许堆空间的生长方向覆盖其他变量占据的内存，会成为debug的灾难

内存管理应用场景

void *pvPortMalloc(size_t xSize)申请内存
void vPortFree(void *pv)释放内存
void vPortInitialiseBlocks(void)初始化内存堆
size_t xPortGetFreeHeapSize(void)获取当前未分配的内存堆大小
size_t xPortGetMinimumEverFreeHeapSize(void)获取未分配的内存堆历史最小值
heap_1.c、heap_2.c、heap_4.c内存堆是一个很大的数组
heap_3.c是使用C语言原生的malloc和free函数，但是进行的安全保护的封装，需要用户通过编译器或者启动文件设置空间
heap_5.c允许用户使用多个非连续的内存堆空间，同时可以使用外部SDRAM、内存卡等

heap_1

用于从不删除任务、队列、信号量、互斥量等应用程序
函数执行时间是确定并且不会产生内存碎片
不支持释放内存

heap_2

和heap_1的内存管理算法不同，采用最佳匹配算法，支持释放内存不能将相邻的小碎片内存合并为大内存
可用于反复删除任务、队列、信号量、互斥量等内核对象且不担心内存碎片的应用程序
若存在一些碎片化的任务，那么可能导致内存碎片
具有不确定性，但是比C语言原生的malloc高级
不能用于内存分配和释放是随机大小的应用程序

heap_3

简单封装C语言的malloc和free，满足常用的编译器，具有保护功能
需要链接器设置一个堆，malloc和free由编译器提供
具有不确定性
很可能增大RTOS内核代码大小
configTOTAL_HEAP_SIZE宏定义不起作用

heap_4

在heap_2的基础上加上了合并算法，能将相邻空闲内存合并为1个更大的块
可用于重复删除任务、队列、信号量、互斥量等的应用程序
可用于分配和释放随机字节内存的应用程序，但并不像heap_2那样产生严重的内存碎片
具有不确定性，但是效率比C语言原生的malloc函数高

heap_5

动态分配和heap_4是一样，采用最佳匹配和合并算法，并且允许内存跨多个非连续内存区
需要使用vPortDefineHeapRegions()来实现内存初始化

创建内存管理

内存管理句柄，创建一个引用，并不是创建一个真实的内存管理

//内存管理
static TaskHandle_t Test_Task_Handle=NULL;

uint8_t *Test_Ptr=NULL;

Test任务

//内存管理
static void Test_Task(void *paramter)
{
	uint32_t g_memsize;
	while (1)
	{
		if (Key_BTN(BTN1)==KEY_ON)
		{
			if (Test_Ptr==NULL)
			{
				//获取当前内存大小
				g_memsize=xPortGetFreeHeapSize();
				printf("系统当前内存大小为%d字节，开始申请内存\r\n",g_memsize);
				Test_Ptr = pvPortMalloc(1024);
				if (Test_Ptr!=NULL)
				{
					printf("内存申请成功\r\n");
					printf("申请到的内存地址为%#x\r\n",(int)Test_Ptr);
					// 当前剩余内存大小
					g_memsize = xPortGetFreeHeapSize();
					printf("系统当前内存剩余大小为%d字节\r\n",g_memsize);

					sprintf((char*)Test_Ptr,"当前系统TickCount=%d\r\n",xTaskGetTickCount);
					printf("写入数据是%s\r\n",(char*)Test_Ptr);
				}else
				{
					printf("按下Key2释放内存然后申请\r\n");
				}
			}
		}
		if (Key_BTN(BTN2)==KEY_ON)
		{
			if (Test_Ptr!=NULL)
			{
				printf("释放内存\r\n");
				vPortFree(Test_Ptr);
				Test_Ptr=NULL;
				// 获取当前剩余内存
				g_memsize = xPortGetFreeHeapSize();
				printf("系统当前内存剩余大小为%d字节\r\n",g_memsize);
			}else
			{
				printf("按下Key1申请内存再释放\r\n");
			}
	
		}
		vTaskDelay(20);
	}
}

按下BTN1申请内存，并将系统当前TickCount打印，按下BTN2释放内存

FreeRTOS-07-任务通知

2023-07-07T00:17:19.000Z

任务通知

任务通知是一种任务间通信的手段，比使用信号量更节省资源，解除阻塞时间更快

无需创建队列
更节省RAM空间
发送通知任务几种模式：通知未读，不覆盖通知值；直接覆盖通知值；设置通知位的一个或多位，当作事件组；递增通知值，当做计数信号量。
由于必须指定接收通知的任务，只能有一个任务接收通知。
只有等待通知的任务可以被阻塞，发送通知的任务不会因为发送失败进入阻塞态。

任务通知运行机制

1 2	//开启任务通知功能，默认开启 #define configUSE_TASK_NOTIFICATIONS 1

随任务创建而初始化
任务通知和队列消息的运行机制一致

任务通知常见函数

xTaskGenericNotify()发送任务通知，是任务通知的原型
xTaskNotifyGive()调用任务通知，并将任务通知值加1，可以作为二值信号量和计数信号量的低配版，更加轻量化，原型xTaskNotify()
xTaskNotifyGiveFromISR()中断调用任务通知
xTaskNotify()用于任务直接向另一个任务发送一个事件
xTaskNotifyFromISR() 中断中使用，原型为xTaskGenericNotifyFromISR()
xTaskGenericNotifyFromISR()通用中断发送任务通知
xTaskNotifyAndQuery()和xTaskNotify()功能类似，附加了回传接收任务的通知值，若不需要回传则等同于xTaskNotify()
xTaskNotifyAndQueryFromISR()中断用
ulTaskNotifyTake()可作为轻量级获取二值信号量和计数信号量的实现，用于自身句柄的调用
xTaskNotifyWait()可以用于实现全功能的等待任务通知，更轻量化

代替消息队列

设计3个任务，2个任务接收消息通知来控制LED，1个任务通过2个按钮来发送消息通知

接收、发送通知句柄，创建一个引用，并不是创建一个真实的消息通知

//任务通知句柄
static TaskHandle_t Receive1_Task_Handle = NULL;
static TaskHandle_t Receive2_Task_Handle = NULL;
static TaskHandle_t Send_Task_Handle = NULL;

#define USE_CHAR 0 					//测试字符串配置1，测试变量配置0

创建一个真实的句柄

//Receive1_Task任务
xReturn =xTaskCreate(Receive1_Task,"Receive1_Task",512,NULL,2,(TaskHandle_t *)&Receive1_Task_Handle);
if (xReturn==pdPASS)
{
	printf("创建Receive1_Task任务成功\r\n");
}

//Receive2_Task任务
xReturn = xTaskCreate(Receive2_Task,"Receive2_Task",512,NULL,3,(TaskHandle_t *)&Receive2_Task_Handle);
if (xReturn==pdPASS)
{
	printf("创建Receive2_Task任务成功\r\n");
}

//Receive2_Task任务
xReturn = xTaskCreate(Send_Task,"Send_Task",512,NULL,4,(TaskHandle_t *)&Send_Task_Handle);
if (xReturn==pdPASS)
{
	printf("创建Send_Task任务成功\r\n");
}

接收通知任务1

static void Receive1_Task(void *paramter)
{
	BaseType_t xReturn = pdTRUE;
#if USE_CHAR
	char *r_char;
#else
	uint32_t r_num;
#endif
	while (1)
	{
		//获取任务通知，没获取到则等待
		xReturn = xTaskNotifyWait(0x0,			//进入函数的时候不清除任务Bit
					ULONG_MAX,		//退出函数的时候清除所以的Bit
#if USE_CHAR
					(uint32_t *)&r_char,	//保存任务通知值
#else
					&r_num,			//保存任务通知值
#endif
					portMAX_DELAY);		//阻塞时间
		if(xReturn==pdTRUE)
#if USE_CHAR
			printf("Receive1_Task 任务通知%s \r\n",r_char);
#else
			printf("Receive1_Task 任务通知%d \r\n",r_num);
#endif
		LED0_Turn();
	}
}

接收通知任务2

static void Receive2_Task(void *paramter)
{
	BaseType_t xReturn = pdTRUE;
#if USE_CHAR
	char *r_char;
#else
	uint32_t r_num;
#endif
	while (1)
	{
		//获取任务通知，没获取到则一直等待
		xReturn = xTaskNotifyWait(0x0,
					ULONG_MAX,
#if USE_CHAR
					(uint32_t *)&r_char,
#else
					&r_num,
#endif
					portMAX_DELAY);

		if(xReturn == pdTRUE)
		{
#if USE_CHAR
			printf("Receive2_Task 任务通知%s \r\n",r_char);
#else
			printf("Receive2_Task 任务通知%d \r\n",r_num);
#endif
		LED7_Turn();
		}
	}
}

发送通知任务

static void Send_Task(void *paramter)
{
	BaseType_t xReturn=pdTRUE;
#if USE_CHAR
	char test_str1[]="this is mail test 1";			//消息1
	char test_str1[]="this is mail test 2";			//消息2
#else
	uint32_t send1=1;
	uint32_t send2=2;
#endif
	while (1)
	{
		//KEY1按下
		if (Key_BTN(BTN1)==KEY_ON)
		{
			xReturn = xTaskNotify(Receive1_Task_Handle,	//任务句柄
#if USE_CHAR
					(uint32_t)&test_str1,		//发送数据，最大4字节
#else
					send1,				//发送数据，最大4字节
#endif
					eSetValueWithOverwrite);	//覆盖当前通知

			if(xReturn==pdTRUE)
			{
				printf("Receive1_Task_Handle 任务通知释放成功\r\n");
			}
		}

		//KEY2按下
		if (Key_BTN(BTN2)==KEY_ON)
		{
			xReturn = xTaskNotify(Receive2_Task_Handle,
#if USE_CHAR
					(uint32_t)&test_str2,
#else
					send2,
#endif
					eSetValueWithOverwrite);
			if (xReturn==pdTRUE)
			{
				printf("Receive2_Task_Handle 任务通知释放成功\r\n");
			}
		}
		vTaskDelay(20);
	}
}

按下BTN1后，通信接收任务1，LED0亮，按下BTN2后，通信接收任务2，LED7亮

代替二值信号量

设计3个任务，2个任务接收消息通知来控制LED，1个任务通过2个按钮来发送消息通知，按钮控制释放信号量句柄，注意ulTaskNotifyTake的使用，在自身句柄对应的Task中调用

前置和代替消息队列相同

接收通知任务1

static void Receive1_Task(void *paramter)
{
	while (1)
	{
		//获取任务通知，没有则一直等待
		ulTaskNotifyTake(pdTRUE,portMAX_DELAY);
		printf("Receive1_Task 任务通知获取成功\r\n");
		LED0_Turn();
	}
}

接收通知任务2

static void Receive2_Task(void *paramter)
{
	while (1)
	{
		ulTaskNotifyTake(pdTRUE,portMAX_DELAY);
		printf("Receive2_Task 任务通知获取成功\r\n");
		LED7_Turn();
	}
}

发送通知任务

static void Send_Task(void *paramter)
{
	BaseType_t xReturn=pdPASS;
	while (1)
	{
		if (Key_BTN(BTN1)==KEY_ON)
		{
			xReturn = xTaskNotifyGive(Receive1_Task_Handle);
			if (xReturn==pdTRUE)
			{
				printf("Receive1_Task 任务释放成功\r\n");
			}
		
		}
		if (Key_BTN(BTN2)==KEY_ON)
		{
			xReturn = xTaskNotifyGive(Receive2_Task_Handle);
			if (xReturn == pdTRUE)
			{
				printf("Receive2_Task 任务释放成功\r\n");
			}
		
		}
		vTaskDelay(20);
	}

}

按下BTN1后，通信接收任务1，LED0亮，按下BTN2后，通信接收任务2，LED7亮

代替计数信号量

创建2个任务，1个用于等待通知，申请车位。另一个用于释放信号量，释放车位。

接收、发送通知句柄，创建一个引用，并不是创建一个真实的消息通知

1
2
3

//任务通知-计数信号量替代
static TaskHandle_t Take_Task_Handle=NULL;
static TaskHandle_t Give_Task_Handle=NULL;

申请车位

static void Take_Task(void *paramter)
{
	uint32_t take_num=pdPASS;
	while (1)
	{
		if(Key_BTN(BTN1)==KEY_ON)
		{
			//没获取到，就一直等待
			take_num=ulTaskNotifyTake(pdFALSE,0);
			if (take_num>0)
			{
				printf("成功申请到车位，当前车位%d\r\n",take_num-1);
			}else
			{
				printf("KEY1按下，无多余车位。请按下KEY2释放车位\r\n");
			}
		}
	}
}

释放车位

static void Give_Task(void *paramter)
{
	BaseType_t xReturn = pdPASS;
	while (1)
	{
		if (Key_BTN(BTN2)==KEY_ON)
		{
			xReturn = xTaskNotifyGive(Take_Task_Handle);
			if (xReturn==pdPASS)
			{
				printf("KEY2按下，释放一个车位\r\n");
			}
	
		}
		vTaskDelay(20);

	}
}

按下KEY1，无车位；按下KEY22次释放2个车位，再按下KEY1申请2个车位

代替事件组

创建2个任务，一个任务用于监听事件，一个任务用于控制BTN1和BTN2来触发事件

事件组句柄，创建一个引用，并不是创建一个真实的事件组

//事件组代替
static TaskHandle_t LED7_Task_Handle=NULL;
static TaskHandle_t KEY_Task_Handle=NULL;

//事件句柄
static EventGroupHandle_t Event_Handle=NULL;

#define KEY1_EVENT (0x01 << 0)		//设置掩码的位0

创建一个真实的事件组

Event_Handle = xEventGroupCreate();
if (Event_Handle!=NULL)
{
	printf("事件组句柄创建成功\r\n");
}

LED灯任务

static void LED7_Task(void *paramter)
{
	uint32_t r_event=0;
	uint32_t last_event=0;
	BaseType_t xReturn=pdPASS;
	while(1)
	{
		xReturn = xTaskNotifyWait(0x0,				//进去函数不清除任务Bit
					ULONG_MAX,			//退出函数清除所有bit
					&r_event,			//保存任务通知值
					portMAX_DELAY);			//阻塞时间
		if (xReturn == pdPASS)
		{
			last_event |= r_event;
			if (last_event == (KEY1_EVENT|KEY2_EVENT))
			{
				last_event=0;
				printf("KEY1和KEY2都按下\r\n");
				LED7_Turn();
			}else
			{
				last_event=r_event;
			}
	
		}
	}
}

KEY任务

static void KEY_Task(void *paramter)
{
	while(1)
	{	
		if( Key_BTN(BTN1) == 0 )
		{/* K1 被按下 */
			printf("K1 被按下\r\n");
			xTaskNotify(LED7_Task_Handle,	//任务句柄
				KEY1_EVENT,		//需要触发的事件
				eSetBits);		//设置通知的值
		} 
		if( Key_BTN(BTN2) == 0  )
		{/* K2 被按下 */
			printf("K2 被按下\r\n");
			xTaskNotify(LED7_Task_Handle,
				KEY2_EVENT,
				eSetBits);
		}
		vTaskDelay(20);
	}
}

按下BTN1，设置事件1，按下BTN2，设置事件2，触发LED事件

FreeRTOS-06-软件定时器

2023-07-05T00:03:07.000Z

软件定时器

软件定时器是一种基于硬件定时器的资源利用手段，相当于扩展了定时器数量。

允许开启关闭软件定时
创建软件定时
启动软件定时
停止软件定时
复位软件定时
删除软件定时

软件定时运行机制

1
2
3

//开启宏定义
#define configUSE_TIMERS 1
#define configTIMER_QUEUE_LENGTH		        10

单次模式，定时完毕只执行一次回调
周期模式，定时完毕周期性执行回调

软件定时精度不如硬件定时，且容易被打断，用于一些辅助性任务
软件定时通信采用队列消息

软件回调应该快进快出，不能有阻塞行为，不允许死循环

定时器常见函数

xTimerCreate()创建一个定时器，返回句柄
xTimerStart()启动定时器
xTimerStartFromISR()中断启动定时器
xTimerStop()停止定时器
xTimerStopFromISR()中断停止定时器
xTimerDelete()删除定时器

创建定时器

创建2个定时器回调任务，其中一个周期1s定时任务，另一个5s单次任务

开启宏定义

//中断事件组
#define configUSE_TIMERS 1
#define INCLUDE_xTimerPendFunctionCall 0
//软件定时器队列长度
#define configTIMER_QUEUE_LENGTH		        10  
//软件定时器优先级
#define configTIMER_TASK_PRIORITY (configMAX_PRIORITIES-1)

定时器句柄，创建一个引用，并不是创建一个真实的定时器

//软件定时器句柄
static TimerHandle_t Swtmr1_Handle=NULL;
static TimerHandle_t Swtmr2_Handle=NULL;

static uint32_t TmrCb_Count1=0;		//记录定时器1回调函数执行次数
static uint32_t TmrCb_Count2=0;		//记录定时器2回调函数执行次数

创建真实的定时器1

//定时器句柄
	Swtmr1_Handle = xTimerCreate(
		(const char*)"AutoReloadTimer",		//定时器名称
		1000,					//定时器周期
		pdTRUE,					//周期模式
		(void *)1,				//为每个计时器分配索引唯一ID
		Swtmr1_Callback);			//回调函数

创建真实的定时器2

//定时器句柄
	Swtmr2_Handle = xTimerCreate(
		(const char*)"OneShotTimer",		//定时器名称
		5000,					//定时器周期
		pdFALSE,				//周期模式
		(void *)2,				//为每个计时器分配索引唯一ID
		Swtmr2_Callback);			//回调函数

定时器1回调函数

static void Swtmr1_Callback(void *paramter)
{
	TickType_t tick_num1;
	TmrCb_Count1++;		//每次回调自加1

	tick_num1=xTaskGetTickCount();		//获取滴答计时器计数值

	LED0_Turn();
	printf("swtmr1_callback回调函数执行次数%d\r\n",TmrCb_Count1);
	printf("滴答计时器计数值%d\r\n",tick_num1);

}

定时器2回调函数

static void Swtmr2_Callback(void *paramter)
{
	TickType_t tick_num2;
	TmrCb_Count2++;		//每次回调自加1

	tick_num2=xTaskGetTickCount();		//获取滴答计时器计数值

	// LED0_Turn();
	printf("swtmr2_callback回调函数执行次数%d\r\n",TmrCb_Count2);
	printf("滴答计时器计数值%d\r\n",tick_num2);

}

每过1s，定时器1运行一次，第5s，定时器2运行一次

FreeRTOS-05-事件

2023-07-04T05:53:11.000Z

事件

事件是一种任务间通信的技术，和信号量不同，可以实现一对多，多对多的通信，但是不涉及数据的传输。

configUSE_16_BIT_TICKS 开启后，uxEventBits为16位，8位存储事件组；未开启时，uxEventBits为32位，24位存储事件组。
事件只与任务相关联，事件之间彼此独立。
事件只同于同步，不涉及数据传输。
事件无队列消息性质，多次向同一任务发送事件，若未被读取，则视为一次事件。
支持事件等待超时机制。

事件运行机制

//中断事件组
#define configUSE_TIMERS 0
#define INCLUDE_xTimerPendFunctionCall 0
//软件定时器优先级
#define configTIMER_TASK_PRIORITY (configMAX_PRIORITIES-1)

事件接收成功后，需要使用xClearOnExit()来清除事件类型，否则不会清除已接收的事件，需要手动显示清除。
24位存储事件中，1表示事件已发生，0表示事件未发生

任务唤醒遵循事件的或与逻辑

事件常见函数

xEventGroupCreate()创建事件组，返回一个句柄
xEventGroupDelete()删除事件
xEventGroupSetBits()置位事件组中指定的位，置位后，阻塞该位的任务会被解锁。
xEventGroupSetBitsFromISR()中断置位事件组，需要开启configUSE_TIMERS 1和INCLUDE_xTimerPendFunctionCall 1宏定义
xEventGroupWaitBits()等待事件，获取事件标志位。
xEventGroupClearBits()清除事件组置位
xEventGroupClearBitsFromISR()中断清除事件组置位

创建事件

创建2个Btn任务控制LED任务，当只按下BTN1时，不亮，接着按下BTN2后，亮。此时相当于标志位变得和设定相同。

开启宏定义

//中断事件组
#define configUSE_TIMERS 0
#define INCLUDE_xTimerPendFunctionCall 0
//软件定时器优先级
#define configTIMER_TASK_PRIORITY (configMAX_PRIORITIES-1)

事件句柄，创建一个引用，并不是创建一个真实的事件

//事件句柄
static EventGroupHandle_t Event_Handle=NULL;

#define KEY1_EVENT (0x01 << 0)		//设置掩码的位0
#define KEY2_EVENT (0x01 << 1)		//设置掩码的位1

创建一个真实的事件

1 2	//创建事件句柄 Event_Handle = xEventGroupCreate();

LED任务

static void LED0_Event_Task(void *paramter)
{
	EventBits_t r_event;
	while (1)
	{
		r_event = xEventGroupWaitBits(
			Event_Handle,				//事件句柄
			KEY1_EVENT | KEY2_EVENT,		//接收感兴趣事件
			pdTRUE,					//退出时清除事件位
			pdTRUE,					//满足感兴趣的所有事件
			portMAX_DELAY);				//超时一直等待

		if (r_event & (KEY1_EVENT | KEY2_EVENT) == (KEY1_EVENT | KEY2_EVENT))
		{
			printf("KEY1和KEY2都按下\r\n");
			LED0_Turn();
		}else
		{
			printf("事件错误\r\n");
		}
	}
}

Key任务

static void KEY_Event_Task(void *paramter)
{
	while (1)
	{
		if(Key_BTN(BTN1)==KEY_ON)
		{
			printf("KEY1按下\r\n");
			xEventGroupSetBits(Event_Handle,KEY1_EVENT);
		}
		if (Key_BTN(BTN2)==KEY_ON)
		{
			printf("KEY2按下\r\n");
			xEventGroupSetBits(Event_Handle,KEY2_EVENT);
		}
		vTaskDelay(20);
	}

}

当BTN1和BTN2都按下后，才会翻转信号

FreeRTOS-04-信号量

2023-07-02T05:49:30.000Z

信号量

信号量类似于裸机开发中的标志位，用于任务间通信的变量，或者成为标志位。

临界资源：任何时刻只能被一个任务访问的资源

递归信号量和互斥量都实现继承优先级机制，降低优先级反转的危害

二值信号量运行机制

类似于互斥量，但是没有互斥量的优先级继承机制
偏向于同步功能，任务与任务的同步，任务与中断的同步
等效于一个只有一个消息的队列，只存在两种状态：有消息或者无消息
信号被获取时为0，被释放时为1
二值信号量无效时，有其他任务获取信号量，则任务进入阻塞态

某时刻信号量被中断或任务释放时，其他进入阻塞态的最高优先级任务进入就绪态

计数信号量运行机制

1
2
3

//使用计数信号量需要开启宏定义
//开启计数信号量
#define configUSE_COUNTING_SEMAPHORES   1

当事件发生时，信号量被释放，计数值加一
当事件被处理时，信号量被取走，计数值减一
信号计数值表示还未处理事件数量
使用完资源必须返还信号量，信号量为0时表示无资源可用
可用于资源管理，允许多个任务获取信号量进行资源访问，当访问个数到达最大时，其他任务进入阻塞态，直到有任务释放资源，类似于二值信号量访问资源的过程

互斥信号量运行机制

//使用互斥信号量需要开启宏定义
//开启互斥量
#define configUSE_MUTEXES 1
//开启递归互斥量
#define configUSE_RECURSIVE_MUTEXES 1

特殊的二值信号量，拥有优先级继承机制
信号量创建之初为满，使用临界资源时，先获取信号量使其为空，防止其他任务使用临界资源。
低优先级任务申请互斥量，高优先级任务申请不到进入阻塞态，低优先级任务临时继承高优先级的优先级。

适用于可能引发优先级翻转的场景
可递归使用，形成递归互斥量，任务可能会多次获取互斥量的情况下。这样可以避免同一任务多次递归持有而造成死锁的问题。
互斥量不能在中断使用，优先级继承只在普通任务中有效，同一时期只能有一个任务获取互斥量进行资源访问

递归信号量运行机制

获取递归信号量的任务可以重复获取该量，拥有该量的所有权
递归几次就要返还几次，有点类似任务的挂起和恢复之间的关系

信号常见函数

xSemaphoreCreateBinary()创建二值信号量，返回一个句柄，函数原型xQueueGenericCreate()
xSemaphoreCreateCounting()创建计数信号量，返回一个句柄，原型xQueueGenericCreate()
xSemaphoreGive()释放信号量，可用于二值信号量、互斥信号量、计数信号量的任务释放，不能用于递归信号量，原型xQueueGenericSend()
xSemaphoreGiveFromISR()用于中断的释放信号量，只能用于二值信号量、计数信号量，原型xQueueGiveFromISR()
xSemaphoreTake()获取信号量，可用于二值信号量、互斥信号量、计数信号量的任务获取，不能用于递归信号量，原型xQueueGenericReceive()，该操作类似任务访问队列消息的过程。
xSemaphoreTakeFromISR()，用于中断的获取信号量，只能用于二值信号量、计数信号量
xSemaphoreCreateMutex()创建互斥量，返回一个句柄，只能被同一个任务获取，再次获取会失败。原型xQueueCreateMutex()，原型的原型为xQueueGenericCreate()
prvInitialiseMutex()初始化互斥量
xSemaphoreCreateRecursiveMutex()创建递归互斥量，可以被同一个任务获取很多次，获取前先释放。原型xQueueCreateMutex()
xSemaphoreDelete()信号量删除
xSemaphoreTakeRecursive()获取递归互斥量，原型xQueueTakeMutexRecursive()，该函数不能获取由xSemaphoreCreateMutex()创建的互斥量
xSemaphoreGiveRecursive()释放递归互斥量，原型xQueueGiveMutexRecursive()

创建二值信号量

设计1个Button任务，通过按键发送控制LED0的开关，二值量操作信息通过串口显示

二值量句柄，创建一个引用，并不是创建一个真实的二值量

//创建一个二值信号量句柄
SemaphoreHandle_t Binary_Handle=NULL;
//发送和接收任务-信号量
static void Receive_Semaph_Task(void *paramter);
static void Send_Semaph_Task(void *paramter);

创建一个真实的二值量

1 2	//创建一个二值信号量 Binary_Handle = xSemaphoreCreateBinary();

接收数据任务控制LED0

static void Receive_Semaph_Task(void *paramter)
{
	BaseType_t xReturn=pdPASS;
	uint32_t r_queue;
	while (1)
	{
		//获取二值信号量
		xReturn = xSemaphoreTake(Binary_Handle,portMAX_DELAY);
		if(xReturn==pdPASS)
		{
			printf("二值信号量获取成功\r\n");
		}
		LED0_Turn();
	}
}

Button控制发送数据任务

static void Send_Semaph_Task(void *paramter)
{
	BaseType_t xReturn=pdTRUE;
	while (1)
	{
		if (Key_BTN(BTN1)==KEY_ON)
		{
			//先释放一下二值信号量
			xReturn = xSemaphoreGive(Binary_Handle);
			if (xReturn==pdTRUE)
			{
				printf("二值信号量释放成功\r\n");
			}else
			{
				printf("二值信号量释放失败\r\n");
			}
		}

		if (Key_BTN(BTN2)==KEY_ON)
		{
			//先释放一下二值信号量
			xReturn = xSemaphoreGive(Binary_Handle);
			if (xReturn==pdTRUE)
			{
				printf("二值信号量释放成功\r\n");
			}else
			{
				printf("二值信号量释放失败\r\n");
			}
		}
	
		vTaskDelay(20);
	
	}

}

创建计数二值量

设计2个Button任务，通过按键BTN1申请车位，按键BTN2释放车位，最大车位5

开启宏定义

1 2	//开启计数信号量 #define configUSE_COUNTING_SEMAPHORES 1

计数信号量句柄，创建一个引用，并不是创建一个真实的计数信号量

//创建一个计数信号量句柄
SemaphoreHandle_t CountSem_Handle=NULL;
//计数信号量-申请释放车位
static void Take_Task(void *paramter);
static void Give_Task(void *paramter);
//计数信号量-申请释放车位任务句柄
static TaskHandle_t Take_Task_Handle=NULL;
static TaskHandle_t Give_Task_Handle=NULL;

创建一个真实的计数信号量

1
2
3

//创建一个计数信号量
CountSem_Handle =xSemaphoreCreateCounting(5,	//最大车位5
					5);	//当前空闲车位5

BTN1控制申请车位

static void Take_Task(void *paramter)
{
	BaseType_t xReturn=pdTRUE;
	while (1)
	{
		if (Key_BTN(BTN1)==KEY_ON)
		{
			//获取计数信号量
			xReturn = xSemaphoreTake(CountSem_Handle,
						0);		//等待时间：0
			if (xReturn==pdTRUE)
			{
				printf("BTN1按下，申请车位成功\r\n");
			}else
			{
				printf("BTN1按下，车位已满，申请车位失败\r\n");
			}
		}
		vTaskDelay(20);

	}

}

BTN2释放车位

static void Give_Task(void *paramter)
{
	BaseType_t xReturn=pdTRUE;
	while (1)
	{
		if (Key_BTN(BTN2)==KEY_ON)
		{
			//获取计数信号量
			xReturn = xSemaphoreGive(CountSem_Handle);	
			if (xReturn==pdTRUE)
			{
				printf("BTN2按下，释放一个车位\r\n");
			}else
			{
				printf("BTN2按下，无车位可被释放\r\n");
			}
		}
		vTaskDelay(20);
	
	}
}

创建二值信号量优先级翻转

创建Low、Mid、High三个任务，其中Low获取信号后，被Mid打断，但是Mid未执行完，执行完后，Low释放信号后，High才能获取信号，在此之前High进入阻塞态。

二值信号量句柄，创建一个引用，并不是创建一个真实的二值信号量

//优先级翻转
static TaskHandle_t LowPriority_Task_Handle=NULL;
static TaskHandle_t MidPriority_Task_Handle=NULL;
static TaskHandle_t HighPriority_Task_Handle=NULL;

//创建一个二值信号量句柄
SemaphoreHandle_t Binary_Handle=NULL;

创建一个真实的二值量

1 2	//创建一个二值信号量 Binary_Handle = xSemaphoreCreateBinary();

Low任务

static void LowPriority_Task(void *paramter)
{
	static uint32_t i;
	BaseType_t xReturn=pdPASS;

	while (1)
	{
		printf("Low任务获取二值信号量\r\n");
		xReturn = xSemaphoreTake(Binary_Handle,portMAX_DELAY);
		if(xReturn==pdPASS)
		{
			printf("Low任务获取成功\r\n");
		}
		for ( i = 0; i < 2000000; i++)	//模拟占用
		{
			taskYIELD();	//发起任务调度
		}

		printf("Low任务释放二值信号量\r\n");
		xReturn = xSemaphoreGive(Binary_Handle);

		LED0_Turn();
		vTaskDelay(500);
	}
}

Mid任务

static void MidPriority_Task(void *paramter)
{
	while (1)
	{
		printf("Mid任务运行中\r\n");
		vTaskDelay(500);
	}
}

High任务

static void HighPriority_Task(void *paramter)
{
	BaseType_t xReturn = pdTRUE;
	while (1)
	{
		printf("High任务获取二值信号量\r\n");
		xReturn = xSemaphoreTake(Binary_Handle,portMAX_DELAY);

		if (xReturn==pdTRUE)
		{
			printf("High任务获取成功\r\n");
		}

		LED0_Turn();
		xReturn = xSemaphoreGive(Binary_Handle);
		vTaskDelay(500);
	}
}

注意调整AppTaskCreate中的优先级顺序

创建互斥量

开启宏定义

//开启互斥量
#define configUSE_MUTEXES 1
//开启递归互斥量
#define configUSE_RECURSIVE_MUTEXES 1

互斥句柄，创建一个引用，并不是创建一个真实的互斥

//优先级翻转
static TaskHandle_t LowPriority_Task_Handle=NULL;
static TaskHandle_t MidPriority_Task_Handle=NULL;
static TaskHandle_t HighPriority_Task_Handle=NULL;

//创建互斥量句柄
SemaphoreHandle_t MutexSem_Handle=NULL;

创建一个真实的互斥量

1 2	//创建互斥量 MutexSem_Handle = xSemaphoreCreateMutex();

Low任务

static void LowPriority_Task(void *paramter)
{
	static uint32_t i;
	BaseType_t xReturn=pdPASS;

	while (1)
	{
		printf("Low任务获取互斥量\r\n");
		xReturn = xSemaphoreTake(MutexSem_Handle,portMAX_DELAY);
		if(xReturn==pdPASS)
		{
			printf("Low任务获取成功\r\n");
		}
		for ( i = 0; i < 2000000; i++)	//模拟占用
		{
			taskYIELD();	//发起任务调度
		}

		printf("Low任务释放互斥量\r\n");
		xReturn = xSemaphoreGive(MutexSem_Handle);

		LED0_Turn();
		vTaskDelay(1000);
	}
}

Mid任务

static void MidPriority_Task(void *paramter)
{
	while (1)
	{
		printf("Mid任务运行中\r\n");
		vTaskDelay(500);
	}
}

High任务

static void HighPriority_Task(void *paramter)
{
	BaseType_t xReturn = pdTRUE;
	while (1)
	{
		printf("High任务获取互斥量\r\n");
		xReturn = xSemaphoreTake(MutexSem_Handle,portMAX_DELAY);

		if (xReturn==pdTRUE)
		{
			printf("High任务获取成功\r\n");
		}

		LED0_Turn();
		printf("High释放互斥量\r\n");
		xReturn = xSemaphoreGive(MutexSem_Handle);
		vTaskDelay(1000);
	}
}

注意调整AppTaskCreate中的优先级顺序

在低优先级任务运行的时候，中优先级任务无法抢占低优先级的任务，低优先级任务的优先级发生翻转。

FreeRTOS-03-消息队列

2023-06-30T18:32:35.000Z

消息队列

消息队列是一种用于线程间通信的技术，在FreeRTOS中则用于任务间通信，其中的任务可以视为线程。

支持先进先出、后进先出

消息队列运行机制

创建消息队列单独划分一个内存空间，内存大小=控制块大小+单个消息空间*队列长度，然后初始化消息队列，空间大小无法更改。
初始化后，内存空间中会包含头指针等信息，消耗部分内存，删除消息队列后空间释放。
每个空间存放不大于uxItemSize 的任意类型数据。
队列未满，消息会被拷贝到队列末尾。紧急消息则发送至队列首。
当有任务请求队列消息时，任务变为阻塞态在等待时间内等待消息，若消息空间内无消息直至超时，则任务变为就绪态，否则接收消息变为就绪态。
消息队列不再使用后，应该及时删除，释放资源。
任务等待消息的几种状态
1. 即刻型：任务等待消息，若队列中没有消息，任务直接变为就绪态，不再等待消息。
2. 等待型：任务变为阻塞态，在等待时间内等待队列消息，若有消息则接收并变为就绪态，若无就超时变为就绪态。
3. 无限型：任务一直等待消息，直到消息出现。
- 注意事项：只有任务才能进入阻塞态，中断不能进入阻塞态，中断有单独的消息函数

队列常见函数

xQueueCreate()创建一个队列返回一个指针类型的句柄
- 使用的是动态内存，需要开启configSUPPORT_DYNAMIC_ALLOCATION 1宏定义
- 创建的时候，申请内存是连续的，保证队列控制块和消息空间的连续
xQueueStaticCreate()使用静态内存创建一个队列
vQueueDelete()队列删除
xQueueSend()向队列发送消息，以拷贝的形式在队列尾部加入一个消息，不能在中断中使用
xQueueSendToBack()和xQueueSend()等效
xQueueSendFromISR()用于中断中向队列尾部发送一个消息
xQueueSendToBackFromISR()和xQueueSendFromISR()等效
xQueueGenericSend()通用消息队列发送，是上述发送的原型
xQueueGenericSendFromISR()中断通用消息队列发送，中断发送的原型
xQueueReceive()从队列中接收消息，并将消息删除，将消息拷贝至缓冲区
xQueuePeek()从队列中接收消息，不删除消息
xQueueReceiveFromISR()中断中使用
xQueuePeekFromISR()中断中使用
xQueueGenericReceive()通用接收消息，上述的原型

创建队列

设计2个Button任务，通过按键发送不同的Data数据，然后将发送的Data数据在另一个任务中接收，最终在串口显示

队列消息句柄，创建一个引用，并不是创建一个真实的队列消息，同时设置队列的属性

//创建一个Queue句柄
QueueHandle_t Test_Queue=NULL;
#define QUEUE_LEN 4			//队列长度
#define QUEUE_SIZE 4		//单个消息空间大小

创建一个真实的队列

1 2	//创建一个Queue队列 Test_Queue=xQueueCreate((UBaseType_t)QUEUE_LEN,(UBaseType_t)QUEUE_SIZE);

接收数据任务

static void Receive_Task(void *paramter)
{
	BaseType_t xReturn=pdTRUE;
	uint32_t r_queue;
	while (1)
	{
		//消息队列句柄，缓冲区，等待时间：一直等待
		xReturn = xQueueReceive(Test_Queue,&r_queue,portMAX_DELAY);
		if(xReturn==pdTRUE)
		{
			printf("本次接收到的消息是%d\r\n",r_queue);
		}else
		{
			printf("数据接收错误，错误代码:0x%l\r\n",xReturn);
		}
	}
}

Button控制发送数据任务

static void Send_Task(void *paramter)
{
	BaseType_t xReturn=pdTRUE;
	uint32_t send_data1=1;
	uint32_t send_data2=2;
	while (1)
	{
		if (Key_BTN(BTN1)==KEY_ON)
		{
			printf("发送消息send_data1\r\n");
			//消息队列句柄，数据，等待时间：0
			xReturn = xQueueSend(Test_Queue,&send_data1,0);

			if (xReturn==pdTRUE)
			{
				printf("消息send_data1发送成功\r\n");
			}
		}

		if (Key_BTN(BTN2)==KEY_ON)
		{
			printf("发送消息send_data2\r\n");
			xReturn = xQueueSend(Test_Queue,&send_data2,0);
			if (xReturn==pdTRUE)
			{
				printf("消息send_data2发送成功\r\n");
			}
		}
		vTaskDelay(20);
	}
}

FreeRTOS-02-任务管理

2023-06-29T18:23:38.000Z

任务管理

系统中任务运行调度方式

每个任务都是在独立的堆栈环境运行，运行的任务越多需要的堆栈空间越多。
任务之间的切换是基于抢占优先级的，高优先级抢占低优先级
任务切换的寻找方式
- 基于链表，从高往低查，任务创建时已经完成排序
- 计算前导零指令CLZ，直接读出优先级任务(stm32使用这种方式)
相同优先级任务则采用时间片轮转，无更高优先级任务情况下。

任务状态

创建的任务一般有四种状态

就绪态：新创建的任务处于该状态，等待调度器调度
运行态：正在运行的任务，运行的是最高优先级的就绪态任务
阻塞态：不在就绪态列表中，处于中断或等待
挂起态：
- 挂起态任务调度器不可见
- 使用vTaskSuspend()进入挂起态
- 使用vTaskResume()或vTaskResumeFromISR()从挂起态恢复
- 和阻塞态的区别在于：挂起态用于长时间不处理的任务；阻塞态的任务系统需要判断是否超时

常见任务操作函数

vTaskSuspend()任务挂起：等效于该任务被“冻结”或者“休眠”
vTaskSuspendAll()全任务挂起
vTaskResume()任务恢复：将被挂起的任务恢复
vTaskResumeFromISR()中断专用任务恢复
- 无论使用几次vTaskSuspend()，只需要使用一次恢复函数即可恢复
- 需要配置INCLUDE_vTaskResumeFromISR 1的宏定义
vTaskResumeAll()全任务恢复
vTaskDelete()任务删除
vTaskDelay()任务延时，延时时间为Systick
vTaskDelayUntil()任务绝对延时

设计一个任务管理

通过2个Button控制一个LED灯任务的挂起和恢复，需要注意的是：按键检测最好设计成通用函数，保留GPIO和Pin让每个按键的检测尽量避免耦合

//按下状态,0为低有效道通,此处根据接线而定
#define KEY_ON 0
#define KEY_OFF 1

uint8_t Key_Scan(GPIO_TypeDef* GPIOx,uint16_t GPIO_Pin)
{	
	/*检测是否有按键按下 */
	if(GPIO_ReadInputDataBit(GPIOx,GPIO_Pin) == KEY_ON  )  
	{	 
		/*等待按键释放 */
		while(GPIO_ReadInputDataBit(GPIOx,GPIO_Pin) == KEY_ON );   
		return 	KEY_ON ;	 
	}
	else
		return KEY_OFF;
}

建立一个按键检测的任务，根据按键检测来判断是否导通，然后其中一个按键用于挂起任务，另一个按键用于恢复任务。

static void KEY_Task(void *paramter)
{
	while(1)
	{
		if( Key_Scan(GPIOB,GPIO_Pin_1) == 0 )
		{
			/* Button1 被按下 */
			printf("按下开启键，LED0任务挂起\r\n");
			vTaskSuspend(LED0_Task_Handle);/* 挂起LED任务 */
			printf("挂起成功\r\n");
		} 
		if( Key_Scan(GPIOB,GPIO_Pin_10) == 0  )
		{
			/* Button1 被按下 */
			printf("按下关闭键，LED0任务恢复\r\n");
			vTaskResume(LED0_Task_Handle);/* 恢复LED任务！ */
			printf("恢复成功\r\n");
		}
		vTaskDelay(20);

	}
}

FreeRTOS-01-移植

2023-06-28T22:52:44.000Z

堆和栈

堆

栈

返回地址保存在栈中

添加串口打印功能

去掉无关代码、LCD等
增加串口打印功能
- 初始化串口
- 实现fputc

标准库移植

将官方标准库移植到STM32F103C8T6

常见变量类型

TaskHandle_t是任务句柄类型，指针类型，原型为void *

StackType_t是任务堆栈类型，整型类型，原型为uint32_t

StackTask_t是任务块类型，结构体，原型为xSTATIC_TCB结构体

移植注意事项

FreeRTOSConfig.h

配置中断服务

/****************************************************************
            FreeRTOS与中断服务函数有关的配置选项,映射端口                     
****************************************************************/

#define xPortPendSVHandler 	PendSV_Handler
#define vPortSVCHandler 	SVC_Handler

Serial.c

注意串口波特率一致性

尽量使用printf而不使用自定义Serial_Printf

main.c

注意开启vTaskStartScheduler

创建任务

静态SARM内存

需要开启静态内存

1 2	//支持静态内存 #define configSUPPORT_STATIC_ALLOCATION 1

静态内存任务开启区函数

LEDTask_Handle = xTaskCreateStatic((TaskFunction_t)LED_Task,	//任务LED
				(const char*)"LED_Task",	//任务名
				(uint32_t)128,			//堆栈大小
				(void*)NULL,			//传给函数的参数
				(UBaseType_t)4,			//任务优先级
				(StackType_t *)LED_Task_Stack,	//任务堆栈
				(StaticTask_t *)&LED_Task_TCB);	//任务控制块

动态SARM内存

不开启静态内存

动态内存任务开启函数

xReturn = xTaskCreate((TaskFunction_t)LED_Task,		//任务LED
			(const char*)"LED_Task",	//任务名
			(uint16_t)512,			//堆栈大小
			(void*)NULL,			//传给函数的参数
			(UBaseType_t)2,			//任务优先级
			(TaskHandle_t *)&LEDTask_Handle);//任务控制块指针

注意动态和静态的开启函数区别，参数不同，参数类型也不同。

多任务

多任务相较于单任务，区别只在任务开启的个数，对应参数填好，开启任务即可实现多任务。

C52-day05

2023-05-23T03:58:56.000Z

高级定时器应用

PWM调制LED灯并驱动电机

代码

/*
time:2023-05-23
PWM LED DC
*/
#include <reg52.h>
#include "Delay.h"
sbit LED=P1^0;
sbit st = P3^0;
sbit eoc = P3^1;
sbit oe = P3^2;
sbit RS = P3^3;
sbit RW = P3^4;
sbit E = P3^5;

unsigned int vol = 0;
unsigned char t[] = {"012346789"};
unsigned char str[] = {"VOLTAGE: "};
unsigned char i;
unsigned char PWM_COUNT; //计数
unsigned int HUXI_COUNT; //占空比更新时间
unsigned char PWM_VLAUE; //占空比比对值
bit direc_flag; //占空比更新方向



// 写数据
void writedate(unsigned int date)
{
    RS = 1;
    RW = 0;
    E = 0;
    P2 = date;
    Delay(5);
    E = 1;
    E = 0;
}


// 写命令
void writecom(unsigned char com)
{
    RS = 0;
    RW = 0;
    E = 0;
    P2 = com;
    Delay(5);     // 延时根据实际效果判断
    E = 1;
    E = 0;
}


// 初始化
void initlcd()
{
    writecom(0x38);
    writecom(0x0c);
    writecom(0x06);
    writecom(0x01);
}





void timer0_init()
{
	TMOD=0x02; //模式设置，00100000，定时器0，工作于模式2（M1=1，M0=0）
//定时器溢出值设置，每隔50ms发起一次中断。
	TH0=(65536-50000)/256;
	TL0=(65536-50000)%256;
	TR0=1; //定时器0开始计时
	ET0=1; //开定时器0中断
	EA=1; //开总中断
	PWM_COUNT =0;
}
void time0() interrupt 1
{
	PWM_COUNT++;
	HUXI_COUNT++;
	if(PWM_COUNT == PWM_VLAUE) //判断是否到了点亮LED的时候
		LED = 1; //点亮LED
	if(PWM_COUNT == 40) //当前周期结束
	{
		LED = 0; //熄灭LED
		PWM_COUNT = 0; //重新计时
	}
	if((HUXI_COUNT == 200) && (direc_flag == 0))
	{ //占空比增加10%
		HUXI_COUNT = 0;
		PWM_VLAUE++;
		if(PWM_VLAUE == 39) //占空比更改方向
		direc_flag = 1;
	}
	if((HUXI_COUNT == 200) && (direc_flag == 1))
	{ //占空比减少10%
		HUXI_COUNT = 0;
		PWM_VLAUE--;
		if(PWM_VLAUE == 1) //占空比更改方向
			direc_flag = 0;
	}
}


void adc()
{
    // 开启START
    st = 0;
    st = 1;
    Delay(5);
    st = 0;
    while (eoc != 1);
    oe = 1;
    vol = P0;
    oe = 0; 
}   

void display()
{
    unsigned char temp0 = 0, temp1 = 0, temp2 = 0;
    int i = 0;

    vol = vol * 100 / 51;
    temp0 = vol/100;
    temp1 = (vol%100)/10;
    temp2 = vol%10;

    writecom(0x80);
    Delay(5);
    for(i=0; i<8; i++)
    {
        writedate(str[i]);
        Delay(5);
    }
    writecom(0x80 + 0x40 + 4);
    Delay(5);
    writedate(t[temp0]);
    Delay(5);
    writedate('.');
    Delay(5);
    writedate(t[temp1]);
    Delay(5);
    writedate(t[temp2]);
    Delay(5);
    writedate('V');
    Delay(5); 
}




void main()
{
	HUXI_COUNT = 0;
	PWM_COUNT = 0;
	PWM_VLAUE = 20;
	direc_flag = 0;
	LED = 1; //默认LED熄灭
	timer0_init(); //定时器0初始化
	initlcd();

	while(1){

//		Delay(100);
//		LED=~LED;

		adc();
		display();

	}
}



//Delay.c


#include <intrins.h>
#include <reg52.h>
#include "Delay.h"
// 延迟1ms
void Delay(unsigned int n){
//@11.0592MHz
	unsigned char i, j;

//for(j=n;j>0;j--)
//for(i=112;i>0;i--);

	while(n--)
	{
		i = 2;
		j = 239;
		do
		{
			while (--j);
		} while (--i);
	}

}

//Delay.h
#ifndef __Delay_H__
#define __Delay_H__

void Delay(unsigned int times);


#endif

C52-day04

2023-05-16T02:52:48.000Z

AD转换

代码

/*
time:2024-05-16
数字电压表
*/

# include "reg51.h"
sbit st = P3^0;
sbit eoc = P3^1;
sbit oe = P3^2;
sbit RS = P3^3;
sbit RW = P3^4;
sbit E = P3^5;
unsigned int vol = 0;
unsigned char t[] = {"012346789"};
unsigned char str[] = {"VOLTAGE: "};

void delay(unsigned char n)
{
    unsigned int i = 0, j = 0;
    for (i=0; i<n; i++)
    {
        for (j=0; j<120; j++);
    }
}

// 写数据
void writedate(unsigned int date)
{
    RS = 1;
    RW = 0;
    E = 0;
    P1 = date;
    delay(5);
    E = 1;
    E = 0;
}

// 写命令
void writecom(unsigned char com)
{
    RS = 0;
    RW = 0;
    E = 0;
    P1 = com;
    delay(5);      // 延时根据实际效果判断
    E = 1;
    E = 0;
}

// 初始化
void initlcd()
{
    writecom(0x38);
    writecom(0x0c);
    writecom(0x06);
    writecom(0x01);
}

void adc()
{
    // 开启START
    st = 0;
    st = 1;
    delay(5);
    st = 0;
    while (eoc != 1);
    oe = 1;
    vol = P2;
    oe = 0; 
}                

void display()
{
    unsigned char temp0 = 0, temp1 = 0, temp2 = 0;
    int i = 0;

    vol = vol * 100 / 51;
    temp0 = vol/100;
    temp1 = (vol%100)/10;
    temp2 = vol%10;

    writecom(0x80);
    delay(5);
    for(i=0; i<8; i++)
    {
        writedate(str[i]);
        delay(5);
    }
    writecom(0x80 + 0x40 + 4);
    delay(5);
    writedate(t[temp0]);
    delay(5);
    writedate('.');
    delay(5);
    writedate(t[temp1]);
    delay(5);
    writedate(t[temp2]);
    delay(5); 
    writedate('V');
    delay(5);   
}

void main()
{
    initlcd();
    while(1)
    {
        adc();
        display();
    }
}

直流电机

直流电机的控制：

方向控制：直流电机只有正负极，只需交换正负极就可以调节正反转。
转速控制：负载变化不大的时候，加在直流电动机两端的电压大小与其速度近似成正比。

PWM技术：

电动机的电枢绕组两端的电压平均值U为：$D = \frac{t_1}{T}U=DU_s$
D为PWM的占空比：$D = \frac{t_1}{T}$
占空比：一个周期之内高电平的时间与整个周期时长之比。范围：0~1

L293D 芯片：

顺时针转动：最大转速192

代码

/*
time:2023-05-16
51单片机对直流电机的控制
*/
# include "reg51.h"
typedef unsigned int uint;
sbit IN0 = P2^0;
sbit IN1 = P2^1;
sbit E = P2^2;


void motor()
{
    IN0 = 1;
    IN1 = 0;
    E = 1;
}

void inittimer()
{
    TMOD = 0X01;
    TH0 = (65536 - 10000)/256;
    TL0 = (65536 - 10000)%256;
    ET0 = 1;
    EA = 1;
    TR0 = 1;
    IN1 = 0;
}

/*void timer_isr() interrupt 1
{
    TH0 = (65536 - 10000)/256;
    TL0 = (65536 - 10000)%256;          // 占空比：%50
    IN1 = ~IN1;
}
*/
void main()
{
    inittimer();
    while(1)
    {
        motor();
    }
}

步进电机

驱动芯片：L298
四相步进电机四步法和八步法：四步法：给ABCD引脚给控制信号：1001、1100、0110、0011步进电机顺时针转动。八步法：四步法的一半，1001、1000、1100、0100、0110、0010、0011、0001
四步法转动角度大，更平滑。八步法转读角度小，但是能够实现更高的转速

代码

/*
time:2023-05-16
步进电机
*/


# include "reg51.h"
typedef unsigned  char uchar;
typedef unsigned  int uint;
uchar st[] = {0x09,0x08,0x0c,0x04,0x06,0x02,0x03,0x01};

void delay(uint n)
{
    uint i = 0, j = 0;
    for (i=0; i<n; i++)
    {
        for (j=0; j<120; j++);
    }
}

void stepper()
{
    int i = 0;
    for (i=7; i>0; i--)     // 反转 每次转动45°
    {
        P2 = st[i];
        delay(100);

    }  
}

void main()
{
    while(1)
    {
        stepper();
    }
}

C52-day03

2023-05-10T17:42:43.000Z

虚拟串口

代码

/* 
time:2023-05-10
COM
*/
# include "reg51.h"
unsigned char recdat = 0, flag = 0;

void initscon()
{
    SCON = 0X50; // 0101 0000
    TMOD = 0X20; // 0010 0000
    TH1 = 256 - 3;
    TL1 = 256 - 3;
    ES = 1;
    EA = 1;
    TR1 = 1;
}

void scon_isr() interrupt 4     // COM interrupt
{
    recdat = SBUF;
    RI = 0;
    flag = 1;                
}

void senddat()
{
    SBUF = recdat;
    while(!TI);
    TI = 0;
}

void main()
{
    initscon();
    while(1)
    {
        if (flag == 1)
        {
            senddat();
            flag = 0;
        }
    }
}

LCD1602

常用指令码

0X38:设置16 * 2 显示，5*7点阵， 8位数据接口
0X0C：设置开显示，不显示光标
0X06:写一个字符后地址指针加1
0X01: 显示清0，数据指针清0
0X80:LCD第一行的起始地址
0X80+0X40:LCD第二行的起始地址

LCD1602功能

RS，片选
- RS=0，输入命令，不显示字符
- RS=1，写入数据，显示字符
RW，读写操作
- RW=0，写操作
- RW=1，读操作
E，使能端，高电平有效

/* 
time:2023-05-10
LCD display
*/
# include "reg51.h"
sbit RS = P3^0;
sbit RW = P3^1;
sbit E = P3^2;
unsigned char str[] = {"xuaner"};

void delay(unsigned char n)
{
    unsigned int i = 0, j = 0; 

    for (i=0; i<n; i++)
    {
        for (j=0; j<120; j++);
    }
}

// write sign
void writecom(unsigned char com)
{
    RS = 0;
    RW = 0;
    E = 0;	//P3^2 is low --->E is high
    P2 = com;
    delay(5);      // delay
    E = 1;
    E = 0;
}

// write Data
void writedate(unsigned char date)
{
    RS = 1;
    RW = 0;
    E = 0;
    P2 = date;
    delay(5);
    E = 1;
    E = 0;
}

// initial
void initlcd()
{
    writecom(0x38);
    writecom(0x0c);
    writecom(0x06);
    writecom(0x01);
}

void display()
{
    unsigned int i = 0;

    writecom(0x80);     // second line：0x80 + 0x40
    delay(5);
    /* one Char display
    writedate('x');
    delay(5);  
    writedate('u');
    delay(5);
    writedate(a');
    delay(5);
    writedate('n');
    delay(5);
    writedate(e');
    delay(5);
    writedate('r');
    delay(5);
    */
    // string display
    while (str[i] != '\0')
    {
        writedate (str[i]);
        delay(5);
        i++;
    }     
}

void main()
{
    initlcd();
    while(1)
    {
        display();
    }
}

LCD时钟

代码

/*
time:2023-05-10
simple clk
*/

# include "reg51.h"
sbit RS = P3^0;
sbit RW = P3^1;
sbit E = P3^2;
unsigned char count = 0;
unsigned int hour = 9, min = 54, sec = 0;
unsigned char str[] = {"0123456789"};
unsigned char str1[] = {"xuaner CLK"};

void delay(unsigned char n)
{
    unsigned int i = 0, j = 0; 

    for (i=0; i<n; i++)
    {
        for (j=0; j<120; j++);
    }
}


void writecom(unsigned char com)
{
    RS = 0;
    RW = 0;
    E = 0;
    P2 = com;
    delay(5);   
    E = 1;
    E = 0;
}


void writedate(unsigned char date)
{
    RS = 1;
    RW = 0;
    E = 0;
    P2 = date;
    delay(5);
    E = 1;
    E = 0;
}


void initlcd()
{
    writecom(0x38);
    writecom(0x0c);
    writecom(0x06);
    writecom(0x01);
}

void display()
{
    unsigned char temp0 = 0, temp1 = 0, temp2 = 0, temp3 = 0, temp4 = 0, temp5 = 0;
    unsigned char i = 0;
    temp0 = hour / 10;
    temp1 = hour % 10;
    temp2 = min / 10;
    temp3 = min % 10;
    temp4 = sec / 10;
    temp5 = sec % 10;
    writecom(0X80);
    delay(5);
    while(str1[i] != '\0')
    {
        writedate(str1[i]);
        delay(5);
        i++;
    }
    writecom(0X80 + 0X40 + 4);
    delay(5);
    writedate(str[temp0]);
    delay(5);  
    writedate(str[temp1]);
    delay(5);
    writedate(':');
    delay(5);
    writedate(str[temp2]);
    delay(5);
    writedate(str[temp3]);
    delay(5);
    writedate(':');
    delay(5);
    writedate(str[temp4]);
    delay(5);
    writedate(str[temp5]);
    delay(5);  
}

void inittimer()
{
    TMOD = 0x01;
    TH0 = (65536-50000)/256;     // 50ms
    TL0 = (65536-50000)%256;
    ET0 = 1;
    EA = 1;
    TR0 = 1;
}

void timer0_isr() interrupt 1
{
    TH0 = (65536-50000)/256;     // 50ms
    TL0 = (65536-50000)%256;
    count++;
    if (count == 20)    // 1s
    {
        sec = sec + 1;
        count = 0;
    }
    if (sec == 60)
    {
        min = min + 1;
        sec = 0;
    }
    if (min == 60)
    {
        hour = hour + 1;
        min = 0;
    }
    if (hour == 24)
    {
        hour = 0;
    }
}

void main()
{
    initlcd();
    inittimer();
    while(1)
    {
        display();
    }
}

点阵显示

代码

/*
time:2023-05-10
matrix
*/

# include "reg51.h"
unsigned char code tab[] = { 0x00, 0x7e, 0xff, 0xc3, 0xc3, 0xff, 0x7e, 0x00,   // 0
                             0x00, 0x00, 0x43, 0xff, 0xff, 0x03, 0x00, 0x00,   // 1
                             0x00, 0x63, 0xc7, 0xcf, 0xdb, 0xf3, 0x63, 0x00,   // 2
                             0x00, 0x42, 0xdb, 0xdb, 0xdb, 0xff, 0x66, 0x00,   // 3
                             0x00, 0x3e, 0x46, 0xff, 0xff, 0x06, 0x06, 0x00,   // 4
                           };   
unsigned char row[] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
unsigned char num = 0, flag = 0;
sbit key0 = P1^0;

void key()
{
    if (flag == 0 && key0 == 0)
    {
        flag = 1;
    }
    if (flag == 1 && key0 == 1)
    {
        num++;
        flag = 0;
    }
    if (num == 5)
    {
        num = 0;
    }
}

void matrix()
{
    unsigned int i = 0;

    for (i=8*num; i<8*(num+1); i++)    
    { 
        P3 = ~row[i-8*num];
        P2 = tab[i];
    }
}

void main()
{
    while(1)
    {
        matrix();
        key();  
    }
}

DA转换

代码

/*
time:2023-05-10
DA
*/

# include "reg51.h"
unsigned int value = 100, flag = 0;
sbit key0 = P1^0;
sbit key1 = P1^1;

void key()
{
    if (key0 == 0 && flag == 0)
    {
        flag = 1;
    }
    if (flag == 1 && key0 == 1)
    {
        value += 10;
        flag = 0;
    }

    if (key1 == 0 && flag == 0)
    {
        flag = 1;
    }
    if (flag == 1 && key1 == 1)
    {
        value -= 10;
        flag = 0;
    }
}
void delay(unsigned int n)
{
    int i=0, j=0;
    for (i=0; i<n; i++)
    {
        for (j=0; j<120; j++);
    }
}
/*  pwm
void PWM()
{
    P2 = 0;
delay(100);         // duty cycle :change delay
    P2 = 255;
    delay(value);

}
*/
void stair()
{
    int i = 0;
    for (i=0; i<255; i++)
    {
        P2 = i;
    }
    for (i=255; i<0; i--)
    {
        P2 = i;
    }
}

void main()
{
    while(1)
    {
        // PWM();
        stair(); // sawtooth wave
        key();
    }
}

C52-day02

2023-05-09T16:29:19.000Z

矩阵键盘

代码

/*
time:2023-05-08
array buttons 
*/
# include "reg51.h"

unsigned int num = 9;
unsigned char s[] = {0X3F, 0X06, 0X5B, 0X4F, 0X66, 0X6D, 0X7D, 0X07, 0X7F, 0X6F,0X76, 0X79, 0X38, 0X38, 0X3F,0XFF};     // 0-9
sbit P10=P1^0;
sbit P11=P1^1;
sbit P12=P1^2;
sbit P13=P1^3;
sbit P14=P1^4;
sbit P15=P1^5;
sbit P16=P1^6;
sbit P17=P1^7;
void Delay(unsigned int n)
{
    unsigned int i, j;
    for (i=0; i<n; i++)
    {
        for (j=0; j<120; j++);
    }
}

void key_scan()
{
    P1 = 0xff;
    /*---------------cycle scan-----------------*/
    P1=0xFF;
		P13=0;
		if(P17==0){Delay(20);while(P17==0);Delay(20);num=1;}
		if(P16==0){Delay(20);while(P16==0);Delay(20);num=5;}
		if(P15==0){Delay(20);while(P15==0);Delay(20);num=9;}
		if(P14==0){Delay(20);while(P14==0);Delay(20);num=13;}
	
		P1=0xFF;
		P12=0;
		if(P17==0){Delay(20);while(P17==0);Delay(20);num=2;}
		if(P16==0){Delay(20);while(P16==0);Delay(20);num=6;}
		if(P15==0){Delay(20);while(P15==0);Delay(20);num=10;}
		if(P14==0){Delay(20);while(P14==0);Delay(20);num=14;}
	
		P1=0xFF;
		P11=0;
		if(P17==0){Delay(20);while(P17==0);Delay(20);num=3;}
		if(P16==0){Delay(20);while(P16==0);Delay(20);num=7;}
		if(P15==0){Delay(20);while(P15==0);Delay(20);num=11;}
		if(P14==0){Delay(20);while(P14==0);Delay(20);num=15;}
	
		P1=0xFF;
		P10=0;
		if(P17==0){Delay(20);while(P17==0);Delay(20);num=4;}
		if(P16==0){Delay(20);while(P16==0);Delay(20);num=8;}
		if(P15==0){Delay(20);while(P15==0);Delay(20);num=12;}
		if(P14==0){Delay(20);while(P14==0);Delay(20);num=16;}
  
}

void display()
{
    P2 = s[num];
}

void main()
{
    while(1)
    {
        key_scan();
        display();
    }

}

定时器

工作方式

interrupt0，13位，当 INT0 引脚由高电平变为低电平时触发中断。
- $X=8192-N\frac{12}{fosc}$
- 上次计数为0，要重复计数需要置零
interrupt1，16位，当定时器 0 计数器溢出时触发中断。
- $X=65536-N\frac{12}{fosc}$
- 上次计数值为0，要重复计数需要重置初值
interrupt2，8位自动重置定时/计数器，当 INT1引脚由高电平变为低电平时触发中断。
interrupt3，8位，只有T0才能使用，当定时器 1 计数器溢出时触发中断。
- $X=256-N\frac{12}{fosc}$
- 计数器自动配置初值，不需要用户重置
interrupt4，串口中断，当串口接收完成（RI）或发送完成（TI）时触发中断。

TMOD 寄存器

TMOD 的低 4 位控制定时器 0，高 4 位控制定时器 1，每个定时器都有两个工作模式可以选择

M0表示定时器0，M1表示定时器1

TMOD=0x20表示定时器1设置为2模式

TMOD=0x02表示定时器0设置为2模式

TMOD	C/T	M1	M0	工作模式
0x00	0	0	0	模式 0：13 位计数器
0x01	0	0	1	模式 1：16 位计数器
0x02	0	1	0	模式 2：8 位自动重装载计数器
0x03	0	1	1	模式 3：16 位自动重装载计数器
0x04	1	0	0	模式 4：外部事件计数
0x05	1	0	1	模式 5：保留
0x06	1	1	0	模式 6：8 位 PWM 波形发生器
0x07	1	1	1	模式 7：16 位 PWM 波形发生器

TH和TL寄存器

TH0/TL0表示定时器0的高低八位
TH1/TL1表示定时器1的高低八位

IT寄存器

IT0，外部中断寄存器
IT1，外部中断寄存器
IT0/IT1=0，低电平触发
IT0/IT1=1，下降沿触发

中断寄存器

ET0/ET1，定时器中断使能寄存器，为1中断允许，为0不允许
EA，总中断使能寄存器，为1中断允许，为0不允许
TR0/TR1，定时器启动控制寄存器，为1时开始计数，为0时停止计数。

12MHz晶振对应的一个机器周期为1us，需要延时50ms，则从65536-50000开始计数，分为高低八位分别存储计数，当定时器0计数到65536溢出位时，触发timer_isr中断，执行函数。

/*
time: 2023-05-08
timer
*/

# include "reg51.h"
unsigned char s[] = {0x3f, 0x06, 0x5b, 0x4f, 0x66, 0x6d, 0x7d, 0x07, 0x7f, 0x6f};
unsigned char count = 0, num = 0;

void inittimer()
{
    TMOD = 0x01;    // 0000 0001
    TH0 = (65536 - 50000) / 256;  // 50ms = 50000us    initial value >> 8
    TL0 = (65536 - 50000) % 256;
    ET0 = 1;    /* timer0 interrupt on*/
    EA = 1;    // interrupt on
    TR0 = 1; //timer0 on
}
void display()
{
    P2 = s[num];
    if (num == 10)
    {
        num = 0;
    }
}

/* 
0 out interrupt0； 
1 timer interrupt0；
2 out interrupt1；
3 timer interrupt1；
4 COM interrupt
*/
void timer_isr() interrupt   1                   
{
    TH0 = (65536 - 50000) / 256;  // 50ms = 50000us    initial value >> 8
    TL0 = (65536 - 50000) % 256;  
    count++;
    if (count == 20)    // setTime 1s
    {
        num++;
        count = 0;
    }

}
void main()
{
    inittimer();
    while(1)
    {
        display();
    }
}

计数器

代码

/*
time:2023-05-08
8bit auto reset count
*/

# include "reg51.h"
unsigned char s[] = {0x3f, 0x06, 0x5b, 0x4f, 0x66, 0x6d, 0x7d, 0x07, 0x7f, 0x6f};
unsigned char num = 0;

void initcounter()
{
    TMOD = 0X06;   // 0000 0110 auto reset
    TH0 = 255;
    TL0 = 255;
    ET0 = 1;
    EA = 1;
    TR0 = 1;
}

void display()
{
    P2 = s[num];
    if (num == 10)
    {
        num = 0;
    }
}

void counter_isr() interrupt  1
{
    num++;
}

void main()
{
    initcounter();
    while(1)
    {
       display();
    }
}

C52-day01

2023-05-08T00:16:11.000Z

STC89C52

命名规则

STC89C52

STC89
C–>工作电压
- C：5.5V~3.8V
- LE:3.6V~~2.4V/3.4V\~~2.4V
52表示8K字节程序空间，512字节RAM

最小系统

LED灯

代码

/*
time: 2023-05-07
C Flowing LED
*/
# include "reg51.h"
// define an array of reg P0
//unsigned char leds[] = {0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80};

void delay(unsigned int n)
{
    unsigned int i, j;
    for (i=0; i<n; i++)
    {
        for (j=0; j<120; j++);
    }
}

void led()
{
    int i = 0;
    for (i=0; i<8; i++)
    {
        P2 = ~(0x01<<i);
			//P2 = ~leds[i]; 
        delay(500);
    }
}

void main()       
{
    while(1)
    {
       led();
    }
}

数码管

数码管16进制显示

数码管对应16进制0~F

共阳极数码管

1 2	unsigned char LED7Code[] = {0xc0, 0xf9, 0xa4, 0xb0, 0x99, 0x92, 0x82, 0xf8, 0x80, 0x90, 0x88, 0x83, 0xc6, 0xa1, 0x86, 0x8e};

共阴极数码管

1 2	unsigned char LED7Code[] = {0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d, 0x07,0x7f,0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71,0x00};

普通数码管

代码

/*
time: 2023-05-07
C  LED Display
*/
# include "reg51.h"

unsigned char s[] = {0X3F, 0X06, 0X5B, 0X4F, 0X66, 0X6D, 0X7D, 0X07, 0X7F, 0X6F};     // common cathode 0-9
/*                    {0X77, 0X7C, 0X39, 0X5E, 0X79, 0X71, 0X73, 0X3E, 0X31, 0X6E,}
                      {0X38, 0X00}
static display 0-9 A-F P U T Y L   */

void delay(unsigned char n)
{
    unsigned char i, j;

    for (i=0; i<n; i++)
    {
        for (j=0; j<120; j++);
    }
}

void smg()
{
    int i = 0;

    for (i=0; i<10; i++)
    {
        P2 = s[i];
        delay(1000);
    }
}

void main()
{
    while(1)
    {
        smg();
	//P2=0X06;
    }
}

组合74LS138

74LS138对数码管进行片选

/* time:2023-05-07
	74LS138  display HELLO
*/
# include "reg51.h"

unsigned char s[] = {0X76, 0X79, 0X38, 0X38, 0X3F};     // common cathode HELLO
unsigned char sbi[] = {0X00, 0X01, 0X02, 0X03, 0X04, 0X05, 0X06, 0X07}; //74LS138 chip select
/*                    {0X77, 0X7C, 0X39, 0X5E, 0X79, 0X71, 0X73, 0X3E, 0X31, 0X6E,}
                      {0X38, 0X00}
0-9 A-F P U T Y L   */

void delay(unsigned char n)
{
    unsigned char i, j;

    for (i=0; i<n; i++)
    {
        for (j=0; j<120; j++);
    }
}

void smg()
{
    int i = 0;

    for (i=0; i<5; i++)
    {
        P3 = sbi[i];
        P2 = s[i];
        delay(10);
    }
}

void main()
{
    while(1)
    {
        smg(); 
    }
}

按钮控制数码管

代码

/*
time:2023-05-07
LED button control
*/

# include "reg51.h"

sbit key0 = P1^0;
unsigned char s[] = {0X3F, 0X06, 0X5B, 0X4F, 0X66, 0X6D, 0X7D, 0X07, 0X7F, 0X6F};     // 0-9
unsigned char num = 0;
unsigned char flag = 0;
void key()
{
    if (key0 == 0 && flag == 0)
    {
        flag = 1;
    }
    if (flag == 1 && key0 == 1)
    {
        num++;
        flag = 0;
    }
}

void seg()
{
    P2 = s[num];
    if (num == 10)
    {
        num = 0;
    }
}

void main()
{
    while(1)
    {
        key();
        seg();
    }
}

前端IC——数电基础

2023-01-08T02:58:54.000Z

信息、编码和逻辑代数

信息是用来消除不确定的东西✨

编码是一种映射或者描述关系。

常见编码：余三码、补码、反码、8421码、格雷码

反码：除符号位外，按位取反

补码：除符号位外，按位取反然后加1

正数的反码和补码都是其本身

逻辑代数计算：

(AB)’ = A’ + B’

(A + B)’ = A’B’

组合逻辑、时序逻辑电路

组合逻辑电路：是任意时刻的输出仅仅取决于当前时刻的输入，与电路之前的历史状态无关（即无记忆能力）

组合逻辑电路的设计通常包含以下几个步骤：

进行逻辑抽象。分析事件的因果关系，确定输入变量和输出变量，列出输入变量和输出变量的逻辑真值表。
写出逻辑函数。将真值表转换为对应的逻辑函数式，或者直接画出卡诺图，然后使用第三章中介绍的卡诺图将逻辑函数进行化简。
根据化简后的逻辑函数，画出逻辑电路图。

时序逻辑电路：输出不仅取决于当前的输入，还取决于电路的历史状态。因此我们需要一种元件能保存电路的状态信息。如果一个元件带有内部存储功能，它就包含状态，也称之为状态单元（State Element）。

锁存器：锁存器在E的高(低)电平期间对信号敏感
触发器：触发器在CP的上升沿(下降沿)对信号敏感
二者区别：

具有0 和1两个稳定状态，一旦状态被确定，就能自行保持。一个锁存器或触发器能存储一位二进制码。
锁存器—对脉冲电平敏感的存储电路，在特定输入脉冲电平作用下改变状态。
触发器—对脉冲边沿敏感的存储电路，在时钟脉冲的上升沿或下降沿的变化瞬间改变状态。

亚稳态、稳定时间、保持时间

建立时间：触发器在时钟上升沿到来之前，其数据输入端的数据必须保持不变的最小时间。

保持时间：触发器在时钟上升沿到来之后，其数据输入端的数据必须保持不变的最小时间。

建立时间裕量：如果数据信号在时钟边沿触发之前的持续时间要大于建立时间Tsu，那么超出的部分时间即为建立时间裕量。

保持时间裕量：如果数据信号在时钟边沿触发之后的保持时间要大于保持时间Thd，那么超出的部分时间即为保持时间裕量。

静态时序分析——建立保持时间

2023-01-02T22:05:42.000Z

建立时间

公式

$$
T_{lanuch}+T_{ck2q}+T_{dp}<T_{capture}+T_{cycle}-T_{setup}
$$

如果组合逻辑的延时最大值也满足这个公式，则所有都满足，通常用组合逻辑最大延时检查建立时间

使用组合逻辑最小延时检查保持时间

输入端口到寄存器

公式

$$
slack=T_{capture}+T_{cycle}-T_{setup}-T_{uncertainty}-(T_{lanuch}+T_{ck2q}+T_{dp})>0
$$

输出端口到寄存器

公式

$$
slack=T_{capture}+T_{cycle}-T_{setup}-T_{uncertainty}-T_{output_delay}-(T_{lanuch}+T_{ck2q}+T_{dp})>0
$$

保持时间

捕获路径边沿比发射路径边沿晚一个时钟周期
保持时间和时钟周期无关
保持时间不能计算频率，只能用建立时间去计算

公式

$$
T_{lanuch}+T_{ck2q}+T_{dp}>T_{capture}+T_{hold}
$$

建立时间和保持时间的区别

保持时间的检查边沿都是同一个边沿
建立时间的检查边沿捕获的边沿要比发射的边沿晚一个时钟周期
保持时间的检查通常在建立时间检查的前一个上升沿

静态时序分析——逻辑综合

2022-12-27T02:33:14.000Z

逻辑综合三个阶段：转译、优化、映射

时序路径约束

输入到寄存器的路径
寄存器到寄存器之间的路径
寄存器到输出的路径
输入直接到输出的路径

1 2	create_clock-period 10 [get_ports Clk] set_dont_touch_network [get_clocks Clk]

对所有定义的时钟网络设置为dont_touch，即综合的时候不对Clk信号优化。

如果不加这句，DC会根据CIk的负载自动对他产生Buffer，而在实际的电路设计中，时钟树（Clock Tree）的综合有自己特别的方法，它需要考虑到实际布线后的物理信息，所以DC不需要在这里对它进行处理，就算处理了也不会符合要求。

#定义输入延迟
set_input_delay -max 4-clock Clk [get_ports A]

#定义输出延迟
set_output_delay -max 5.4 -clock Clk [get_ports B]

TCL脚本

sh date      //显示开始时间
remove_design-designs     //移除DC中原有的设计
//下面是库的设置，对应图形界面操作的2
###########井#############井
#set library
#
###########井####井##井#####井
set search_path [list *********]
set target_library {tt.db} 
set link_library {*tt.db} 
set symbol_library {tt.sdb}

//下面是屏蔽一些warning信息，DC在综合时遇到这些warning时就把它们忽略，
//不会报告这些信息，VER-130，VER-129等是不同warning信息的编码，
//具体含义可以查看帮助

#void warning Info

#############
suppress_message VER-130
suppress_message VER-129
suppress_message VER-318
suppress_message ELAB-311
suppress_message VER-936

//读入example1.v文件，对应于图形界面的3
#################################
#read&amp；link&amp；Check design#
read_file -format verilog ~/example1.v
#analyze -format verilog ~/example1.v
#elaborate EXAMPLE1
current_design EXAMPLE1  //把EXAMPLE1指定为当前设计的顶层模块
uniquify 
check design

//设置一些变量
############################
#define IO port name
#############################

set clk[get_ports clk] //设置变量clk的值是[get_ports clk],
//在下面的代码中若出现$clk字样，则表示引用该变量的值，即用[get_ports clk]代替$clk。
set rst_n [get_ports rst_n]
set general_inputs [list a b c]
set outputs [get_ports o]

/设置约束条件，对应于图形界面的4
#
set_constraints
#
############################井
//设置时钟约束，对应于图形界面的4.1
#1 set constraints for clock signals 
create_clock -n clock $clk -period 20 -waveform{0 10} //创建一个周期为20ns，占空比为1的时钟
set_dont_touch_network[get_clocks clock]
set_drive 0 $clk //设置时钟端口的驱动为无穷大
set_ideal_network [get_ports clk] //设置时钟端为理想网络

//设置复位信号约束，对应于图形界面的4.2
#2 set constraints for reset signals 
set_dont_touch_network $rst_n 
set_drive 0 $rst_n 
set_ideal network[get_ports rst_n]

//设置输入延时，对应图形界面的4.3
#3 set input delay 
set_input_delay -clock clock 8
$general_inputs
/设置输出延时，对应图形界面的4.4
#4 set output delay 
set_output_delay -clock clock 8
$outputs

//设置面积约束和设计约束，对应图形界面的4.5
#5 set design rule constraints
set_max_fanout 4 $general_inputs 
set_max_transition 0.5 [get_designs "EXAMPLE1"]
#6 set area constraint 
set_max_area 0