嵌入式Linux

已于 2022-07-08 22:41:47 修改
阅读量705 收藏 1
点赞数 1
分类专栏： Linux 嵌入式 文章标签： linux
于 2022-04-07 21:56:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_54252044/article/details/123457082
版权

一、文件 I/O

1.1、文件描述符

对于内核而言，所有打开的文件都通过文件描述符引用。文件描述符是一个非负整数。当打开一个现有文件或创建一个新文件时，内核向进程返回一个文件描述符。当读、写一个文件时，使用open或creat返回的文件描述符标识该文件，将其作为参数传递给read或write
文件描述符的变化范围是0 ~ OPEN_MAX - 1

注意：
文件描述符 0：标准输入（STDIN_FILENO）
文件描述符 1：标准输出（STDOUT_FILENO）
文件描述符 2：标准错误（STDERR_FILENO）

1.2、函数 open

调用open函数可以打开或创建一个文件

#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>

int open(const char *path, int oflag，mode_t mode);

参数：
path： 是要打开或创建文件的名字（包含路径）
oflag：可用来说明此函数的多个选项
       O_RDONLY				只读打开
	   O_WRONLY				只写打开
	   O_RDWR				可读、写打开		
	   O_EXEC				只执行打开
	   O_SEARCH				只搜索打开（应用于目录）
	   
以上5个常量中必须指定一个且只能指定一个，以下常量则是可选

	   O_APPEND				每次写时都追加到文件的尾端
	   O_CLOEXEC			把FD_CLOEXEC常量设置为文件描述符标志
	   O_CREAT				若文件不存在则创建它
	   O_DIRECTORY			如果path引用的不是目录，则出错
	   O_EXCL				如果同时指定了O_CREAT，而文件已经存在，则出错
	   O_NOCTTY				如果path引用的是终端设备，则不将该设备分配作为此进程的控制终端
	   O_NOFOLLON			如果path引用的是一个符号链接，则出错
	   O_NONBLOCK			如果path引用的是一个FIFO、一个块特殊文件或一个字符特殊文件，则此选项为文件的本次打开操作和后续的I/O操作设置非阻塞方式
	   O_SYNC				使每次write等待物理I/O操作完成，包括由该write操作引起的文件属性更新所需的I/O
	   O_TRUNC				如果此文件存在，而且为只读或读-写成功打开，则将其长度截断为0
	   O_TTY_INIT			如果打开一个还未打开的终端设备，设置非标准termios参数值，使其符合Single UNLX Specification

mode：记录待创建的文件的访问权限

返回值：若成功，返回文件描述符；若失败返回-1

1.3、 函数 creat

调用creat函数创建一个文件

#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>

int creat(const char *pathname, mode_t mode);

参数：
pathname：创建文件的名字（包含路径）
mode：	  记录待创建的文件的访问权限

返回值：若成功，返回为只写打开的文件描述符；若出错，返回-1

注意：此函数等效于：open(path, O_WRONLY | O_CREAT | O_TRUNC, mode);
creat 的一个不足之处是它以只写方式打开所创建的文件。在提供open的新版本之前，如果要创建一个临时文件，并要先写该文件，然后又读该文件，则必须先调用creat、close，然后再调用open。现在则可用下列方式调用open实现：

open(path, O_WRONLY | O_CREAT | O_TRUNC, mode);

1.4、函数 close

可调用close函数关闭一个打开文件

#include<unistd.h>

int close(int fd);
参数：
fd：是指需要关闭文件的描述符

返回值：若成功，返回0；若出错，返回-1

关闭一个文件时还会释放该进程加在该文件上的所有记录锁

1.5、 函数 lseek

每个打开文件都有一个与其相关联的“当前文件偏移量”（current file offset）。它通常是一个非负整数，用以度量从文件开始处计算的字节数。
通常，读、写操作都从当前文件偏移量处开始，并使偏移量增加所读写的字节数。按系统默认的情况，当打开一个文件时，除非指定 O_APPEND 选项，否则该偏移量被设置为0

#include<sys/types.h>
#include<unistd.h>

off_t lseek(int fd, off_t offset, int whence);

参数：
fd:     文件描述符
offset：偏移值
whence：
		若whence是SEEK_SET,则将该文件的偏移量设置为距文件开始处 offset 个字节
		若whence是SEEK_CUR,则将该文件的偏移量设置为其当前值加offset，offset可为正或负
		若whence是SEEK_END,则将该文件的偏移量设置为文件的长度加offset，offset可正可负

返回值：若成功，返回新的文件偏移量；若出错，返回-1

获取当前偏移量的位置

off_t 	  currpos;
currpos = lseek(fd, 0, SEEK_CUR); // 表示从当前位置偏移0个字节，并返回偏移量

这种方法可用来确定所涉及的文件是否可以设置偏移量。如果文件描述符指向的是一个管道、FIFO或网络套接字，则lseek返回-1，并将errno设置为ESPIPE

1.6、函数 read

调用read函数从打开文件中读取数据

#include<unistd.h>

ssize_t read(int fd, void *buf, size_t count);

参数：
fd:    文件描述符
buf：  将读取到的数据存入buf缓冲区中
count：读取的字节数

返回值：读到的字节数，若已到文件尾，返回0；若出错，返回-1

理论上read的返回值和count的大小一样，但也有读取到的字节数小于count

  • 读普通文件时，在读到要求字节数之前已到达了文件尾端。例如，若在到达文件尾端之前有30字节，而要求读100字节，则read返回30。下次再调用read时，它将返回0（文件尾端）。
  • 当从终端设备读时，通常一次最多读一行。
  • 当从网络读时，网络中的缓冲机制可能造成返回值小于所要求读的字节数
  • 当从管道或FIFO读时，如若管道包含的字节少于所需的数量，那么read将只返回实际可用的字节数
  • 当从某些面向记录的设备（如磁带）读时，一次最多返回一个记录
  • 当一信号造成中断，而已经读了部分数据量时。

1.7、 函数 write

调用write函数向打开文件写入数据

#include<unistd.h>

ssize_t write(int fd, const void *buf, size_t count);

参数：
fd:     文件描述符
buf：   写入缓冲区，将需要写入文件的内容存入buf中
count： 写入的字节数

返回值：若成功，返回已写的字节数；若出错，返回-1

其返回值通常与参数count的值相同，否则表示出错。write出错的一个常见原因是磁盘已写满，或者超过了一个给定进程的文件长度限制。
对于普通文件，写操作从文件的当前偏移量处开始。如果在打开该文件时，指定了 O_APPEND 选项，则在每次写操作之前，将文件偏移量设置在文件的当前结尾处。在一次成功写之后，该文件偏移量增加实际写的字节数。

1.8、函数 fopen

FILE *fopen(char *filename, *type);

参数：
filename： 文件名称
mode：     打开模式：
					r   只读方式打开一个文本文件                           
			        rb  只读方式打开一个二进制文件                         
			        w   只写方式打开一个文本文件                           
			        wb  只写方式打开一个二进制文件                         
			        a   追加方式打开一个文本文件                           
			        ab  追加方式打开一个二进制文件                         
			        r+  可读可写方式打开一个文本文件                       
			        rb+ 可读可写方式打开一个二进制文件                     
			        w+  可读可写方式创建一个文本文件                       
			        wb+ 可读可写方式生成一个二进制文件                     
			        a+  可读可写追加方式打开一个文本文件                   
			        ab+ 可读可写方式追加一个二进制文件    
返回值：返回一个文件指针

open和fopen的区别：

  • 前者属于低级IO，后者是高级IO。
  • 前者返回一个文件描述符，后者返回一个文件指针。
  • 前者无缓冲，后者有缓冲。 前者与 read，write 等配合使用， 后者与 fread, fwrite等配合使用。
  • 后者是在前者的基础上扩充而来的，在大多数情况下，用后者。

1.9、函数 fwrite

例程

1 、打开一个文件，如果文件不存在则创建

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>

int main()
{
    int fd;

 // 如果file1文件不存在则会创建file1文件，如果存在open函数会返回-1
    fd = open("./file1", O_RDWR | O_CREAT | O_EXCL, 0x600);	//0600 代表可读可写权限
    if(fd == -1)                         // O_EXCL 文件存在则返回-1
        printf("file exist!!!\n");
    else
        printf("file creat succeed!!!\n");
        
    return 0;
}

2、在文件末尾添加数据，不改变原本内容！！！

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>

int main()
{
    int fd;
    char *buf = "welcom to Linux !!!";

    /* 
    	O_RDWR    是从文件的开头开始写入，并覆盖原有的内容
		O_APPEND  在文件末尾处写入，不改变原有内容
		O_TRUNC   在清除文件的数据，并头开始写入
	*/

    fd = open("./file1", O_RDWR | O_APPEND); // 可读可写，光标移动至尾端
    printf("open file success!!!\n");

    int n_write = write(fd, buf, strlen(buf));
    
    if(n_write != -1)
        printf("write %d byte to file\n", n_write);
        
    close(fd);
    return 0;
}

3、创建一个文件

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>

int main()
{
	int fd;
	char *buf = "Hello Linux World";

	fd = creat("./file2", S_IRWXU);     // 创建文件，权限是可读可写可执行
	
   /************************************** 
    *常见创建模式（mode）：                 vi 
	* 宏表示		数字		              
	* S_IRUSR   4        可读                
	* S_IWUSR   2		 可写             
	* S_IXUSR   1        可执行
	* S_IRWXU   7        可读可写可执行
	**/
	
	write(fd, buf, strlen(buf));        // 写入文件

	return 0;
}

4、打开text文件，若没有该文件则创建。 之后在text中写入数据，最后在读取出来显示在屏幕并计算数据大小。

#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int 
main()
{
	int fd;
	char *Write_buf = "Welcom to Linuix\n";
	
	fd = open("./test", O_RDWR | O_APPEND);	// 写入的内容在尾端直接添加
	if(fd == -1)
	{
		printf("open file fiale!!!\n");
		fd = open("./test", O_RDWR | O_CREAT | O_APPEND, 0600);
		if(fd > 0)
			printf("creat file success!!!\n");
		else
		{
			printf("creat file faile!!!\n");
			exit(0);
		}
     }

	int byte = write(fd, Write_buf, strlen(Write_buf)); // 写入的大小，单位字节
	printf("write file %d byte\n", byte);

	char *read_buf = (char *)malloc(sizeof(char) * byte);	// 申请空间
// 由于偏移量在尾端，需要往前移动，具体移动多少？
	lseek(fd, -byte, SEEK_END);		// 在末尾写入多少我们就往前移动多少，最后读取写入的内容

	byte = read(fd, read_buf, strlen(Write_buf));
	
	printf("read:%s\nread Byte:%d\n",read_buf, byte);	// 输出写入的内容

	close(fd);	// 一定要记得关闭
	return 0;
}

5、获取一个文件中内容的字节数

#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int
main()
{
	int fd;
	fd=open("test",O_RDWR);
	char *write_buf="hello linux!";
	if(fd==-1)
	{
		printf("no file\n");
		fd=open("test",O_RDWR|O_CREAT,0600);
		if(fd > 0)
			printf("file creat success\n");
		else if(fd == -1)
		{
			printf("file creat failt! \n");
			exit(0);
		}
	}
	printf("fd=%d\n",fd);
	int size=lseek(fd,0,SEEK_END);	// 获取字节数
	printf("file size=%d\n",size);
	close(fd);
	return 0;
}

6、实现复制文件cp指令

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>

int main(int argc, char **argv)
{
    int fdSrc;
    int fdDes;
    char *readBuf = NULL;	// 定义野指针

    if(argc != 3)
    {
        printf("pararn error!!!\n");
        exit(-1);
    }
    fdSrc = open(argv[1], O_RDWR);
    int size = lseek(fdSrc, 0, SEEK_END);   // 计算字节大小
    lseek(fdSrc, 0, SEEK_SET);              // 把光标移动至开头
    // 申请空间内存
    readBuf = (char *)malloc(sizeof(char) * size + 8);   // 加上8个字节为了防止溢出的可能
    int n_read = read(fdSrc, readBuf, size);	// 有多少字节读取多少字节
    // O_TRUNC 的存在使得先清空再写入数据
    fdDes = open(argv[2], O_RDWR | O_CREAT | O_TRUNC, 0600);
    int n_write = write(fdDes, readBuf, strlen(readBuf));

    close(fdSrc);
    close(fdDes);
    return 0;
}

7、从键盘上获取数据，并输出数据

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>

int main()
{
    int fd;
    char readBuf[128];
    
/*
	0	标准输入
	1	标准输出
	2	标准错误

*/
	// 读取键盘的输入
    int n_read = read(0, readBuf, 10);		// 标准输入
    int n_write = write(1, readBuf, strlen(readBuf));
    return 0;
}

8、向file1文件中添加整型数，并输出写入文件中的数字

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>

int main()
{
    int fd;
    int data = 100;
    int data2 = 0;

    fd = open("./file1", O_RDWR);
    int n_write = write(fd, &data, sizeof(int));
    lseek(fd, 0, SEEK_SET);
    int n_read = read(fd, &data2, sizeof(int));

    printf("read %d \n", data2);
    close(fd);
    
    return 0;
}

9、向文件中写入一个结构体

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>

typedef struct
{
    int a;
    char c;
}Data;

int main()
{
    int fd;
    /*定义结构体*/
    Data data = {100, 'c'};
    Data data2;   
    
    fd = open("./file1", O_RDWR);
    // 将data数据写入file1文件中
    int n_write = write(fd, &data, sizeof(Data));
    // 光标回到开头
    lseek(fd, 0, SEEK_SET);
    // 将file1中的数据读取到data2中
    int n_read = read(fd, &data2, sizeof(Data));

    // 输出data2的数据
    printf("read %d,%c \n", data2.a, data2.c);
    close(fd);
   
    return 0;
}

10、fopen函数的用法

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int main()
{
    FILE *fp;
    char *str = "welcom to LINUX!!!";
    char *readBuf = NULL;	// 定义野指针
    fp = fopen("./jian.txt","w+");

//  size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream);
    /**
     * 参数：
     * *ptr    代表 缓冲区地址
     * size    代表 写入长度
     * nmemb   代表 写入字节的长度
     * stream  代表 哪个文件
     */
    fwrite(str, sizeof(char), strlen(str), fp);		// 写入数据（光标在末尾）
//  fwrite(str, sizeof(char)*strlen(str), 1, fp);
    int size = fseek(fp, 0, SEEK_END);			// 获取长度
    fseek(fp, 0, SEEK_SET);				// 移动光标至开头
    readBuf = (char *)malloc(sizeof(char)*size + 8);    // 申请空间内存
//  size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);
    fread(readBuf, sizeof(char), strlen(str), fp);	// 读取写入的数据

    printf("read data: %s\n", readBuf);			// 输出读取到的数据

    return 0;
}

二、进程环境

2.1、 main 函数

C程序总是从main函数开始执行。
main函数的原型是：

int main(int argc, char *argv[]);
或
int main(int argc, char **argv);

其中，argc是命令行参数的数目，argv是指向参数的各个指针所构成的数组。

2.2、进程终止

有8种方式使进程停止（termination），其中5种为正常终止

  1. 从main返回
  2. 调用exit
  3. 调用 _exit 或 _Exit
  4. 最后一个线程从启动例程返回
  5. 从最后一个线程调用 pthread_exit

异常终止：

  1. 调用abort
  2. 接到一个信号
  3. 最后一个线程对取消请求做出响应

2.2、退出函数

3个函数用于正常终止一个程序： _exit 和 _Exit 立即进入内核，exit 则先执行一些清理处理，然后返回内核

#include "stdlin.h"

void exit(int status);
void _Exit(int status);

#include "unistd.h"
void _exit(int status);

exit()用来正常终结目前进程的执行，并把参数status返回给父进程,
而进程所有的缓冲区数据会自动写回并关闭未关闭的文件。

mian函数返回一个整型值与该值调用exit是等价的

exit(0);
等价于
return 0；

2.3、C程序的存储空间布局

在这里插入图片描述

  1. 正文段。这是由CPU执行的机器指令部分。通常，正文段是可共享，所以即使是频繁执行的程序在存储器中也只需有一个副本，另外，正文段常常是只读，以防止程序由于意外而修改其指令。
  2. 初始化数据段。通常将此段称为数据段，它包含了程序中需明确地赋初值的变量。例如， int max = 100；
  3. 未初始化数据段。通常将此段称为bss段，在程序开始执行之前，内核将此段中的数据初始化为0或空指针。例如，int max[100]；
  4. 栈。自动变量以及每次函数调用时所需保存的信息都存放在此段中，通常函数中的局部变量存放在栈中。函数中的形参是不会分配具体的空间，当函数被调用的时候，具体给出的参数，也就是实参，其实是一份拷贝，它的内存空间在该函数的堆中进行分配。
  5. 堆。通常在堆中进行动态存储分配，通常在堆中进行动态存储分配，它的大小并不固定，可动态扩张或缩减。当进程调用malloc/free等函数分配内存时，新分配的内存就被动态添加到堆上（堆被扩张）/释放的内存从堆中被剔除（堆被缩减）
点灯master
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
嵌入式Linux软件数据参数存储的方法
08-19
文章简单介绍了嵌入式Linux软件数据参数存储的方法
北京讯为 嵌入式linux开发指南
05-25
北京讯为 嵌入式linux开发指南
嵌入式 Linux 入门（一、Linux 基本介绍及文件结构）
热门推荐
不浮夸，不将就，认真对待学知识的我们
06-29 3万+
嵌入式 Linux入 门第一课，嵌入式 linux 基础说明以及 Linux 文件结构。
嵌入式入门——Linux学习基础（1）
Retrograde0805的博客
07-06 2288
本博客记录了嵌入式定义概念、以Ubuntu为例的Linux入门基础操作及目录操作，附录含命令行补全、通配符、修改Ubuntu的root密码方式。
嵌入式学习之Linux
我智商开挂的博客
05-29 2147
2）vi拷贝与粘贴命令。3）vi保存和退出命令。1）vi模式切换命令。
Linux嵌入式基础知识
PtaQ的博客
05-16 2204
该目录下存放的是设备与设备接口的文件，设备文件是Linux中特有的文件类型，在Linux系统下，以文件的方式访问各种设备，即通过读写某个设备文件操作某个具体硬件。该目录下存放系统命令，即只有系统管理员（俗称最高权限的root）能够使用的命令，系统命令还可以存放在/usr/sbin,/usr/local/sbin目录下，/sbin目录中存放的是基本的系统命令，它们用于启动系统和修复系统等，与/bin目录相似，在挂接其他文件系统之前就可以使用/sbin，所以/sbin目录必须和根文件系统在同一个分区中。
嵌入式Linux开发教程(上册) +嵌入式Linux开发教程(下册)（周立功）
12-02
嵌入式Linux开发教程(上册) +嵌入式Linux开发教程(下册)（周立功）PDF高清版 主要讲述嵌入式 Linux 产品开发过程中的内核/驱动开发部分相关内容，包括 Linux 内核裁剪定制、驱动编写和驱动移植等
嵌入式Linux总结
05-03
嵌入式 Linux 总结 笔记 嵌入式 Linux 总结 笔记 嵌入式 Linux 总结 笔记
嵌入式Linux开发教程
03-07
本篇主要讲述进行嵌入式 本篇主要讲述进行嵌入式 本篇主要讲述进行嵌入式 本篇主要讲述进行嵌入式 本篇主要讲述进行嵌入式 本篇主要讲述进行嵌入式 Linux 开发所必备的基础知识， 以实用和够为标准进行介绍开发所...
imx6ull嵌入式linux驱动开发指南pdf（正点原子）
05-21
imx6ull嵌入式linux驱动开发指南pdf（正点原子）
什么是嵌入式linux？
轩辕霸天L
07-12 1147
开发平台：嵌入式Linux开发通常在计算机上进行，使用主机操作系统（如Linux、Windows或Mac）作为开发环境。通过系统定制，可以实现系统的最优性能和资源利用。对于嵌入linux，了解不多，朴素地理解是将linux系统烧录到嵌入式设备，如stm32等，使得stm32上能够运行linux系统及其相关应用。通常所说的嵌入式Linux开发是指在嵌入式系统中使用Linux操作系统进行应用程序开发和系统定制的过程。嵌入式Linux系统基于Linux内核，但通常会进行定制和裁剪，以适应特定设备的要求。
【超全面】Linux嵌入式干货学习系列教程
修成真的博客
06-06 3万+
博主学习Linux也有几个月了，在这里为广大朋友整理出嵌入式linux的学习知识，希望对大家有所帮助，当然博主也只是个初入嵌入式领域的初学者，有问题的地方希望大家指出，在此祝大家学习顺利。............
嵌入式linux 必懂概念科普篇
small_po_kid的博客
07-02 1496
嵌入式linux 应用编程入门应用编程概念系统调用是什么？应用编程、裸机编程、驱动编程概念文件 I/O 操作文件i/o的系统调用函数文件管理文件描述符的由来什么是空洞文件？原子操作与竞争冒险标准 I/O 库标准 I/O 库与文件 I/O 的区别FILE 指针I/O 缓冲文件 I/O 的内核缓冲标准 I/O 库的缓冲文件属性与目录Linux 系统中的文件类型文件属主符号链接（软链接）与硬链接目录系统信息与系统资源时间的概念GMT 时间UTC 时间时区proc 文件系统信号基本概念信号的目的是用来通信的信号由谁
嵌入式Linux系统开发笔记（七）
SudekiMing的博客
06-19 5699
嵌入式Linux U-Boot基础
学习嵌入式——第二弹，了解linux
ascii_kly的博客
07-03 161
Linux 系统是一个开源免费的多用户多任务操作系统。无操作系统阶段(手工操作与脱机输入/输出)—>单道批处理系统—>多道批处理系统（多道程序设计)。简单介绍一下：无操作系统阶段具有用户独占计算机资源、资源利用率低以及CPU等待等人工操作的特点。单道批处理系统是操作系统的前身，具有自动性、顺序性和单道性。多道批处理系统的主要运行特点就是多道、在宏观上并行，在微观上串行（实际上，内存中的多道程序轮流占用CPU,交替运行。
什么是嵌入式、LINUX以及LINUX基本命令
qq_63431486的博客
12-03 1150
什么是嵌入式、LINUX的基本知识和命令
嵌入式之Linux基础
m0_55939438的博客
02-27 320
嵌入式之linux基础今日查阅摘要
嵌入式知识1
linlin_x的博客
01-16 592
ARM公司把ARM11之后的基于ARM Cortex-R内核和ARM Cortex-M内核的系列处理器称为嵌入式处理器
嵌入式linux如何掉电保护,嵌入式系统掉电保护方案设计
weixin_28907247的博客
05-11 965
在嵌入式系统设计过程中，系统的掉电保护越来越受到重视。本文介绍的方法是在用ARM7系列芯片S3C4510B和μClinux构建的嵌入式平台上实现的。整个掉电保护实现的基本思路是：产生掉电信号，捕捉掉电信号和处理掉电信号。重点介绍这个过程的具体实现。系统防掉电设计的目的是：采用一种机制，使得系统在意外失去供电的情况下，可以保证系统运行状态的确定性以及记录数据的完整性;当系统供电恢复后，现场数据可以及...
嵌入式linux架构
最新发布
10-01
嵌入式Linux架构是指将Linux操作系统应用于嵌入式设备的一种系统架构。嵌入式设备是指那些在特定功能下运行的小型电子设备，如智能手机、家电、车载系统等。嵌入式Linux架构经过特殊的定制和优化，使其适应嵌入式...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值