server-monitor v1.0

mqtt服务器默认端口：127.0.0.1：1883

主题：server-status，5秒钟采集一次发送到服务器

以上都是默认配置可自己修改源码

• 通过C语言实现的采集内存、cpu使用情况、cpu温度、硬盘温度。

• cpu温度通过读取linux内核伪文件获得:”/sys/class/hwmon/hwmon1/temp3_input”。

• 硬盘温度通过通过Smartmontools api获取。

• CPU使用率通过读取linux内核伪文件计算获得：”/proc/stat”。

• 内存使用率通过读取linux内核伪文件计算获得：”/proc/meminfo”。

需要安装的依赖：mosquitto客户端、emqx或mosquitto服务器、Smartmontools ，测试基于centos7.9

运行效果：

• shell启动命令：

1

nohup /opt/server-monitor/server-monitor_v1.0_x64/server-monitor /dev/sdb &

源码地址： http://gitea.880755.xyz/private/server-monitor.git

Web体验地址： http://nodeui.880755.xyz/

vscode使用

• 光标移动操作

1.打开命令面板：Ctrl shift + P或者F1

2.光标回到行首：home键

3.光标回到行尾：end键

4.回到文档最开始: Ctrl + home

• 复制、粘贴、注释

1.复制光标所在的行：alt + shift + 上/下，上：光标不动，下：光标移到新行

2.单行注释：shift + /

3.多行注释：alt + shift + a

4.删除光标所在行：alt + shift + k或者Ctrl + x，效果和vim的dd一样

• 代码格式化

1.代码格式化：shift + alt + f

• 批量操作

1.点出多个光标：alt + 鼠标左键

2.选中代码段行末生成光标：alt + shift + i

• 插件推荐

1.简体中文插件

2.自动重命名标签：Atuo Rename Tag（针对html标签语言）

3.右键运行代码：Code Runner，js文件

4.右键用浏览器打开：Open in Browser，html文件

5.右键文件自动加入.gitignore文件：gitignore 1.0.1，如果没有.gitignore文件生成一个.gitignore

6.快速粘贴剪贴板的图片到.md文件：Paste Image ，快捷键：Ctrl + alt + v

7.VScode图标：vscode icons，推荐

8.快速对类和函数添加注释：Document This，快速按两次Ctrl + alt + d

9.函数或文件注释：KoroFileHeader，光标处添加注释：ctrl + alt + t，文件开头添加注释：ctrl + alt + i

10.自动补齐sql语句：Language PL/SQL

• 自定义代码片段

事先定义一段代码通过关键字触发自动补齐代码

设置示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

"函数注释": {
	"scope": "c,c++",  // 生效的语言类型
	"prefix": "nfuction",  // 触发代码片段的关键字
	"body": [
		"/**"
		"* @description: 函数作用描述"
		"* @param {*}参数："
		"* @return {*}返回值"
		"* @author hyl"
		"* @data 2021/05"
		"*/
		$1"	// 光标位置
	],
	"description": "函数注释"
}

"结构体注释": {
	"scope": "c,c++",  // 生效的语言类型
	"prefix": "nstruct",  // 触发代码片段的关键字
	"body": [
		"/*"
			"* obj desc:$1"
			"*/"
		"$2"  // 按tab键后光标位置
	],
	"description": "结构体注释"
}

分层和面向对象的编程思想

四种IO模型

• 非阻塞IO

1.read()如果没有数据就直接返回一个错误码。

• 阻塞IO

1.read()如果没有数据，进程就被挂起直到有数据到来被唤醒。

• IO多路复用

1.将一个进程或线程中多处会同时阻塞的地方，添加到一个阻塞合集（文件描述符集合或与事件），然后通过这个集合在一个地方阻塞

2.集合中有一个或多个子集有数据到来时唤醒进程或线程，然后依次检查是哪个子集有数据到来，并处理有数据到来的子集。

• 异步信号驱动IO（模拟硬件中断方式）

1.在需要阻塞的地方，通过将文件描述符和一个（回调）函数绑定，事件到来时会自动执行回调函数，在回调函数中通知本该阻塞的进程。

2.进程收到通知执行对应的读写数据操作。

会有一个进程实时的去查询是否有数据到来，有数据到了就通知本该阻塞的进程。效果：本该阻塞的进程可以不受影响的去执行自己的事情，有数据来就去处理数据。

attribute((section(x))) 使用详解

• 有如下变量声明：

__attribute__：设置属性， section：属于哪个输入段

1
2
3
4
5
6
7
8
9
10

#define SECTION(x)                  __attribute__((section(x)))
typedef int (*init_fn_t)(void);

int fun_test(void)
{
    return 0;
}

// 表示把 my_fun 这个变量放到输入段.fn_cmd.0.end中
const init_fn_t my_fun SECTION(".fn_cmd.""0.end") = fun_test;

• 编译代码可以在.map文件确实生成了输入段：”.fn_cmd.””0.end”，并且这个输入段中有一个变量fun_test

• 再添加一个变量到输入段

1
2
3
4
5
6
7

int fun_test1(void)
{
    return 0;
}

// 表示把 my_fun 这个变量放到输入段.fn_cmd.0.end中
const init_fn_t my_fun1 SECTION(".fn_cmd.""0.end") = fun_test1;

可以看到在相同代码端的变量保存在内存中的地址是连续的。（keil的.map文件没有显示地址，但其实他们的地址是连续的）

• 再有如果定义多个输入段它们在内存中排列的顺序是怎么样的：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

int fun_test1(void)
{
    return 0;
}

int fun_test2(void)
{
    return 0;
}

int fun_test3(void)
{
    return 0;
}

int fun_test4(void)
{
    return 0;
}

int fun_test5(void)
{
    return 0;
}


#define SECTION(x)                  __attribute__((section(x)))
typedef int (*init_fn_t)(void);

const init_fn_t my_fun1 SECTION(".fn_cmd.""1") = fun_test4;
const init_fn_t my_fun2 SECTION(".fn_cmd.""2") = fun_test2;
const init_fn_t my_fun3 SECTION(".fn_cmd.""2") = fun_test3;
const init_fn_t my_fun4 SECTION(".fn_cmd.""3") = fun_test1;

• 根据输入段在内存中排列的顺序是按输入段名字的大小可以这样调用这些函数

1
2
3
4
5
6
7
8

// my_fun1是属于.fn_cmd.1输入段的
// my_fun4是属于.fn_cmd.3输入段的
// .fn_cmd.1 --> .fn_cmd.2 -- > .fn_cmd.3
init_fn_t *pfn;  
for (pfn = &my_fun1; pfn <= &my_fun4; pfn++)  // 四个函数被全部调用了一遍
{
    (*pfn)();
}

• 再用宏定义的方式改进下上面的代码（实现类似rtthread里面用到的）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

#define SECTION(x)                  __attribute__((section(x)))
typedef int (*init_fn_t)(void);

#define INIT_COMM(fn, level)   const init_fn_t _init_##fn SECTION(".fn_cmd."level) = fn;

#define INIT_1(fn)  INIT_COMM(fn, "1") 
#define INIT_2(fn)  INIT_COMM(fn, "2") 
#define INIT_3(fn)  INIT_COMM(fn, "3") 


int fun_init0_end(void)
{
    return 0;
}
INIT_COMM(fun_init0_end, "0.end");
    
int fun_init1_end(void)
{
    return 0;
}
INIT_COMM(fun_init1_end, "1.end");

int fun_init2_end(void)
{
    return 0;
}
INIT_COMM(fun_init2_end, "2.end");

int fun_init3_end(void)
{
    return 0;
}
INIT_COMM(fun_init3_end, "3.end");



/*******************************************************************************************************/
// 用户代码中使用
int demo1(void)
{
    printf("%s\n", __FUNCTION__);
    return 0;
}
INIT_1(demo1);  // 定义一个属于.fn_cmd.1的变量保存demo1这个内容

int demo2(void)
{
    printf("%s\n", __FUNCTION__);
    return 0;
}
INIT_2(demo2);  // 定义一个属于.fn_cmd.2的变量保存demo2这个内容

int demo3(void)
{
    printf("%s\n", __FUNCTION__);
    return 0;
}
INIT_3(demo3);  // 定义一个属于.fn_cmd.3的变量保存demo2这个内容

/*******************************************************************************************************/
// 用户代码中调用输入段.fn_cmd.1中的所有函数
init_fn_t *pfn;  
for (pfn = &_init_fun_init0_end; pfn <= &_init_fun_init1_end; pfn++) 
{
    (*pfn)();
}

// 用户代码中调用输入段.fn_cmd.2中的所有函数  
for (pfn = &_init_fun_init1_end; pfn <= &_init_fun_init2_end; pfn++) 
{
    (*pfn)();
}

// 用户代码中调用输入段.fn_cmd.3中的所有函数  
for (pfn = &_init_fun_init2_end; pfn <= &_init_fun_init3_end; pfn++) 
{
    (*pfn)();
}

小结：rtthread里面的组件初始化原理：在用户函数定义的地方，通过宏顺便定义一个函数指针指向这个函数，但只是顺便定义的这个函数指针给它设置了一个属性让它属于指定的某个输入段，利用属于输入段的变量在内存上存放地址是连续的这一特性，通过开头和结束变量找到这整个输入段的所有变量，而这些变量里面保存的就是我们通过宏设置进去的那些函数入口地址。

Makefile基本语法

1.make工程管理器

• make是一个工程管理器，类似于kile、iar等，只不过make没有图形界面，也不提供代码编辑功能。
• Make工程管理器也就是个“自动编译管理器”，它能够根据文件时间戳自动发现更新过的文件而减少编译的工作量,同时,它通过读入Makefile文件的内容来执行大量的编译工作。

Make将只编译改动的代码文件,而不用完全编译

makefile

Makefile是Make读入的唯一配置文件

makefile基本结构

• 由make工具创建的目标体(target) ,通常是目标文件或可执行文件
• 要创建的目标体所依赖的文件(dependency file)
• 创建每个目标体时需要运行的命令(command)

注意:命令行前面必须是一个” TAB键”,否则编译错误为:*** missing
separator. Stop.

makefile语法示例1：

1
2
3
4
5
6

# Makefile格式
target: dependency_files
<TAB> command
# 例子
hello.o : hello.c hello.h
	gcc -c hello.c -o hello.o

makefile语法示例2：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

test: f1.o f2.o              # make从第一行开始执行
	gcc f1.o f2.o main.o -o test
f2.o: f2.c					# ：前面是目标文件，：后面是生成目标文件需要的依赖文件
	gce -c -Wall f2.c -o f2.o
f1.o: f1.c
	gce -c -Wall f2.c -o f2.o
main.o: main.c
	gce -c -Wall main.c -o main.o
.PHONY:clean				# 伪目标
clean:						
	rm *.o test
# 注释:-Wall :表示允许发出gcc所有有用的报警信息
# -c:只是编译不链接,生成目标文件".o"
# -o file:表示把输出文件输出到file里
# -O 优化等级

1.make不带参数默认从makefile的第一行开始执行语句，make发现需要生成test的目标，而生成test需要的依赖三个文件f1.o、f2.o和main.o，所以make需要先得到这三个依赖文件，会去先执行生成这三个目标文件的语句，最后通过f1.o、f2和main.o依赖文件生成test这个目标文件。

2.make带参数，例如：make clean、make f1.o则跳过其它目标生成直接执行clean这个目标。

3.伪目标：为防止目标名字和文件名字重名。

make执行步骤：

自动编译原则：当依赖文件比目标文件的时间戳新，或者只有依赖文件没有目标文件，就需要通过依赖文件（重新）生成目标文件。

检查makefile是否有语法错误：

只打印要执行的命令，但不执行这些命令：make -n

make识别的文件名字：makefile、Makefile、MAKEFILE不区分字母大小写

2.makefile语法中的变量

• 创建变量的目的 : 用来代替一个文本字符串，减少语法出错率，增加可读性

1.系列文件的名字
2.传递给编译器的参数
3.需要运行的程序
4.需要查找源代码的目录
5.你需要输出信息的目录
6.你想做的其它事情。

• 变量定义的两种方式

1.递归展开方式：VAR=var
2.简单方式：VAR: =var

• 变量使用

$(VAR)

makefile中的变量类似与C语言的宏，起简单的替换作用，用$$表示使用$变量

• 使用变量的makefile示例：

1
2
3
4
5
6
7
8
9
10
11
12
13

OBJS = f1.o f2.o	# 定义一个变量后面就可以通过$(OBJS)来代替f1.o f2.o
CC = gcc
CFLAGS = -Wall -O -g

test: $(OBJS)
	$(CC) $(OBJS) -o test
f1.o : f1.c f1.h
	$(CC) $(CFLAGS) -c f1.c -o f1.o
f2.o : f2.c f2.h
	$(CC) $(CFLAGS) -c f2.c -o f2.o
.PHONY:clean
clean:
	rm *.o test

• 递归展开的变量VAR=var：变量可以先使用再定义

例子：

1
2
3
4
5

foo= S(bar)
bar =$(ugh)
# ugh = Huh?
# $ (foo)的值为?
# echo $(foo)来进行查看

优点: 它可以先使用后定义。
缺点: 不能对该变量进行任何扩展。

例如：
CFLAGS = $(CFLAGS) -O 会造成死循环

• 简单方式定义变量VAR: = var ：更接近C语言中的变量

例子：

1
2
3
4
5
6

m:=mm
x:=$(m)
y:=$(x) bar
x:= later
echo $(x) $(y)
# 看看打印什么信息?

简单定义变量的方式更适合在大的编程项目中使用,因为它更像我们一般的编程语言

• 用?=定义变量：

makefile中需要使用别人写的makfile时会用到，不知道一个变量是否被别的makefile已经定义了。

1
2

dir:= /foo/bar
FOO?= bar	# 如果FOO之前没有被定义过，则定义FOO变量为bar，否则忽略该行语句

不使用?=上面代码等价代码：

1
2
3

ifeq ($(origin FOO), undefined)
FOO = bar
endif

• makefile的变量类似于C语言的字符串：可以对一个变量追加内容

1
2
3
4

# 为变量添加值
# 你可以通过+为已定义的变量添加新的值
Main= hello.o hello1.o
Main+= hello2.o

• make管理器预定义变量：自己也可以重新定义这些变量的值

变量带默认值：

AR 库文件维护程序的名称,默认值为ar.AS汇编程序的名称,默认值为as。
CC C编译器的名称,默认值为cc.CPP C预编译器的名称,默认值为$(CC) -E
CXX C++编译器的名称,默认值为g++。
FC FORTRAN编译器的名称,默认值为f77
RM 文件删除程序的名称,默认值为rm-f

变量不带默认值：

ARFLAGS 库文件维护程序的选项,无默认值。
ASFLAGS 汇编程序的选项,无默认值。
CFLAGS C 编译器的选项,无默认值。
CPPFLAGS C预编译的选项,无默认值。
CXXFLAGS C+编译器的选项,无默认值。
FFLAGS FORTRAN 编译器的选项,无默认值。

• 自动变量：在某个特定的语句中变量自动代表相应的内容

$* 不包含扩展名的目标文件名称
$+ 所有的依赖文件,以空格分开,并以出现的先后为序,可能包含重复的依赖文件
$< 第一个依赖文件的名称
$? 所有时间戳比目标文件晚的的依赖文件,并以空格分开
$@ 目标文件的完整名称
$^ 所有不重复的目标依赖文件,以空格分开
$% 如果目标是归档成员,则该变量表示目标的归档成员名称

带自动变量、预定义变量、自定义变量的示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

OBJS= f1.o f2.o    # OBJS是自定义变量
OBJS+= main.o      # 为变量追加内容
CFLAGS= -c -Wall 
test:$(OBJS)
	$(CC) $(OBJS) -o test     # CC变量为make管理器预定义变量值为cc
f2.o: f2.c
	gcc -c -Wall f2.c -o f2.o
f1.0: $^				      # 自动变量 $^，变量内容见上面
	$(CC) $(CFLAGS) f1.c -o f1.o  # CFLAGS是我们自己定义的变量
main.o: main.c
	$(CC) $(CFLAGS) $^ -o $@  # 自动变量 $@，变量内容见上面
. PHONY: clean
clean：
	rm *.o test

• makefile中的环境变量：

1.make在启动时会自动读取系统当前已经定义了的环境变量,并且会创建与之具有相同名称和数值的变量。
2.如果用户在Makefile中定义了相同名称的变量,那么用户自定义变量将会覆盖同名的环境变量。

• make命令的选项参数

-C dir读入指定目录下的Makefile，此时不再makefile所在目录，例如：make -C /dir/test_dir
-f file读入当前目录下的file文件作为Makefile，任意文件名的文件当做make的配置文件，例如：make -f makefile-debug
-i 执行make过程中如果出现错误，忽略本条错误继续执行makefile后面的不受本条错误影响的其它命令，例如：make -i
-I dir指定被包含的Makefile所在目录(重要)，例如：make -I /dir/include
-n 只打印要执行的命令,但不执行这些命令，例如：make -n
-p 显示make变量数据库和隐含规则，例如：make -p
-s 在执行命令时不显示命令(不推荐)
-w 如果make在执行过程中改变目录,打印当前目录名，例如：make -w
-L 来指定库文件所在的目录，例如：- L /usr/lib
-l 来指定库文件的名称(不带后缀)，例如：-lpthraed

1

CFLAGS= -c -Wall -I include_dir # 告诉make在编译找不到头文件时，可以去include_dir文件夹找头文件

include关键字从其他文件读内容到makefile：

交叉编译时候会用到，比如跟开发板硬件相关的配置信息可以单独用一个config.mk文件书写，在makefile中include文件config.mk