详解基于 Cortex-M3 的任务调度（下）

最新推荐文章于 2022-12-05 08:01:10 发布
最新推荐文章于 2022-12-05 08:01:10 发布
阅读量1.1k 收藏 7
点赞数 3
分类专栏： 未分类 文章标签： stm32 任务调度 Cortex-M3
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/longintchar/article/details/120478223
版权

文章目录


在 详解基于 Cortex-M3 的任务调度（上）_车子（chezi）-CSDN博客 这篇文章中，我们已经有了理论基础，这篇文章，我们写代码实践一下。

代码基于网友提供的工程和书中的参考代码修改而成，不求面面俱到，只求讲清原理。

工程说明

我用的是 STM32F103 这款芯片，工程结构如图：

请添加图片描述

User 下面是串口的裸板驱动，调用官方的库函数，非常套路化；

Cortex-M3 下面是厂家提供的文件，一般不用修改；

OS 下面是本文的重点，任务调度的精髓就在里面；

Compiler 下面是我添加的组件，由 ARM 提供，也不用修改。方便没有板子的时候也可以用 PC 模拟运行。

实验结果

结果就是 4 个任务轮流执行。虽然每个任务代码中都有 while(1)，但是它不会一直占用 CPU，当它的时间片到了，OS 就会剥夺它对 CPU 的使用权，让下一个任务运行。

请添加图片描述

如果你有板子，那么就用串口输出。需要在 RTE_Components.h 文件中注释掉这两行

//#define RTE_Compiler_IO_STDOUT          /* Compiler I/O: STDOUT */
//#define RTE_Compiler_IO_STDOUT_ITM      /* Compiler I/O: STDOUT ITM */

如果没有板子，在仿真的时候，打开 Debug（printf) Viewer 窗口就可以了。

请添加图片描述

代码讲解

时钟节拍

上一篇博文说过，系统滴答定时器（SYSTICK）中断是要有的，在这个中断里面触发任务切换。

void OSSysTickInit(void)
{ 
	//Systick定时器初使化
	char *Systick_priority = (char *)0xe000ed23;       //Systick中断优先级寄存器
	SysTick->LOAD  = (SystemCoreClock/8/1000000)* 1000; //Systick定时器重装载  计数9000次=1ms 
	*Systick_priority = 0x00;                           //Systick定时器中断优先级
	SysTick->VAL   = 0;                                 //Systick定时器计数器清0
	SysTick->CTRL = 0x3;//Systick打开并使能中断,且使用外部晶振时钟,8分频  72MHz/8=9MHz  计数9000次=1ms  计数9次=1us
}

配置 SYSTICK 的计数频率，然后使能 SYSTICK 和中断。

如果 SystemCoreClock 是 72MHz，就是 1ms 一次中断。

void SysTick_Handler(void) // 1KHz
{ 
	System.TimeMS++;  //系统时钟节拍累加
	
	if((--System.TaskTimeSlice) == 0)  {		
		System.TaskTimeSlice = TASK_TIME_SLICE;//重置时间片初值
		task_switch();
	}
}

以上就是 SYSTICK 中断处理函数。System.TaskTimeSlice 的初始值是 10；

在 main() 中有初始化的语句:

	System.TaskTimeSlice = TASK_TIME_SLICE; // #define TASK_TIME_SLICE     	10  
	System.OSRunning = OS_TRUE;
	System.TimeMS = 0;

也就是说 10ms 切换一次任务。

注意，这是基于时间片的任务调度，而不是基于优先级。

任务切换 task_switch()

void task_switch(void)
{
	if(System.OSLockNesting != 0) 
		return;
	
	switch(curr_task) {
		case(0): 
			next_task=1; 
			break;
		case(1): 
			next_task=2; 
			break;
		case(2): 
			next_task=3; 
			break;
		case(3): 
			next_task=0; 
			break;
		default: 
			next_task=0;
			stop_cpu;
			break; // Should not be here
	}
	
	if (curr_task != next_task){ // Context switching needed
		SCB->ICSR  |= SCB_ICSR_PENDSVSET_Msk; // Set PendSV to pending
	}
		
}

第 3 行：判断是否给调度器加锁了，如果是，就禁止任务切换，直接返回。

切换的逻辑很简单，只有 0-3 个任务， 0 切到 1，1 切到 2，…。next_task 是个全局变量，记录下一个任务编号。

第 26 行很重要，设置 PendSV 中断悬起。当 SYSTICK 中断服务退出后，马上就会进入 PendSV 中断服务。

这个函数虽然叫 task_switch，但是真正的切换是在 PendSV 中断服务里面。

PendSV_Handler

__asm void PendSV_Handler(void) 
{ 
	
// Simple version - assume No floating point support
	
// Save current context
	MRS R0, PSP // Get current process stack pointer value
	STMDB R0!,{R4-R11} // Save R4 to R11 in task stack (8 regs)
	LDR R1,=__cpp(&curr_task)
	LDR R2,[R1] // Get current task ID
	LDR R3,=__cpp(&PSP_array)
	STR R0,[R3, R2, LSL #2] // Save PSP value into PSP_array

	
// Load next context
	LDR R4,=__cpp(&next_task)
	LDR R4,[R4] // Get next task ID
	STR R4,[R1] // Set curr_task = next_task
	LDR R0,[R3, R4, LSL #2] // Load PSP value from PSP_array
	LDMIA R0!,{R4-R11} // Load R4 to R11 from taskstack (8 regs)
	MSR PSP, R0 // Set PSP to next task
	BX LR // Return
	ALIGN 4
}

这段代码虽然短，但它是任务切换的精髓，简而言之就是保存当前任务的上下文，加载下一个任务的上下文。

在 PendSV_Handler 发生后，会有 8 个寄存器被自动压栈，7-8 行用来手动压栈另外 8 个寄存器。

我们一句一句说。

第 7 行：MRS R0, PSP

加载栈指针到 R0，也就是找到当前任务的栈

第 8 行：STMDB R0!,{R4-R11}

R0 = R0-4， 把 R11 的值存入 R0 指向的内存；然后 R0 = R0-4，把 R10 的值存入 R0 指向的内存；…

为了更加直观，我弄了一幅图：
请添加图片描述

这张图是刚压栈后的情况，可以看到，R4 是最后被压进去的。右边的方框展示的是某个任务的栈。

第 9 行：LDR R1,=__cpp(&curr_task)

这句话的意思是把变量 curr_task 的地址赋值给 R1

第 10 行：LDR R2,[R1] // Get current task ID

取 R1 指向的内容给 R2，也就是获得当前任务的编号

第 11 行：LDR R3,=__cpp(&PSP_array)

取数组 PSP_array[] 的地址给 R3

第 12 行：STR R0,[R3, R2, LSL #2]

相当于伪码 STR R0,[R3, R2<<2]，也就是 STR R0,[R3 + R2*4]

因为 R2 里面是当前任务的编号，所以 [R3 + R2*4] 是根据任务编号索引 PSP_array 数组（每个元素占 4 个字节），意思是把 R0 的值保存到 PSP_array[R2] ，结合 R0 指向当前任务的栈，就是要把当前任务的栈指针保存到数组中。

上面这一番操作，其实是保存当前任务的上下文。

我们继续看代码：

	LDR R4,=__cpp(&next_task)
	LDR R4,[R4] // Get next task ID
	STR R4,[R1] // Set curr_task = next_task
	LDR R0,[R3, R4, LSL #2] // Load PSP value from PSP_array
	LDMIA R0!,{R4-R11} // Load R4 to R11 from taskstack (8 regs)
	MSR PSP, R0 // Set PSP to next task
	BX LR // Return

1：取得变量 next_task 的地址给 R4

2：把 R4 指向的内容给 R4，也就是得到下一个任务的编号

3：存储 R4 的值到 R1 指向的内存，R1 是 curr_task 的指针，所以就是把下一个任务的编号赋值给变量 curr_task ，用 C 语言表示就是 curr_task = next_task；

4：相当于 LDR R0,[R3, R4*4]，即以 R4 的值为下标索引 PSP_array 数组，把里面的值给 R0，连起来就是获得下一个任务的 PSP 到 R0

5：手动出栈，把下一个任务的栈上面的 8 个值恢复到对应的寄存器。剩下 8 个怎么办？会在中断返回的时候自动出栈。IA 表示每次传送后地址增加 4，出栈顺序是先 R4， 再 R5，…，最后 R11

6：用 R0 调整栈指针 PSP，为后面的自动出栈做准备

7：启动异常返回流程

以上语句执行后，就会切换到下一个任务。

任务的代码

void task0(void) //任务0
{
	while(1) 
	 {
		 OSprintf("Task0 is running\r\n");						
		 OS_delayMs(500);	//任务延时							
	 }			
}

void task1(void)  //任务1
{   
	while(1) 
	 {	
		 OSprintf("Task1 is running\r\n");		  
		 OS_delayMs(1000);  //任务延时	
	 }
}
void task2(void)  //任务2
{
	while(1) 
	{
		OSprintf("Task2 is running\r\n");
		OS_delayMs(2000);	//任务延时	 
	}
}
		
void task3(void) //任务3
{
	while(1) 
	 {
		 OSprintf("Task3 is running\r\n");						
		 OS_delayMs(4000);	//任务延时							
	 }			
}

很傻瓜地搞了四个任务，每个任务都向串口输出一句话。

OSprintf 中有一个给调度器上锁和解锁的操作，防止每个任务的打印混淆在一起。有关的代码是：

#define OS_CORE_ENTER 			__disable_irq
#define OS_CORE_EXIT  			__enable_irq

#define OSprintf(fmt, ...) \
{ OSSchedLock(); printf( fmt, ##__VA_ARGS__); OSSchedUnlock();}

//系统布尔值
#define OS_FALSE 0 
#define OS_TRUE  1 

//系统变量类型定义
typedef struct 
{
	INT8U OSRunning;    //运行标志变量
	INT8U OSLockNesting; //任务切换锁定层数统计变量 
	volatile INT32U TimeMS;      //系统时钟节拍累计变量
	INT32U TaskTimeSlice; //任务时间片
}SYSTEM;

//系统变量
SYSTEM System;

void OSSchedLock(void) //任务切换锁定  
{
	OS_CORE_ENTER(); // 关中断
	if(System.OSRunning == OS_TRUE)  
	{                                                                       
		if (System.OSLockNesting < 255u)  // 任务锁定可以最大嵌套 255 层
			System.OSLockNesting++;	     
	}
	OS_CORE_EXIT(); // 开中断
}
void OSSchedUnlock(void) //任务切换解锁 
{
	OS_CORE_ENTER(); 
	if(System.OSRunning == OS_TRUE)
	{                               
		if (System.OSLockNesting > 0) 
			System.OSLockNesting--;  
	}
	OS_CORE_EXIT();
}    


INT32U GetTime(void)
{
    return System.TimeMS;
}

void OS_delayMs(INT32U ms)
{
    INT32U counter;
    counter = GetTime() + ms;
    while(1){
        if(counter < GetTime()) 
			break;
    }
}

OS_delayMs 这个函数有点问题，没有考虑到定时器的溢出。另外，OS_delayMs 这个函数不会挂起当前任务。比较好的做法是当任务调用这个函数的时候，主动放弃 CPU，这时候 CPU 可以选择其他任务执行。当延时时间到了，被挂起任务再恢复到就绪态。

重要的全局变量

// Stack for each task (4K bytes each)
unsigned int 	task0_stack[1024], 
				task1_stack[1024],
				task2_stack[1024], 
				task3_stack[1024];



// Data use by OS
uint32_t curr_task = 0; // Current task
uint32_t next_task = 1; // Next task
uint32_t PSP_array[4]; // Process Stack Pointer for each task

2-5：定义了 4 个数组，分别对应 4 个任务的栈

10-11：curr_task 记录当前任务的编号，next_task 记录下一个任务的编号

12：数组 PSP_array 用来保存每个任务的栈指针。

其实管理任务应该有个 TCB（任务控制块），但是我们的代码比较简陋（防止喧宾夺主），所以就用这些全局变量对付了。

main() 函数

铺垫了那么多，终于来到主函数。

#define HW32_REG(ADDRESS) 		(*((volatile unsigned long *)(ADDRESS)))


int main(void)
{
	USART1_Config(115200); //串口1初使化
	System.TaskTimeSlice = TASK_TIME_SLICE; // 设置时间片为 10ms
	System.OSRunning = OS_TRUE;
	System.TimeMS = 0; 
	
	SCB->CCR  |= SCB_CCR_STKALIGN_Msk; 
	// Enable double word stack alignment
	//(recommended in Cortex-M3 r1p1, default in Cortex-M3 r2px and Cortex-M4)

	
	// Create stack frame for task0
	PSP_array[0] = ((unsigned int) task0_stack) + (sizeof task0_stack) - 16*4;
	HW32_REG((PSP_array[0] + (14<<2))) = (unsigned long) task0;
	// initial Program Counter
	HW32_REG((PSP_array[0] + (15<<2))) = 0x01000000; // initial xPSR
	
	// Create stack frame for task1
	PSP_array[1] = ((unsigned int) task1_stack) + (sizeof task1_stack) - 16*4;
	HW32_REG((PSP_array[1] + (14<<2))) = (unsigned long) task1;
	// initial Program Counter
	HW32_REG((PSP_array[1] + (15<<2))) = 0x01000000; // initial xPSR
	
	// Create stack frame for task2
	PSP_array[2] = ((unsigned int) task2_stack) + (sizeof task2_stack) - 16*4;
	HW32_REG((PSP_array[2] + (14<<2))) = (unsigned long) task2;
	// initial Program Counter
	HW32_REG((PSP_array[2] + (15<<2))) = 0x01000000; // initial xPSR
	
	
	// Create stack frame for task3
	PSP_array[3] = ((unsigned int) task3_stack) + (sizeof task3_stack) - 16*4;
	HW32_REG((PSP_array[3] + (14<<2))) = (unsigned long) task3;
	// initial Program Counter
	HW32_REG((PSP_array[3] + (15<<2))) = 0x01000000; // initial xPSR
	
	curr_task = 0; // Switch to task #0 (Current task)
	__set_PSP((PSP_array[curr_task] + 16*4)); // Set PSP to top of task 0 stack
	NVIC_SetPriority(PendSV_IRQn, 0xFF); // Set PendSV to lowest possible priority
	OSSysTickInit(); 
	
	__set_CONTROL(0x3); // Switch to use Process Stack, unprivileged state
	__ISB(); // Execute ISB after changing CONTROL (architectural recommendation)
	task0(); // Start task 0
	while(1){
		stop_cpu;// Should not be here
	};

}

比较重要的是创建每个任务的栈帧，比如

	// Create stack frame for task0
	PSP_array[0] = ((unsigned int) task0_stack) + (sizeof task0_stack) - 16*4;
	HW32_REG((PSP_array[0] + (14<<2))) = (unsigned long) task0;
	// initial Program Counter

	HW32_REG((PSP_array[0] + (15<<2))) = 0x01000000; // initial xPSR

请添加图片描述

当在 PendSV_Handler 中进行切换的时候，要手动出栈 8 个寄存器（蓝色），另外 8 个寄存器（红色）会自动出栈，对于要切换的任务（将要运行的任务），它的栈指针应该指向 R4

所以第 2 行：PSP_array[0] = ((unsigned int) task0_stack) + (sizeof task0_stack) - 16*4;

后面减去 16*4 表示要预留出这 16 个寄存器的位置，把 PSP 指向 R4

这 16 个寄存器中有 2 个要给初始值，一个是 PC，要指向任务的入口函数；还有一个是 xPSR

请添加图片描述

请添加图片描述

xPSR 的 bit[24] 必须是 1，表示 Thumb state，所以会有代码

HW32_REG((PSP_array[0] + (15<<2))) = 0x01000000; // initial xPSR

继续看代码

	curr_task = 0; // Switch to task #0 (Current task)
	__set_PSP((PSP_array[curr_task] + 16*4)); // Set PSP to top of task 0 stack
	NVIC_SetPriority(PendSV_IRQn, 0xFF); // Set PendSV to lowest possible priority
	OSSysTickInit(); // SysTick 初始化和使能
	
	__set_CONTROL(0x3); // Switch to use Process Stack, unprivileged state
	__ISB(); // Execute ISB after changing CONTROL (architectural recommendation)
	task0(); // Start task 0

第 2 行：因为前面设置好了栈帧，PSP_array[0] 其实是指向 task0 的栈（上面图中 R4 的位置），但是 task0 先运行，它不是在 PendSV_Handler 中切换过去的，而是通过调函数 task0() 来开始执行的，所以它的栈应该是空的，也就是要把它的 PSP 调整到最高处，所以要加上 16*4

第 3 行：把 PendSV_Handler 设置成最低的优先级，为什么这样，可以看我的前一篇博文：详解基于 Cortex-M3 的任务调度（上）_车子（chezi）-CSDN博客

第 6 行：使用 PSP，且运行在非特权级

第 7 行：指令同步屏障。用来清空流水线，确保在执行新的指令前，前面的指令都已执行完毕。

请添加图片描述

请添加图片描述

第 8 行：执行 task0。其实执行第一个任务还有别的方法，比如触发 PendSV_Handler，在中断里面“切换”到 task0

以上就是本文全部内容，欢迎读者批评指正。

代码下载

链接：https://pan.baidu.com/s/1dnl7Cld97hujA3OoxGfd3Q
提取码：chez

参考资料

【1】《Cortex-M3 权威指南 》

【2】《The Definitive Guide to ARM Cortex-M3 and Cortex-M4 Processors（Third Edition）》

车子 chezi
关注
  • 3
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
4.Cortex-M3技术参考手册-r1p1英文版
07-12
1.Cortex-M3处理器简介.pdf 2.Cortex-M3固件函数库.pdf 3.Cortex-M3技术参考手册-r0p0中文版.pdf 4.Cortex-M3技术参考手册-r1p1英文版.pdf 5.Cortex-M3权威指南.pdf 6.STM32F10xxx_RM0008_CH_Rev7V3参考手册.pdf 7.STM32F10x闪存编程手册.pdf 8.STM32F101_Datasheet.pdf 9.STM32F103_Datasheet.pdf 10.stm3210xxx参考手册旧版本.pdf 11.STM-Cortex-M3-培训ppt.pdf 12.Thumb2指令集速查卡.pdf 13.STM32启动模式说明.pdf 14.stm32函数资源.rar 15.STM32系列ARM CORTEX-M3微控制器原理与实践.rar 16.STM32中文应用笔记.rar ****************************************************************************************** 以上是本人在各网站收集的有关STM32与CORTEX-M3的相关中文资料，免费分享给大家，希望能减少各位搜索资料的时间，由于上传限制，不能打包，请大家谅解。
在 Cortex-M3 上运行任务调度代码可以使用一种叫做"时间片轮转"的调度算法
最新发布
weixin_35749545的博客
12-19 65
在 Cortex-M3 上运行任务调度代码可以使用时间片轮转调度算法。时间片轮转调度算法是一种常用的任务调度算法，它可以在多任务环境中有序地执行任务。 在时间片轮转调度算法中，每个任务都会被分配一个固定的时间片，每当一个任务使用完它的时间片后，就会被暂停，让其他任务有机会执行。然后，当所有任务都得到执行的机会后，调度器会再次回到第一个任务，以此类推。 使用时间片轮转调度算法可以有效地分配 CPU ...
STM32 操作系统内核调度原理与实现（2）：任务调度的基础
白杨木屋
04-19 1571
一、STM32F103ze 简介 本文中，采用的 MCU 具体型号为 STM32F103ZET6，其拥有丰富的外设资源（USB，IIC，USART，TIMER）等，大容量的RAM和ROM，以及上百个IO口，可满足普通嵌入式设备的大部分需求： STM32F103ZE 参数 STM32F103ZE 存储器 程序存储器类型 Flash ROM(B...
基于Cortex-m3实现简易实时操作系统
Rdryma的博客
06-07 1781
一、实验环境 硬件平台：stm32f103c8t6 硬件内核：cortex-m3 开发环境：mdk5.25 二、功能描述 这里要实现的简易操作系统其实就是一个多任务系统，让MCU能够在同时运行多个任务！下面先列出对这个操作系统功能需求： 1、任务优先级（8）： 这个是必须的，任务总有个轻重缓急，具体多少个看实际需要； 2、同优先级任务数目（不限）： 同优先级的任务...
Cortex-M3.rar_Cortex_Cortex-M3
09-24
《Cortex-M3处理器移植详解》 Cortex-M3是ARM公司推出的基于ARMv7-M架构的微控制器核心，广泛应用于嵌入式系统设计。它以其低功耗、高性能和小巧的芯片尺寸，成为了物联网、消费电子、汽车电子等多个领域的首选微...
Cortex-M3.rar_Cortex_IAR Cortex m3_m3 iar_zlg
09-24
《Cortex-M3与IAR在ZLG平台上的μCOS-II移植实践详解》 Cortex-M3是一款由ARM公司推出的高效能、低功耗的32位微控制器核心，广泛应用于各种嵌入式系统设计中。IAR Embedded Workbench是知名嵌入式开发工具，尤其...
Cortex-M3_Execute_of_uCOSII_for_lpc1700.rar_Cortex-M3_LPC1700 UC
09-14
《基于Cortex-M3的LPC1700在uCOS-II上的执行详解》 本文将深入探讨如何在基于ARM Cortex-M3内核的LPC1700微控制器上执行uCOS-II实时操作系统。uCOS-II是一款广泛使用的、可移植的、抢占式实时操作系统，而LPC1700...
ARM Cortex-M3嵌入式开发实例详解——基于NXP LPC17XX[张燕妮][程序源代码]
07-16
《ARM Cortex-M3嵌入式开发实例详解——基于NXP LPC17XX》是一本深入讲解基于ARM Cortex-M3架构微控制器NXP LPC17XX的实战书籍，由张燕妮编写并提供了丰富的程序源代码。这本书旨在帮助读者掌握如何在实际项目中应用...
基于ARM Cortex-M3便携式智能卫星定位系统.rar
09-20
《基于ARM Cortex-M3便携式智能卫星定位系统》 本文将深入探讨一种采用ARM Cortex-M3微处理器的便携式智能卫星定位系统的实现与应用。ARM Cortex-M3是ARM公司设计的一种高效能、低功耗的32位微控制器核心，广泛应用...
Cortex-M3（中文版）技术参考手册
07-28
这是ARM公司的Cortex-M3架构产品的技术手册，以Cortex-M3为基础开发电子产品的工程师人手必备
Cortex-M3 技术参考手册中文和英文版
07-12
Cortex-M3 Technical Reference Manual r2p1 Cortex-M3 技术参考手册中文版r0p0 pdf文件
Cortex-M3 技术参考手册.pdf
04-25
Cortex-M3 技术参考手册.pdf
cortex-m3笔记
fdfdsds的博客
06-24 178
(1)寄存器 R0-12 : 通用寄存器 其中 , R0-R7 为Low Register ,
app和bootloader跳转 MSP与PSP
weixin_30872337的博客
09-04 1797
1.不要把跳转函数放在中断中，如此导致在跳转后的app或者bootloder都是在中断状态，只要你一开启该中断，就可能出现硬件中断了 2.如果你的APP使用了ucos系统，在跳转函数中还需要增加__set_CONTROL(0);//把psp修改成msp；这样是为了把ucos系统中的psp置回msp，否则容易出现硬件中断 MSP和PSP 的含义是Main_Stack_Pointer 和Proce...
单片机调试 — Event Recorder 的使用
weixin_43866583的博客
07-19 3496
在单片机的软件开发中，经常会遇到各种各样的问题，Event Recorder是一个很好用的调试组件。
例说OS前的任务切换（附代码）
李肖遥的专栏
12-05 278
关注、星标公众号，直达精彩内容作者：网络素材先了解下如何使用PendSV异常。(为何要使用PendSV而不是其他的异常，请参考《cortex-M3权威指南》)1，如何设定PendSV优先级？NVIC_SYSPRI14EQU0xE000ED22 NVIC_PENDSV_PRIEQU0xFF LDRR0,=NVIC_SYSPRI14LDRR1,=NVIC_PENDSV...
ARM Cortex-M 内核调试相关
Chen Do的博客
08-01 5673
根据《ARM Technical Reference Manual cortex_m3_r1p1_trm》和《Arm® Debug Interface Architecture Specification ADI v6.0.pdf》进行梳理。
关于 Intel 8253/8254
热门推荐
车子（chezi）
12-24 1万+
Intel 8253/8254是一个可编程定时/计数器（PIT-Programmable Interval Timer)芯片，用于处理计算机中的精确时间延迟。该芯片提供了 3个独立的16位计数器通道。每个通道可工作在不同的工作方式下， 并且这些工作方式均可以使用软件来设置。对于PC/AT及其兼容微机系统采用的是8254芯片。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值