一步步写嵌入式操作系统-手写内核打印函数

已于 2022-09-25 21:57:32 修改
阅读量416 收藏
点赞数
分类专栏： 一步步写嵌入式操作系统 文章标签： c语言 arm 开源
于 2022-09-23 20:38:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45050132/article/details/127017519
版权

序言


基于对变参函数传参的探究,实现了内核打印函数.

支持的格式类型有字符\整形数\地址值\字符串.

文件结构

启动代码start.s

.section .startup
.code 32
.align 0

.global _start
.extern __vector_reset
.extern __vector_undefined
.extern __vector_swi
.extern __vector_prefetch_abort
.extern __vector_data_abort
.extern __vector_reserved
.extern __vector_irq
.extern __vector_fiq

_start:
	ldr pc,_vector_reset
	ldr pc,_vector_undefined
	ldr pc,_vector_swi
	ldr pc,_vector_prefetch_abort
	ldr pc,_vector_data_abort
	ldr pc,_vector_reserved
	ldr pc,_vector_irq
	ldr pc,_vector_fiq

	.align 4

_vector_reset:			.word  __vector_reset
_vector_undefined:		.word  __vector_undefined
_vector_swi:			.word  __vector_swi
_vector_prefetch_abort:	.word  __vector_prefetch_abort
_vector_data_abort:		.word  __vector_data_abort
_vector_reserved:		.word  __vector_reserved
_vector_irq:			.word  __vector_irq
_vector_fiq:			.word  __vector_fiq

异常处理代码abnormal.s

.global __vector_undefined
.global __vector_swi
.global __vector_prefetch_abort
.global __vector_data_abort
.global __vector_reserved
.global __vector_irq
.global __vector_fiq

.text
.code 32

__vector_undefined:
	nop
__vector_swi:
	nop
__vector_prefetch_abort:	
	nop
__vector_data_abort:
	nop
__vector_reserved:
	nop
__vector_irq:
	nop
__vector_fiq:
	nop

初始化代码init.s

.equ DISABLE_IRQ,	0x80
.equ DISABLE_FIQ,	0x40
.equ SYS_MOD,		0x1f
.equ IRQ_MOD,		0x12
.equ FIQ_MOD,		0x11
.equ SVC_MOD,		0x13
.equ ABT_MOD,		0x17
.equ UND_MOD,		0x1b

.equ MEM_SIZE, 		0x800000
.equ TEXT_BASE,		0x30000000
.equ _SVC_STACK,	(TEXT_BASE+MEM_SIZE-4)
.equ _IRQ_STACK,	(_SVC_STACK-0x400)
.equ _FIQ_STACK,	(_IRQ_STACK-0x400)
.equ _ABT_STACK,	(_FIQ_STACK-0x400)
.equ _UND_STACK,	(_ABT_STACK-0x400)
.equ _SYS_STACK,	(_UND_STACK-0x400)

.text
.code 32
.global __vector_reset

.extern plat_boot
.extern __bss_start__
.extern __bss_end__

__vector_reset:
	msr cpsr_c,#(DISABLE_IRQ|DISABLE_FIQ|SVC_MOD)
	ldr sp,=_SVC_STACK
	msr cpsr_c,#(DISABLE_IRQ|DISABLE_FIQ|IRQ_MOD)
	ldr sp,=_IRQ_STACK
	msr cpsr_c,#(DISABLE_IRQ|DISABLE_FIQ|FIQ_MOD)
	ldr sp,=_FIQ_STACK
	msr cpsr_c,#(DISABLE_IRQ|DISABLE_FIQ|ABT_MOD)
	ldr sp,=_ABT_STACK
	msr cpsr_c,#(DISABLE_IRQ|DISABLE_FIQ|UND_MOD)
	ldr sp,=_UND_STACK
	msr cpsr_c,#(DISABLE_IRQ|DISABLE_FIQ|SYS_MOD)
	ldr sp,=_SYS_STACK

_clear_bss:
	ldr r1,_bss_start_
	ldr r3,_bss_end_
	mov r2,#0x0
1:
	cmp r1,r3
	beq _main
	str r2,[r1],#0x4
	b 1b

_main:
	b plat_boot


_bss_start_:	.word  __bss_start__
_bss_end_:		.word  __bss_end__

.end

mmu功能代码mmu.c

/*mask for page table base addr*/
#define PAGE_TABLE_L1_BASE_ADDR_MASK	(0xffffc000)

#define VIRT_TO_PTE_L1_INDEX(addr)		(((addr)&0xfff00000)>>18)

#define PTE_L1_SECTION_NO_CACHE_AND_WB	(0x0<<2)
#define PTE_L1_SECTION_DOMAIN_DEFAULT	(0x0<<5)
#define PTE_ALL_AP_L1_SECTION_DEFAULT	(0x1<<10)

#define PTE_L1_SECTION_PADDR_BASE_MASK	(0xfff00000)
#define PTE_BITS_L1_SECTION				(0x2)

#define L1_PTR_BASE_ADDR				0x30700000
#define PHYSICAL_MEM_ADDR				0x30000000
#define VIRTUAL_MEM_ADDR				0x30000000
#define MEM_MAP_SIZE					0x800000
#define PHYSICAL_IO_ADDR				0x48000000
#define VIRTUAL_IO_ADDR					0xc8000000
#define IO_MAP_SIZE						0x18000000

void start_mmu(void)
{
	unsigned int ttb = L1_PTR_BASE_ADDR;

	asm (
		"mcr p15,0,%0,c2,c0,0\n"    /* set base address of page table*/
		"mvn r0,#0\n"                  
		"mcr p15,0,r0,c3,c0,0\n"    /* enable all region access*/

		"mov r0,#0x1\n"
		"mcr p15,0,r0,c1,c0,0\n"    /* set back to control register */
		"mov r0,r0\n"
		"mov r0,r0\n"
		"mov r0,r0\n"
		:
		: "r" (ttb)
		:"r0"
	);
}

unsigned int gen_l1_pte(unsigned int paddr)
{
	return (paddr & PTE_L1_SECTION_PADDR_BASE_MASK) | PTE_BITS_L1_SECTION;
}

unsigned int gen_l1_pte_addr(unsigned int baddr, unsigned int vaddr)
{
	return (baddr & PAGE_TABLE_L1_BASE_ADDR_MASK) | VIRT_TO_PTE_L1_INDEX(vaddr);
}

void init_sys_mmu(void)
{
	unsigned int pte;
	unsigned int pte_addr;
	int j;

	for(j = 0; j < MEM_MAP_SIZE>>20; j++) {
		pte = gen_l1_pte(PHYSICAL_MEM_ADDR + (j<<20));
		pte |= PTE_ALL_AP_L1_SECTION_DEFAULT;
		pte |= PTE_L1_SECTION_NO_CACHE_AND_WB;
		pte |= PTE_L1_SECTION_DOMAIN_DEFAULT;
		pte_addr = gen_l1_pte_addr(L1_PTR_BASE_ADDR, VIRTUAL_MEM_ADDR + (j<<20));
		*(volatile unsigned int *)pte_addr = pte;
	}

	for(j = 0; j< IO_MAP_SIZE>>20; j++) {
		pte = gen_l1_pte(PHYSICAL_IO_ADDR+(j<<20));
		pte |= PTE_ALL_AP_L1_SECTION_DEFAULT;
		pte |= PTE_L1_SECTION_NO_CACHE_AND_WB;
		pte |= PTE_L1_SECTION_DOMAIN_DEFAULT;
		pte_addr = gen_l1_pte_addr(L1_PTR_BASE_ADDR, VIRTUAL_IO_ADDR + (j<<20));
		*(volatile unsigned int *)pte_addr = pte;
	}
}

打印功能代码print.c

#define PRINTK_BYTE_IO_VIRTUAL_ADDR 0xd0000020

#define PRINTK_IS_PRINTABLE(c)   ( ( (c >= 32) && (c <= 126) ) || (c == '\n') ) 
#define PRINTK_FMT_TYPE_FLAG '%'
#define PRINTK_FMT_TYPE_CHAR 'c'
#define PRINTK_FMT_TYPE_INT 'd'
#define PRINTK_FMT_TYPE_ADDR 'a'
#define PRINTK_FMT_TYPE_STRING 's'

#define PRINTK_PRINT_CHAR(c) do { \
	if (PRINTK_IS_PRINTABLE(c)) \
	{ \
		*(volatile unsigned int *)(PRINTK_BYTE_IO_VIRTUAL_ADDR) = c; \
	} \
}while(0);

#define PRINTK_STRUCT_BUF_SIZE 256
struct
{
	char buf[PRINTK_STRUCT_BUF_SIZE];
	unsigned int amount;
}printk_struct;

#define PRINTK_TEMP_STRUCT_BUF_SIZE 128
struct
{
	char buf[PRINTK_TEMP_STRUCT_BUF_SIZE];
	unsigned int amount;
}printk_temp_struct;

void printk_struct_buf_clear(void)
{
	unsigned int i = 0;
	for (i = 0; i < PRINTK_STRUCT_BUF_SIZE; i++)
	{
		printk_struct.buf[i] = '\0';
	}
	printk_struct.amount = 0;
}

void printk_temp_struct_buf_clear(void)
{
	unsigned int i = 0;
	for (i = 0; i < PRINTK_TEMP_STRUCT_BUF_SIZE; i++)
	{
		printk_temp_struct.buf[i] = '\0';
	}
	printk_temp_struct.amount = 0;
}

void printk_struct_buf_insert_tail(char c)
{
	if (PRINTK_IS_PRINTABLE(c))
	{
		if (printk_struct.amount < PRINTK_STRUCT_BUF_SIZE)
		{
			printk_struct.buf[printk_struct.amount] = c;
			printk_struct.amount++;
		}
	}
}

void printk_temp_struct_buf_insert_tail(char c)
{
	if (PRINTK_IS_PRINTABLE(c))
	{
		if (printk_temp_struct.amount < PRINTK_TEMP_STRUCT_BUF_SIZE)
		{
			printk_temp_struct.buf[printk_temp_struct.amount] = c;
			printk_temp_struct.amount++;
		}
	}
}

void printk_print_string(char *string)
{
	char *p = string;
	unsigned char i = 0;
	for (;;)
	{
		if (PRINTK_IS_PRINTABLE(p[i]))
		{
			PRINTK_PRINT_CHAR(p[i]);
		}
		else
		{
			break;
		}
		i++;
	}
}

unsigned int printk_get_string_length(char *string)
{
	char *p = string;
	unsigned int length = 0;
	for (;;)
	{
		if (PRINTK_IS_PRINTABLE(p[length]))
		{
			length++;
			continue;
		}
		else
		{
			return(length);
		}
	}
}

void printk_temp_struct_buf_reverse(void)
{
	unsigned int i = 0;
	char temp = '\0';
	for (i = 0; i < printk_temp_struct.amount; i++)
	{
		if (i >= (printk_temp_struct.amount - 1 - i))
		{
			break;
		}
		temp = printk_temp_struct.buf[i];
		printk_temp_struct.buf[i] = printk_temp_struct.buf[printk_temp_struct.amount - 1 - i];
		printk_temp_struct.buf[printk_temp_struct.amount - 1 - i] = temp;
	}
}

void printk_temp_struct_buf_fill_int(int num_int)
{
	int num_int_positve = 0;
	if (num_int >= 0)
	{
		num_int_positve = num_int;
	}
	else
	{
		num_int_positve = -num_int;
	}
	char result = '\0';
	for (;;)
	{
		if (num_int_positve == 0)
		{
			break;
		}
		result = (char)(num_int_positve % 10) + '0';
		printk_temp_struct_buf_insert_tail(result);
		num_int_positve = num_int_positve / 10;
	}
	if (num_int < 0)
	{
		printk_temp_struct_buf_insert_tail('-');
	}
	printk_temp_struct_buf_reverse();
}

void printk_struct_buf_append_temp_buf(void)
{
	unsigned int i = 0;
	char *p = printk_temp_struct.buf;
	for (i = printk_struct.amount;i < PRINTK_STRUCT_BUF_SIZE; i++)
	{
		if (PRINTK_IS_PRINTABLE(*p))
		{
			printk_struct_buf_insert_tail(*p);
		}
		else
		{
			break;
		}
		p++;
	}
}

void printk_temp_struct_buf_fill_addr(unsigned int num_addr)
{
	unsigned int addr = num_addr;
	char result = '\0';
	for (;;)
	{
		if (addr == 0)
		{
			break;
		}
		result = (char)(addr % 10) + '0';
		printk_temp_struct_buf_insert_tail(result);
		addr = addr / 10;
	}
	printk_temp_struct_buf_reverse();
}

void printk_temp_struct_buf_fill_string(unsigned int char_addr)
{
	char *p = (char *)char_addr;
	for (;;)
	{
		if (PRINTK_IS_PRINTABLE(*p))
		{
			printk_temp_struct_buf_insert_tail(*p);
		}
		else
		{
			break;
		}
		p++;
	}
}


#define PRINTK_INIT_PARGV(pArgv,fmt) ( pArgv = (char *)&fmt )
#define PRINTK_REFRESH_PARGV(pArgv) ( pArgv = pArgv + 4 )
#define PRINTK_GET_ARGV(pArgv,type) ( *(type *)pArgv )
#define PRINTK_DEINIT_PARGV(pArgv) ( pArgv = (char*)0 )
void printk_struct_buf_format(char *pV,char *fmt)
{
	char *pArgv = pV;
	char *format = fmt;
	unsigned int format_length = 0;
	unsigned int i = 0;
	format_length = printk_get_string_length(format);
	for (i = 0; i < format_length; i++)
	{
		if (format[i] == PRINTK_FMT_TYPE_FLAG)
		{
			if (format[i + 1] == PRINTK_FMT_TYPE_CHAR)
			{
				PRINTK_REFRESH_PARGV(pArgv);
				char c = PRINTK_GET_ARGV(pArgv,char);
				printk_struct_buf_insert_tail(c);
				i++;
			}
			else if (format[i + 1] == PRINTK_FMT_TYPE_INT)
			{
				printk_temp_struct_buf_clear();
				PRINTK_REFRESH_PARGV(pArgv);
				int num_int = PRINTK_GET_ARGV(pArgv,int);
				printk_temp_struct_buf_fill_int(num_int);
				printk_struct_buf_append_temp_buf();
				i++;
			}
			else if (format[i + 1] == PRINTK_FMT_TYPE_ADDR)
			{
				printk_temp_struct_buf_clear();
				PRINTK_REFRESH_PARGV(pArgv);
				unsigned int num_addr = PRINTK_GET_ARGV(pArgv,unsigned int);
				printk_temp_struct_buf_fill_addr(num_addr);
				printk_struct_buf_append_temp_buf();
				i++;
			}
			else if (format[i + 1] == PRINTK_FMT_TYPE_STRING)
			{
				printk_temp_struct_buf_clear();
				PRINTK_REFRESH_PARGV(pArgv);
				unsigned int char_addr = PRINTK_GET_ARGV(pArgv,unsigned int);
				printk_temp_struct_buf_fill_string(char_addr);
				printk_struct_buf_append_temp_buf();
				i++;
			}
			else
			{
				printk_struct_buf_insert_tail(format[i]);
			}
		}
		else
		{
			printk_struct_buf_insert_tail(format[i]);
		}
	}

}

void printk(char *fmt,...)
{
	printk_struct_buf_clear();
	char *pArgv;
	PRINTK_INIT_PARGV(pArgv,fmt);
	printk_struct_buf_format(pArgv,fmt);
	printk_print_string(printk_struct.buf);
	PRINTK_DEINIT_PARGV(pArgv);
}

void test_printk(void)
{
	printk("test_printk start\n");
	int x;
	printk("[char:%c,int:%d,int:%d,address:%a,string:%s]\n",'a',123,-123,&x,"hello_printk");
	printk("test_printk end\n");
}

开机代码boot.c

typedef void (*init_func)(void);

#define UFCON0	((volatile unsigned int *)(0x50000020))

void helloworld(void)
{
	const char *p = "4.2_helloworld\n";
	while(*p) {
		*UFCON0 = *p++;
	};
}

static init_func init[] = {
	helloworld,
	0,
};

void test_mmu(void)
{
	const char *p = "4.2_test_mmu\n";
	while (*p) {
		*(volatile unsigned int *)0xd0000020 = *p++;
	};
}

extern void test_printk(void);

void plat_boot(void)
{
	int i;
	for(i = 0; init[i]; i++) {
		init[i]();
	}
	init_sys_mmu();
	start_mmu();
	test_mmu();
	test_printk();

	while(1);
}

编译脚本makefile

CC = arm-none-eabi-gcc
LD = arm-none-eabi-ld
OBJCOPY = arm-none-eabi-objcopy

CFLAGS = -O0 -g
ASFLAGS = -O0 -g
LDFLAGS = -T leeos.lds -Ttext 30000000 

OBJS = init.o start.o boot.o abnormal.o mmu.o print.o

.c.o:
	$(CC) $(CFLAGS) -c $<
.s.o:
	$(CC) $(ASFLAGS) -c $<

leeos.elf:$(OBJS)
	$(CC) -static -nostartfiles -nostdlib $(LDFLAGS) $? -o $@ -lgcc
	$(OBJCOPY) -O binary $@ leeos.bin

clean:
	rm -f *.o leeos.elf leeos.bin

链接脚本leeos.lds

OUTPUT_ARCH(arm)
ENTRY(_start)

SECTIONS
{
	. = 0x00000000;
	.text :
	{
		*(.startup)
		*(.text)
	}
	. = ALIGN(32);
	.data :
	{
		*(.data)
	}
	. = ALIGN(32);
	__bss_start__ = .;
	.bss :
	{
		*(.bss)
	}
	__bss_end__ = .;
}

仿真器配置脚本skyeye.conf


cpu:  arm920t
mach: s3c2410x
  
#physical memory
mem_bank: map=M, type=RW, addr=0x30000000, size=0x00800000, file=./leeos.bin,boot=yes
mem_bank: map=I, type=RW, addr=0x48000000, size=0x20000000

效果

nice!

nice!

nice!

lxzlife
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
自己动手写嵌入式操作系统
fatfatearth的博客
12-01 3919
小编分享 本书以作者亲自在PC上开发嵌入式操作系统“HelloChina”的全过程为主线，详细地叙述自己动手写嵌入式操作系统所需的各方面知识，如加载和初始化、Shell、线程的实现、内存管理机制、互斥和同步机制及中断和定时机制的实现，以及设备驱动程序管理框架，应用编程接口等。 本书中的每一个字都是作者辛勤劳动的结晶，本书所讲到的嵌入式操作系统“HelloChina”更是作者亲自实践的成果，因此本书具有极高的实用性，对于嵌入式软件开发工程师、应用软件开发工程师均有很高的参考价值，对于大中院校的学生在学习和
嵌入式 实现自己的printf函数小示例
skdkjxy的专栏
12-02 979
my_printf.h: [csharp] view plaincopyprint? extern void my_printf(const char *format,...); extern void my_printf(const char *format,...); my_printf.c: [csharp] view plaincopyprint? #includ
嵌入式软开面试常见的手写代码
XBlog
10-23 1228
1、冒泡排序： void BubbleSort(int arr[], int len) { for (int i = 0; i < len-1; i++) { for (int j = 0; j < len - 1 - i; j++) { if (arr[j] > arr[j+1]) { Swap(&arr[j], &arr[j+1...
C++基础篇 -- vector的resize函数和reserve函数
newbeixue的博客
04-29 218
https://blog.csdn.net/VampirEM_Chosen_One/article/details/50519870
vector机器人 HOW TO RESET, ERASE AND RESTORE VECTOR 如何重置，删除和恢复向量
whatday的专栏
05-31 2315
目录 How to turn Vector off如何关闭矢量 How to use Recovery Mode如何使用恢复模式 How to Erase User Data如何删除用户数据 How to restore Vector如何恢复 Vector How to turn Vector off如何关闭矢量 Turn off Vector to stop him streaming data to the Cloud. Turning Vector off and on ...
一个微型嵌入式RTOS，参考李述铜《从0到1自己动手写嵌入式操作系统》
06-21
第一周 双任务切换操作系统的实现 C1.04 工程创建。标志变量反转的逻辑仪观测标志变量反转的逻辑仪观测 C1.07 内核编程实践。CPU寄存器数据的保护（压栈）与恢复（出栈），调试技术的应用。简单汇编代码的编写 C...
自己手写的基于STM32C8T6最小系统板的平衡车工程源码.zip
04-24
首先，STM32C8T6是一款低功耗、高性能的ARM Cortex-M0内核微控制器，具有丰富的外设接口，适用于此类嵌入式控制系统。在本项目中，它作为整个系统的"大脑"，处理各种传感器数据并执行相应的控制策略。 高级定时器...
基于ARM手写数字识别系统.pdf
09-21
在手写数字识别系统中，ARM处理器的低功耗和高性能能够满足嵌入式设备的需求，使得系统可以在低能耗的前提下进行复杂的计算任务。 TensorFlow框架： TensorFlow是一个开源的机器学习框架，由Google开发，用于数值...
STM32 调用 keras训练好的h5模型 手写识别
03-08
STM32调用Keras训练好的H5模型进行手写识别是一个典型的嵌入式人工智能（AI）应用。在这个项目中，我们看到STM32微控制器（MCU）被用来实现一个实时的手写数字识别系统。Keras是一个高级的神经网络API，它运行在...
STM32F103实现手写数字识别【支持STM32F10X系列单片机】
最新发布
11-22
STM32F103是意法半导体（STMicroelectronics）推出的一款基于ARM Cortex-M3内核的微控制器，广泛应用于嵌入式系统设计。在本项目中，它被用于实现手写数字识别功能，这涉及到图像处理、模式识别以及低层硬件驱动等多...
vector用法总结(定义，操作，方法，注意点)
一蒙小子的专栏
04-16 5512
前一篇日志中，我们记述了利用面向对象中的多态性实现画圆和画方形的操作。今天把其中的涉及到的知识点vector作一个总结，以作记忆。 http://blog.163.com/zhoumhan_0351/blog/static/399542272010225104536463 一、vector的基本概念 vector是同一种类型的对象的集合，每个对象都有一个对应的整数索引值。和strin
C++：vector中的resize()函数 VS reserve()函数
weixin_34293141的博客
05-11 550
http://www.cplusplus.com/reference/vector/vector/vector/ 写代码的时候无意错用了这两个函数 导致测试的时候，程序运行崩溃 发现这两个函数还是有区别的 void reserve (size_type n); reserver函数用来给vector预分配存储区大小，即capacity的值 ，但是没有给这段内存进行初始化。reserve 的参...
NIOS II学习之路——关于Reset Vector和Exception Vector的解释
电子芯的专栏
05-30 4051
在NIOS II学习过程中设置CPU参数的时候，遇到Reset Vector和Exception Vector的设置。参数设置画面如下图所示。 Reset Vector——复位向量 Exception Vector——执行向量 首先说明两个向量地址都存储着程序。下面分别进行解释。                                         Reset Vector——复
Lpc系列ARM的中断向量表中实现方式
WishMaster
11-16 3552
         实现方式有两种：第一种 0x18处放置        在发生中断时   跳到VICVectAddr中的地址处 代码如下        EXTERN undef_handler, prefetch_handler, data_handler, fiq_handler        ARM__vector:        ;;        ldr   pc,[pc,#+24
圆梦，手写了个操作系统
嵌入式Linux
09-21 1246
大家好，我是发哥。我不止一次在公众号上强调学习操作系统的重要性。至于学习的方法，无外乎看书、看视频、看源码等等。也有推荐过跟着老师一起手写操作系统，但很少有学习方法能同时兼顾以下三点：1、Linux内核2、Windows内核3、自己写操作系统如果只学一种操作系统，很容易陷入到一种认知偏差，觉得操作系统只能这样，或者把某个操作系统的实现就认为是所有操作系统的标准。今天，我要推荐的一个学习方式，就把这...
ARM中断向量表与响应流程
热门推荐
jet
10-18 2万+
一首先中断向量表定义在哪里？如何加载？  二  中断向量表与中断服务程序 三处理流程 //////////////////////////////////////////////////////////////////////////////////////////////////// 一首先中断向量表定义在哪里？__vectors_start 首先中断向量表定义的是什么？ 定义
自己动手从0到1写嵌入式操作系统-李述铜-专题视频课程
李述铜的笔记
04-06 4062
这不是rtos源码分析的课程，而是为初级的同学设计，从基础原理讲师，一步步不断迭代设计rtos的课程！ 用不到【2000行代码，汇编代码仅18行】（不含注释）实现一个精巧的可以运行在ARM Cortex-M内核芯片上的RTOS！ 该RTOS功能与ucos类似，具体实现不同。学习之后，再去学习ucos之类的系统将没有什么问题。...
Tomcat(二)：手写嵌入式tomcat
nelson的博客
08-28 3646
嵌入式tomcat:非传统的部署方式，将tomcat嵌入到主程序中进行运行。 优点：灵活部署、任意指定位置、通过复杂的条件判断 发展趋势：Springboot默认继承的是tomcat容器 Maven中Springboot引入tomcat org.springframe.boot spring-boot-starter-tomcat provided ...
一步一步写嵌入式操作系统学习（一）
java开发指南博客 【转载】
10-28 298
学习方法： 1）以《一步一步写嵌入式系统》为主线，以其他的本书中未提到的相关知识、参考资料为辅助。 2）要多多实践。 开发环境的搭建： 需要解决四个问题：在什么样的系统环境下开发？使用什么样的编辑工具？怎样编译程序？程序如何运行？ 1、关于在什么样的系统环境下开发？ 建议使用Linux操作系统来学习和编写本书的示例。 也可以在windows下使用Cygwin工具来运行编译和运行本...
8051单片机嵌入式操作系统设计与NoC内核实现
"这篇论文主要探讨了单片机嵌入式操作系统的研发，特别是针对8051单片机的简单嵌入式操作系统设计，并研究了NoC（Network on Chip）结构的操作系统内核设计。作者刘彦鑫在导师李哲英的指导下，对8位处理器的操作系统...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值