嵌入式学习笔记1

1、linux系统：

linux系统的特点

1）软硬件一体化，集计算机技术、微电子技术、行业技术与一体；

2)需要操作系统支持，代码小，执行速度快；

3）专用产品，用途固定，成本敏感；

4）可靠性要求高；

5）多样性，应用广泛，种类繁多。

linux文件系统结构：先有目录再有分区，像一颗倒置的树

windows文件系统：先有分区，再有目录

shell命令：

ls，---列出当下目录的内容

cd

cd+目录名---切换当前的工作目录

cd ..------------返回上一级目录

cd../..----------返回上一级的上一级目录

cd~-------------返回家目录

..----------------上一级目录

.-----------------当前目录

Touch文件名---创建文件

rm+文件名-----删除文件

mkdir目录名—创建目录

rm -r目录名----删除目录

man手册

Linux中C程序（c语言编程）步骤：

编辑(vim) ---> 编译、链接(gcc) ---> 执行、调试(./a.out)

1）编辑：vim 文件名(.c) ---创建并打开文件

三种模式：当vim打开文件时，首先进入的是命令模式

命令模式：

i ---进入插入模式

shift + : ---进入底行模式

yy ---复制光标所在的一行

nyy ---复制从光标位置开始的n行5yy ---复制5行

p ---粘贴

dd ---剪切光标所在的一行

ndd ---剪切从光标位置开始的n行5dd ---剪切5行

u ---撤销上一次的操作

ctrl + v + 上下箭头选中+ = ----自动调整代码格式

插入模式：

ESC ---返回到命令模式

底行模式：

w ---保存

q ---退出

wq ---保存并退出

num ---光标直接跳转到num这行

$ ---光标直接跳转到文件最后一行

2）编译、链接：gcc 文件名----默认生成可执行文件a.out

gcc 文件名-o 可执行文件名---指定生成可执行文件的名字

gcc hello.c -o test ---指定生成可执行文件test

3) 执行、调试：./可执行文件

./a.out

./test

2、C语言:

1) 数据的基本类型:

整型：short(2)、int(4)、long(4)、long long(8)

浮点类型(实数) ：float(4)、double(8)

字符型：char(1)

空类型：void

sizeof(变量/类型/表达式/....) ---求...在内存上所占字节数

2) 常量:在程序运行过程中，其值不会发生改变的数据

整型：

十进制：76, 89, 101

八进制：076, 0123

十六进制: 0x123, 0x76, 0xaf

浮点：10.5 3.15e+5 ==>315000

字符型常量:字符常量需要以单引号括起来的单个字节的字符

'c', 'a', '\n'

字符串常量:

"123" "hello" ---字符串常量是以双引号括起来，且以'\0'结尾

3) 变量:在程序运行过程中，其值有可能会发生改变的数据

数据类型变量名;

例：

int a;

float b;

标识符命名规则：

1）由数字、字母、下划线中的一种或多种组成

2）第一个字符不能是数字

3）不能和关键字相同，关键字例如：int, sizeof, for

int a;

int b = 0; //初始化，在定义变量的同时给这个变量赋一个初始值

b = 100; //赋值

4) 输入输出：

printf ---标准格式化输出函数

scanf ---标准格式化输入函数

getchar ---输入一个字符

putchar ---输出一个字符

gets ---输入字符串

puts ---输出字符串

printf("格式化输出串", 变量1, 变量2, ...); ---把变量按照格式输出到屏幕

scanf("格式化输出串", &变量1, &变量2, ...); ---把键盘上输入的数据按格式存放在对应变量中

格式串：

%d --- int

%ld --- long

%lld --- long long

%hd --- short

%u ----无符号整数

%o ----打印八进制整数

%x ----打印十六进制的整数

%f ---float

%lf ---double

%c ---字符

%s ---字符串类型

5) 运算符:

算术运算: + - * / % ++ --

逻辑运算：&& || !

关系运算: > < >= <= == !=

位运算: << >> & | ~ ^

赋值运算: = += -= *=

条件运算符: 表达式1？表达式2 ：表达式3

6)数组:存放具有相同数据类型的多个数据的集合，且在内存上连续存储

数据类型数组名[元素个数];

数组的初始化

int a[10] = {1,2,3,4,5,6,7,8,9,10};

赋值:

数组只能一个元素一个元素依次赋值

访问数组的元素

数组名[下标];

数组名

地址常量，代表的是数组的首地址

1)定义数组：

变量: 数据类型变量名;

数组：数据类型数组名[元素个数];

注：元素个数必须是一个确定的值

int a[10]; //拥有10个int类型数据的数组

char buf[100]//拥有100个char类型数据的数组

2、怎么取数组的元素

数组名[下标]

注：下标取值范围：0 ~ n-1 (n指的是元素个数)

3、初始化：

int a[10] = {1,2,3,4,5,6,7,8,9,10}; //把1-10依次赋值给数组中的a[0]-a[9]

int a[10] = {1,2,3,4,5}; //数组的前5个元素依次为1-5，其余元素为0

int a[10] = {0} //数组的元素全部为0

#include

void *memset(void *s, int c, size_t n); //用c填充s地址的前n个字节

memset(a, 0, sizeof(a)); //用于把数组a清空

4、赋值：在定义之后

int a[10];

只能给数组的元素依次进行赋值，通常循环来做

5、数组名：地址常量，代表的是数组的首地址

7) 字符数组:

数组元素是字符类型的数组

char buf[100] = "hello world!";

strlen: 求字符串长度的函数

strcat：字符串连接函数

strcpy：字符串拷贝函数

strcmp: 字符串比较函数，比较两个字符串的大小

1、定义：char 数组名[元素个数];

2、初始化：

char buf[10] = {'h','e','l','l','o'}; //数组的前5个元素依次为hello,其余元素为'\0'

char buf[10] = "hello";

char buf[10] = "";

3、赋值：

1）输入：gets(char *s); ---从键盘上输入一行字符串存入s中

s ---指的是数组的首地址，也就是数组名

2）输出：puts(const char *s); ---把s字符串打印在屏幕上

s ---指的是数组的首地址，也就是数组名

4、字符串函数

字符串函数头文件：#include

a)strlen: 求字符串的长度

size_t strlen(const char *s);

参数：s ---字符串的首地址

返回值：字符串的长度，不包括末尾的'\0'

b)strcpy: 字符串比较函数

char *strcpy(char *dest, const char *src); ---把src串中所有元素拷贝到dest中去

参数：dest ---目标字符数组的首地址（数组名）

src ---源字符串的首地址

c)strcmp: 字符串比较函数

int strcmp(const char *s1, const char *s2); ---比较s1与s2的大小

参数：s1，s2 ---想要比较的两个字符串的首地址

返回值：

== 0: 两个字符串完全相同

!= 0：两个字符串不相等

8)指针:

数据类型*指针变量名;

&：取变量的地址

*: 取指针指向的内容

指针的运算:

p+n: 指针向地址大的方向移动n个数据

p-n: 指针向地址小的方向移动n个数据

p++：指针向地址大的方向移动1个数据

p--: 指针向地址小的方向移动1个数据

p-q: 指针之间相隔的数据元素个数

1、概念：

地址：内存基本单位(字节)都有一个编号，这个编号就是地址

指针: 地址又称为指针

指针变量: 专门用来存放地址的变量

2、定义：

变量: 数据类型变量名;

指针: 数据类型*指针变量名;

注：数据类型: 指针指向的类型

int a;

int *pa = &a; //pa: int *

char b;

char *pb = &b; //pb: char *

float c;

float *pc; //pc: float *

pc = &c;

3、指针运算符：

&: 取变量的地址的

int a;

&a ----取a的地址

*：取指针所指向的内容

int *a;

int *p = &a;

*p == a

4、直接访问与间接访问

直接访问：直接通过变量名去访问的方式

间接访问：通过指向这个变量的指针（地址）去访问的方式

5、指针的运算:

指针的加减法运算: p指的是地址，n指的是整数

p+n: 指针向地址大的方向移动n个数据

地址量的变化：p + n * sizeof(*p)

p-n: 指针向地址小的方向移动n个数据

地址量的变化：p - n * sizeof(*p)

p++: 指针向地址大的方向移动1个数据

地址量的变化：p + sizeof(*p)

p--: 指针向地址小的方向移动1个数据

地址量的变化：p - sizeof(*p)

注：指针移动看的是指针指向的类型

9)函数：

三要素：定义、声明、调用

函数的传参: 值传递和地址传递

strlen strcpy strcmp printf scanf

1）定义

函数的一般形式：

数据类型函数名(数据类型形参名1, 数据类型形参名2, ...)

{

函数体;

return 返回值;

}

注：函数名前的数据类型指的是函数返回值的类型，如果不需要函数返回值，则

类型设为void，return后不需要值，甚至不需要return语句

函数名尽量贴合函数的功能，望名知义

形参在定义时不会分配空间，而是在函数被调用时才分配空间

return语句用于返回函数，如果函数的返回值类型void，则不需要return语句

封装一个函数的步骤：

a)确定函数的功能

b)根据功能确定函数是否需要返回值，返回值的类型是什么

c)根据功能确定需不需要参数，参数的类型是什么

d)实现函数体

e)如果需要返回值，使用return返回函数

2）声明

数据类型函数名(数据类型形参名1, 数据类型形参名2, ...);

注：只有当函数定义在使用之前(main定义)时不需要声明，否则需要在main定义前加上声明

3）调用

函数名(实参1, 实参2, ....);

返回值类型变量= 函数名(实参1, 实参2, ....); ---获取函数调用的返回值

例：

printf("format", ...);

4）传参

把实参的值依次传递给形参

实参与形参一一对应(个数，类型)

a)值传递

传递的是实参的值，这种只能使用实参的值，而不能修改实参的值

b)地址传递:

传递的是变量的地址值，这种既能使用实参的值，也能修改实参的值

3、数据结构:

算法: 时间复杂度和空间复杂度

数据结构中的逻辑结构：

线性结构、层次结构、图形结构

顺序表：数据在内存上连续存储---增、删、改、查

链表: 数据在内存上是散列存储---增、删、改、查

顺序表与链表的优缺点

数据结构: 指的是数据的逻辑结构和存储结构及其操作;

1）数据的逻辑结构：

线性结构: 里面的数据除了第一个和最后一个，其余元素都只有唯一前驱，唯一后继

第一个数据没有前驱，最后一个没有后继

层次结构(树型结构)：除了第一个数(没有前驱)，其余的数都只有唯一前驱，但可以有多个后继

网状结构(图型)：所有数据都可以有多个前驱和后继

逻辑关系：描述数据与数据之间的关系

2）储存结构: 指的是数据在内存上的存储方式

顺序存储：数据在内存上连续存储

链式存储: 数据在内存上散列存储

3）操作：增、删、改、查等等

2、线性表: 顺序表---线性结构的顺序存储

对线性表的操作：创建空表，增删改查, 排序，倒置, 判空或满etc

4、文件操作:

文件IO标准IO

访问方式：文件描述符文件流(FILE *)

是否有缓存:没有缓存有缓存(全缓冲、行缓冲、无缓冲)

操作的函数: open/close/read/write fopen/fclose/fread/fwrite/fgetc/fputc/fgets/fputs

1、文件IO

Linux上一切皆是文件

文件描述符: 非负整数，当创建或打开文件时会返回一个顺序分配的非负整数，这个整数就是文件描述符，

文件IO就是通过文件描述符来对文件进行操作

一个程序中有3个文件自动打开：

标准输入(键盘): 0

标准输出(屏幕)：1

标准错误输出(屏幕)：2

open: 打开文件

close：关闭文件

read：读

write: 写

lseek: 定位

man 2/3 函数名---查看函数

2、文件API

1、open: 打开文件

#include

#include

#include

int open(const char *pathname, int flags);

int open(const char *pathname, int flags, mode_t mode);

参数：pathname ---路径+文件名,如果是当前目录下的文件则不用加路径

flags --- O_RDONLY ---只读

O_WRONLY ---只写

O_RDWR ---可读写

O_TRUNC ---清空文件

O_APPEND ---追加打开

O_CREAT ---当打开的文件不存在时，创建该文件，并使用第三个参数0777（权限）

返回值：

成功：文件描述符

失败：-1，并设置errno

perror("提示符"); ---打印系统错误信息（只有当函数设置过errno时才能使用）

2、close：关闭文件

#include

int close(int fd);

参数：fd ---文件描述符

返回值：成功：0

失败：-1，并设置errno

3、read: 读取文件内容

#include

ssize_t read(int fd, void *buf, size_t count); //从fd文件中读取count字节存入buf 中

参数:

fd ---文件描述符

buf ---存放读取数据的缓冲区首地址

count ---想要读取的字节数

返回值:

成功:

>0 : 成功读取的字节数

=0 ：读到文件末尾

失败：

-1，并设置errno

打开一个文件，把文件内容读出来并打印到屏幕上

4、write：向文件中写入数据

#include

ssize_t write(int fd, const void *buf, size_t count); //把buf中的count字节写入文件fd 中

参数：

fd ---文件描述符

buf ---存放想要写入数据的缓冲区首地址

count ---想要写入的字节数

返回值：

>0 ---成功写入的字节数

-1 ---失败，设置errno

5、进线程:

1)线程: pthread_create ---线程可以使用全局变量来进行通信

2)进程：

进程与程序的区别?

ps ---查看进程的状态

kill ---向进程发送信号

kill -信号PID ---向进程PID中发送信号

int kill(pid_t pid, int sig); ---向进程pid中发送sig信号

PID ---进程号

PPID ---父进程号

fork ---创建进程的函数

返回值：

<0 ---出错

=0 ---在子进程中

>0 ---在父进程中，且返回值就是子进程的PID号

1、多进程

进程: 是程序的一次执行过程

ps -ef ---查看进程的状态

PID PPID CMD

进程号父进程号命令

进程号: 用于区分不同的进程

kill ---发送信号

kill -l ---列出所有的信号

kill -信号PID ---向PID进程发送信号

例: kill -2 PID --- 2号信号(SIGINT)

2、进程API:

1、fork---创建一个子进程

#include

pid_t fork(void); //typedef

参数:无

返回值:

成功:

>0 ---再父进程中，这个值就是创建的子进程的PID号

=0 ---在子进程中

失败：

-1 ---创建子进程失败，并设置errno

注: fork创建的子进程从fork的下一条语句开始执行

fork创建的子进程与父进程的执行顺序是随机的

进程是资源分配的最小单位，fork创建子进程时会拷贝父进程的空间

2)exit ---退出进程

#include

void exit(int status);

参数: 0

僵尸进程: 当一个进程死亡后，资源还未被完全销毁，这个进程就是僵尸进程(收尸)当子进程死亡后会自动向父进程发送信号SIGCHLD，父进程对这个信号的默认操作是忽略

孤儿进程: 当进程的父进程先子进程死亡，这个进程就是孤儿进程，孤儿进程又会被init(1号进程收养)

6、网络编程:

1）网络编程的预备知识:

a)套接字: 既是一个通用的网络编程接口，也是一种特殊的文件描述符

b)IP地址: 区分不同的主机

ifconfig ---查看本机的IP地址

ping ---网络检测工具，用于检测网络是否连通的

c)端口号: 区分一台主机上的不同任务的（标志进程）

unsigned short

2) TCP编程流程：

服务器:

socket ---创建套接字

bind ---绑定本机地址和端口

listen ---设置监听套接字

accept ---接收客户端的连接，并生成通信套接字

read/write ---收发数据

close ---关闭套接字

客户端：

socket ---创建套接字

connect ----主动连接服务器

write/read ---发收数据

close ---关闭套接字

服务器有2种套接字：

监听套接字---用于监测是否有客户端的连接，并接受链接

通信套接字---只用于跟客户端通信

客户端只有一种套接字

1)预备知识

a、套接字socket

是网络编程的通用的接口socket

也是一种特殊的文件描述符----可以使用文件IO进行操作

b、IP地址: 区分不同的主机

例：192.168.19.45 ---点分形式

IP = 网络号+ 主机号192.168.19.45（IP）255.255.255.0(子网掩码)

网络号: IP & 子网掩码192.168.19.0

主机号: IP & (~子网掩码)0.0.0.45

在同一局域网内，所有主机网络号相同，主机号不同

linux中查看IP：

ifconfig ---查看IP地址

eth0：192.168.19.96

lo ：127.0.0.1 ---只能用于本机通信, 用于测试

ping ---用于网络监测的工具

ping ip

虚拟机网络配置:

虚拟机中--》编辑--》虚拟网络编辑器--》选择桥接模式(管理员身份运行虚拟机)-->桥接到window所用的网卡

点击ubuntu的网络图标-->Edit connections-->点击网络(edit)--->

-->Wired（eth0）--》IPV4 settings（Automatic(DHCP)）--->save

点击ubuntu的网络图标-->选中刚刚配置的网络(重新连接)

ifconfig查看IP是否与windowsIP再同一网络,如果再，则使用ping命令查看是否和windows相通,

ping不同，则关闭windos防火墙

c、端口号: 区分同一主机不同的任务

unsigned short 1 - 65535

可用: 5001 ~ 65565

3、网络编程TCP流程: c/s架构

服务器(server) 客户端(client)

socket ---创建套接字socket ---创建套接字

bind ---绑定本机IP地址和端口

listen ---设置监听套接字connect ---主动向服务器发起连接请求

accept ---接收客户端的连接

------------------------------------------------------------------------------

read/write ---收发数据write/read ---发收数据

close ---关闭套接字close ----关闭套接字

4、网络编程API:

1)socket ---创建套接字

#include /* See NOTES */

#include

int socket(int domain, int type, int protocol);

参数:domain --- AF_INET

type --- SOCK_STREAM (可靠通信)

protocol --- 0

返回值:

成功：套接字文件描述符

失败：-1，并设置errno -- perror

2) bind ---绑定本机地址和端口

#include

#include

int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

参数：sockfd ---套接字文件描述符

addr ---本机地址和端口

addrlen ---地址长度

返回值：

成功：0

失败：-1，使用perror查看错误原因

通用地址结构

struct sockaddr

{

u_short sa_family; // 地址族, AF_xxx

char sa_data[14]; // 14字节协议地址

};

Internet协议地址结构

struct sockaddr_in

{

u_short sin_family; // 地址族, AF_INET，2 bytes

u_short sin_port; // 端口，2 bytes

struct in_addr sin_addr; // IPV4地址，4 bytes

char sin_zero[8]; // 8 bytes unused，作为填充};

IPv4地址结构

// internet address

struct in_addr

{

in_addr_t s_addr; // u32 network address

};

例：

struct sockaddr_in myaddr;

memset(&myaddr, 0, sizeof(myaddr));

myaddr.sin_family = AF_INET;

myaddr.sin_port = htons(8888);

myaddr.sin_addr.s_addr = inet_addr("192.168.3.254");

3) listen ---设置监听套接字

int listen(int sockfd, int backlog);

参数：

sockfd ---套接字文件描述符

backlog ---监听队列长度，大于0的整数

返回值：

成功：0

失败：-1，使用perror查看错误原因

4) accept ---接收客户端连接

int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

参数：sockfd ---套接字文件描述符

addr ---客户端的地址结构

addrlen ---客户端地址长度

当不想知道是哪个客户端时，此时addr和addrlen可设置为NULL

返回值：

成功：通信套接字文件描述符

失败：-1，使用perror查看错误原因

服务器有两种套接字:

1、监听套接字---监听是否有客户端链接，并建立连接使用的

2、通信套接字---用于与连接成功的客户端通信的(接收数据与发送数据)

5) connect ---主动向服务器发起连接请求

int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen); //服务器地

址

参数：sockfd ---套接字文件描述符

addr ---服务器地址和端口

addrlen ---服务器地址长度

返回值：

成功：0

失败：-1，使用perror查看错误原因

网络编程中遇到问题的解决办法:

1、问题:

farsight@ubuntu:~/Liuj/panzh/pan2/3-31$ ./client

socket...............

connect: Connection refused

解决：

因为服务器没开，首先检查服务器是否开启，如果已经开启，仍然出现这个问题，首先服务器ping客户端

如果ping通还是出现这个错误，那就是你的服务器与客户端不匹配(IP, PORT)

2、

问题:

farsight@ubuntu:~/Liuj/panzh/pan2/3-31$ ./server

socket...........

bind: Address already in use

解决: 首先检查客户端是否关闭

a) 等待30s ~ 2分钟

b) 修改服务器与客户端上的服务器的端口号

3、

问题:

farsight@ubuntu:~/Liuj/panzh/pan2/3-31$ ./server

socket...........

bind: Cannot assign requested address

解决:

bind函数绑定的IP地址不对，重新ifconfig查看自己的IP进行设置

注: 网络编程执行过程中:

服务器先执行，客户端后执行

客户端先关闭，再关闭服务器

网络编程过程中，发送与对应接收的字节数应该匹配(一样)