C语言之网络高级编程笔记

1. 分别封装函数实现对保持寄存器的读取和对单个线圈的控制

读保持寄存器：函数参数（发送数据首地址，功能码，寄存器起始地址、寄存器个数、从机ID，接收数据首地址）

int sockfd;

void set_slave_id(uint8_t *p, int id) //设置从机id
{
    p[6]=id;//*(p+6)
}
void read_registers(uint8_t *p, int addr, int nb, uint8_t *dest)
{
    //给p指向数组赋值
    p[5]=6//字节数
    p[7]=0x03;
    p[8]=addr  >> 8 ;//地址高位
    p[9]=addr  &  0xff;//地址低位
    p[10]=nb  >> 8 ;//数量高位
    p[11]=nb  &  0xff;//数量低位
    //发送
    send(sockfd,p,12,0);
    //接收
    recv(sockfd,dest,64,0);
}
void write_coil(uint8_t *p, int function, int addr, int nb, uint8_t *dest)
{
    int i = 0;
    *(p + 5) = 6;              //后面字节数
    *(p + 7) = (char)function; //功能码
    *(p + 8) = addr >> 8;      //线圈高位地址
    *(p + 9) = addr & 0xff;    //线圈低位地址
    if (nb == 1)
        *(p + 10) = 0xff;
    else if (nb == 0)
        *(p + 10) = 0x00;
    *(p + 11) = 0x00;

    send(sockfd, p, 12, 0);
    recv(sockfd, dest, 64, 0);
}

int main()
{
    
    //创建套接字
    //填充结构体
    //连接
    //设置从机ID
    
    //调用函数收发
    
    //循环打印
     for (i = 0; i < dest[8]; i++)
            printf("%#x  ", dest[9 + i]);
        printf("\n");
    //关闭套接字
    return 0；
}

sudo hq_vm.sh

四、Modbus库

三方库的使用

【1】库的安装

1.库的安装配置

1.在linux中解压压缩包

将库压缩包复制到linux下，进行解压

tar -xvf libmodbus-3.1.7.tar.gz

2.进入源码目录，创建文件夹（存放头文件、库文件）

cd libmodbus-3.1.7

mkdir install

3.执行脚本configure，进行安装配置（指定安装目录）

./configure --prefix=$PWD/install

4.执行make和make install

make//编译

make install//安装

执行完成后会在install文件夹下生产对应的头文件、库文件件夹，install用于存放产生的头文件、库文件等

2.库的使用

2.要想编译方便，可以将头文件和库文件放到系统路径下

sudo  cp install/include/modbus/*.h  /usr/include 

sudo  cp install/lib/*  -r /lib -d

后期编译时，可以直接gcc xx.c -lmodbus

头文件默认搜索路径：/usr/include  、/usr/local/include

库文件默认搜索路径：/lib、/usr/lib

【2】函数接口

modbus_t*   modbus_new_tcp(const char *ip, int port)
功能：以TCP方式创建Modbus实例，并初始化
参数：
    ip   ：ip地址
    port：端口号
返回值：成功：Modbus实例
      失败：NULL
int modbus_set_slave(modbus_t *ctx, int slave)
功能：设置从机ID
参数：
    ctx   ：Modbus实例
    slave：从机ID
返回值：成功：0
       失败：-1
int   modbus_connect(modbus_t *ctx)
功能：和从机（slave）建立连接
参数：
    ctx：Modbus实例
返回值：成功：0
       失败：-1
void   modbus_free(modbus_t *ctx)
功能：释放Modbus实例
参数：ctx：Modbus实例
void   modbus_close(modbus_t *ctx)
功能：关闭套接字
参数：ctx：Modbus实例
int modbus_read_bits(modbus_t *ctx, int addr, int nb, uint8_t *dest)
功能：读取线圈状态，可读取多个连续线圈的状态（对应功能码为0x01）
参数：
    ctx   ：Modbus实例
    addr ：寄存器起始地址
    nb    ：寄存器个数
    dest ：得到的状态值
int  modbus_read_input_bits(modbus_t *ctx, int addr, int nb, uint8_t *dest)
功能：读取输入状态，可读取多个连续输入的状态（对应功能码为0x02）
参数：
    ctx   ：Modbus实例
    addr ：寄存器起始地址
    nb   ：寄存器个数
    dest ：得到的状态值
返回值：成功：返回nb的值
int  modbus_read_registers(modbus_t *ctx, int addr, int nb, uint16_t *dest)
功能：读取保持寄存器的值，可读取多个连续保持寄存器的值（对应功能码为0x03）
参数：
    ctx   ：Modbus实例
    addr ：寄存器起始地址
    nb    ：寄存器个数
    dest ：得到的寄存器的值
返回值：成功：读到寄存器的个数
       失败：-1
int   modbus_read_input_registers(modbus_t *ctx, int addr, int nb, uint16_t *dest)
功能：读输入寄存器的值，可读取多个连续输入寄存器的值（对应功能码为0x04）
参数：
    ctx   ：Modbus实例
    addr ：寄存器起始地址
    nb    ：寄存器个数
    dest ：得到的寄存器的值
返回值：成功：读到寄存器的个数
       失败：-1
int  modbus_write_bit(modbus_t *ctx, int addr, int status);
功能：写入单个线圈的状态（对应功能码为0x05）
参数：
    ctx     ：Modbus实例
    addr  ：线圈地址
    status：线圈状态
返回值：成功：0
      失败：-1
int  modbus_write_bits(modbus_t *ctx, int addr, int nb, const uint8_t *src);
功能：写入多个连续线圈的状态（对应功能码为15）
参数：
    ctx     ：Modbus实例
    addr  ：线圈地址
    nb     ：线圈个数
    src    ：多个线圈状态
返回值：成功：0
      失败：-1
int  modbus_write_register(modbus_t *ctx, int addr, int value);
功能：  写入单个寄存器（对应功能码为0x06）
参数： 
    ctx    ：Modbus实例
    addr  ：寄存器地址
    value ：寄存器的值 
返回值：成功：0
       失败：-1
int  modbus_write_registers(modbus_t *ctx, int addr, int nb, const uint16_t *src);
功能：写入多个连续寄存器（对应功能码为16）
参数：
    ctx    ：Modbus实例
    addr  ：寄存器地址
    nb     ：寄存器的个数
    src    ：多个寄存器的值 
返回值：成功：0
      失败：-1

【3】编程流程

1.创建实例

modbus_new_tcp

2.设置从机ID

modbus_set_slave

3.连接

modbus_connect

4.寄存器操作

功能码对应的函数

5.关闭套接字

modbus_close

6.释放实例

modbus_free

03功能码 读2个寄存器的值

05功能码 写一个线圈

 #include<stdio.h>
 #include<modbus.h>
 
 int main() {
     modbus_t *ctx;
     int slave_id = 1;
     const char *ip = "192.168.50.96";
     int port = 502;
     int regs_read = 2;
     uint16_t destination[2];
 
 
     // 创建Modbus TCP实例
     ctx = modbus_new_tcp(ip, port);
 
     // 设置从机ID
     modbus_set_slave(ctx, slave_id);
 
     // 连接到从机
     modbus_connect(ctx);
 
 
     modbus_write_bit(ctx,0,88);
     /*
 
     // 读取保持寄存器的值
     modbus_read_registers(ctx, 0, regs_read, destination);
 
     // 打印读取到的寄存器值
     for (int i = 0; i <regs_read; i++) {
     printf("Register %d: %d\n", i, destination[i]);
     }
     */
     // 关闭套接字和释放实例
     modbus_close(ctx);
     modbus_free(ctx);
 
     return 0;
 }                                                                 
                                                                   
                                                                   

任务：

编程实现采集传感器数据和控制硬件设备（传感器和硬件通过slave模拟）

传感器：2个，光线传感器、加速度传感器（x\y\z）

硬件设备：2个，led灯、蜂鸣器

要求：

1. 多任务编程：多线程
2. 循环1s采集一次数据，并将数据打印至终端
3. 同时从终端输入指令控制硬件设备

0  1 ：led灯打开

0  0：led灯关闭

1  1：蜂鸣器开

1 0 :  蜂鸣器关

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include "modbus.h"
modbus_t *ctx;
//采集数据
void *handler_data(void *arg)
{
	//modbus_t *ctx = (modbus_t *)arg;
	uint16_t dest[64] = {0};
	int i;
	while(1)
	{
		modbus_read_registers(ctx, 0, 4, dest);
		for(i = 0; i < 4; i++)
			printf("data:%d ", dest[i]);
		printf("\n");
		sleep(1);
	}
}
//控制设备
void *handler_ctl(void *arg)
{
	//modbus_t *ctx = (modbus_t *)arg;
	int dev, op;
	while(1)
	{
		scanf("%d %d", &dev, &op); //1 0
		modbus_write_bit(ctx, dev, op);
		sleep(1);
	}
}

int main(int argc, const char *argv[])
{
	//1. 创建modbus实例，并初始化
	int n = 0;
	uint8_t src[2] = {1, 0};
	pthread_t tid1, tid2;

	ctx = modbus_new_tcp(argv[1], atoi(argv[2]));
	if(ctx == NULL){
		perror("modbus new tcp error");
		return -1;
	}
	//2. 设置从机ID
	modbus_set_slave(ctx, 1);
	//3. 建立连接
	if(modbus_connect(ctx) < 0){
		perror("modbus connect error");
		modbus_free(ctx);
		return -1;
	}
	//4.创建线程
	if(pthread_create(&tid1, NULL, handler_data, NULL)!=0)
	{
		perror("pthread_create data err");
		return -1;
	}
	if(pthread_create(&tid2, NULL, handler_ctl, NULL)!=0)
	{
		perror("pthread_create ctl err");
		return -1;
	}

	pthread_join(tid1, NULL);
	pthread_join(tid2, NULL);

	//5. 关闭套接字
	modbus_close(ctx);
	//6. 释放modbus实例
	modbus_free(ctx);
	
	return 0;
}

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <modbus.h>
#include <pthread.h>
#include <sys/types.h>
#include <sys/wait.h>


int sockfd;
uint16_t dest[64] = {};

int main()
{

    modbus_t *ctx;
    ctx = modbus_new_tcp("192.168.50.96", 502);
    int a = modbus_set_slave(ctx, 1);
    int b = modbus_connect(ctx);

    pid_t pid = fork();
    if (pid < 0)
    {
        perror("fork err");
        return -1;
    }
    else if (pid == 0)
    {
        while (1)
        {
            modbus_read_registers(ctx, 0, 4, dest);
            for (int i = 0; i < 4; i++)
            {
                if (i == 0)
                {
                    printf("光线传感器:");
                    printf("%d\n", dest[i]);
                }
                else if (i == 1)
                {
                    printf("加速度传感器x:%d\n", dest[i]);
                }
                else if (i == 2)
                {
                    printf("加速度传感器y:%d\n", dest[i]);
                }
                else if (i == 3)
                {
                    printf("加速度传感器z:%d\n", dest[i]);
                }
                putchar(10);

            }                                                                                      
            sleep(5);
        }
        exit(0);
    }
    else
    {
        int a, b;
        while (1)
        {
            scanf("%d", &a);
            scanf("%d", &b);

            if (a == 0 && b == 1)
            {
                printf("led灯打开\n");
            }
            else if (a == 0 && b == 0)
            {
                printf("led灯关闭\n");
            }
            else if (a == 1 && b == 1)
            {
                printf("蜂鸣器开\n");
            }
            else if (a == 1 && b == 0)
            {
                printf("蜂鸣器关\n");
            }
            modbus_write_bit(ctx, a, b);
        }

        wait(NULL);
    }
    modbus_close(ctx);
    modbus_free(ctx);
    return 0;
}
                                                                                                   
                                                                                                                                                                                                                                                                                                 
                                                                                                  

##
var.home_dir    = "/home/hq/work/web"   #lighttpd操作的主目录
var.log_root    = home_dir + "/log"			#日志文件目录（程序执行中出现的错误信息）
var.server_root = home_dir + "/www"			#存放html、cgi代码目录
var.state_dir   = home_dir + "/run"			#存放pid文件服务运行起来后自动创建
var.conf_dir    = home_dir + "/config"  #存放配置文件
##
var.vhosts_dir  = home_dir + "/vhosts"
##
var.cache_dir   = home_dir + "/cache"
##
var.socket_dir  = home_dir + "/sockets"
##
server.port = 80    #端口号为80
##
server.use-ipv6 = "disable"	  #设置为禁用
##
#server.bind = "localhost"		#默认即可
##
server.username  = "hq"		#修改为当前用户，nobody为任何人都可以访问
#server.groupname = "nobody"		#将其注释即可
##
server.document-root = server_root + "/htdocs"		#存放html网页的文件
##
server.pid-file = state_dir + "/lighttpd.pid"
##
server.errorlog             = log_root + "/error.log"		#错误日志文件

//CGI进程
parse_and_process(char *input)
{
        if(strcmp(input, "get") == 0)
        {
                //创建共享内存、映射
                //读取共享内存数据
                //将数据写至标准输出
        }
        else
        {
            //创建消息队列
            //将postman下发的指令添加至消息队列
            //给浏览器回复数据
        }
}

//和modbus slave交互的服务进程
//采集传感器数据线程
void *info(void *arg)
{
    //创建或打开共享内存、映射
    while(1)
    {
        //读保持寄存器
        modbus_read_registers();
        //将从slave端拿到的数据写到共享内存中
        sleep(1);
    }
}
//控制设备线程
void *control(void *arg)
{
    //创建或打开消息队列
    while(1)
    {
        //读取消息队列
        msgrcv();
        //根据消息队列的值进行设备控制，写线圈
        switch(msg.buf)
        {
            case LED: 写线圈；break；
            case BEEP：写线圈；break；
        }
    }
}

#include "req_handle.h"
#include "log_console.h"
#include "sys/ipc.h"
#include "sys/shm.h"
#include "errno.h"
#include "sys/msg.h"

#define KB 1024
#define HTML_SIZE (64 * KB)

//普通的文本回复需要增加html头部
#define HTML_HEAD "Content-Type: text/html\r\n" \
    "Connection: close\r\n"

/**
 * @brief 处理自定义请求，在这里添加进程通信
 * @param input
 * @return
 */
struct msgbuf{
    long type;
    char buf[32];
};

int parse_and_process(char *input)
{
    char val_buf[2048] = {0};
    key_t key;
    int shmid;
    char *p=NULL;


    int msgid;
    struct msgbuf msg;
    //1.创建key值
    if((key = ftok("/mnt", 'm')) < 0)
    {
        log_console("ftok err");
        return -1;
    }

    // strcpy(val_buf, input);

    //这里可以根据接收的数据请求进行处理
    if(input[0]=='g')
    {

        //2.创建或打开共享内存
        shmid = shmget(key, 128, IPC_CREAT|IPC_EXCL|0666);
        if(shmid <= 0)
        {
            if(errno == EEXIST)
                shmid = shmget(key, 128, 0666);
            else
            {
                log_console("shmget err");
                return -1;
            }
        }

        //3.映射
        if((p = shmat(shmid, NULL, 0)) == (char *)-1)
        {
            log_console("shmat err");
            return -1;
        }
        strcpy(val_buf,p);

    }
    else if(input[0]=='s')
    {
        //1.创建或打开消息队列

        msgid = msgget(key, IPC_CREAT|IPC_EXCL|0666);
        if(msgid <= 0)
        {
            if(errno == EEXIST)
                msgid = msgget(key, 0666);
            else
            {
                log_console("msgget err");
                return -1;
            }
        }
                                                                                             
        msg.type=1;
        strcpy(msg.buf,input);
        strcpy(val_buf,input);

        //2.添加消息队列

        msgsnd(msgid, &msg, sizeof(msg)-sizeof(long), 0);

        log_console("msgbuf:%s\n",msg.buf);
    }

    //数据处理完成后，需要给服务器回复，回复内容按照http协议格式
    char reply_buf[HTML_SIZE] = {0};
    sprintf(reply_buf, "%sContent-Length: %ld\r\n\r\n", HTML_HEAD, strlen(val_buf));
    strcat(reply_buf, val_buf);
    log_console("post json_str = %s", reply_buf);

    //向标准输出写内容（标准输出服务器已做重定向）
    fputs(reply_buf, stdout);

    return 0;
}
                                                                                            

#include <stdio.h>
#include <modbus.h>
#include <pthread.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/shm.h>
#include <errno.h>
#include <sys/msg.h>
#include "sys/msg.h"

#define LED 0
#define BEEP 1

struct msgbuf{
    long type;
    char buf[32];
};

void *handler_info(void *arg)
{
    uint16_t dest[4] = {0};
    key_t key;
    int shmid;
    char *p = NULL;

    //1.创建key值                                                                             
    if((key = ftok("/mnt", 'm')) < 0)
    {
        perror("ftok err");
        return NULL;
    }
    //2.创建或打开共享内存
    shmid = shmget(key, 128, IPC_CREAT|IPC_EXCL|0666);
    if(shmid <= 0)
    {
        if(errno == EEXIST)
            shmid = shmget(key, 128, 0666);
        else
        {
            perror("shmget err");
            return NULL;
        }
    }
    //3.映射
    if((p = shmat(shmid, NULL, 0)) == (char *)-1)
    {
        perror("shmat err");
        return NULL;
    }
    modbus_t *ctx = (modbus_t *)arg;
    while(1)
    {
        modbus_read_registers(ctx, 0, 4, dest);
        sprintf(p, "%u,%u,%u,%u", dest[0],dest[1],dest[2],dest[3]);
        printf("传感器数据：%s\n", p);
        sleep(1);
    }
}
void *handler_contl(void *arg)
{
    modbus_t *ctx = (modbus_t*)arg;
    key_t key;
    int msgid;
    struct msgbuf msg;
    int dev, op;
    if((key = ftok("/mnt", 'm')) < 0)
    {
        perror("ftok err");
        return NULL;
    }
    msgid = msgget(key, IPC_CREAT|IPC_EXCL|0666);
    if(msgid <= 0)
    {
        if(errno == EEXIST)
            msgid = msgget(key, 0666);
        else
        {
            perror("msgget err");
            return NULL;
        }
    }
    while(1)
    {
        //scanf("%d %d", &dev, &op);
        msgrcv(msgid, &msg, sizeof(msg)-sizeof(long), 1, 0);
        printf("msgbuf:%s\n", msg.buf);
        dev = msg.buf[4]-'0';
        op = msg.buf[6]-'0';
        switch(dev)
        {
        case LED:
            modbus_write_bit(ctx, 0, op);
            break;
        case BEEP:
            modbus_write_bit(ctx, 1, op);
            break;
        }
    }
}

int main(int argc, const char *argv[])
{
    modbus_t *ctx;
    pthread_t t1, t2;

    ctx = modbus_new_tcp(argv[1], 502);
    if(ctx == NULL)
    {
        perror("modbus new tcp");
        return -1;
    }
    modbus_set_slave(ctx, 1);
    if(modbus_connect(ctx) < 0)
    {
        perror("connect err");
        goto err;
    }
    printf("connect ok\n");

    if(pthread_create(&t1, NULL, handler_info, ctx) != 0)
    {
        perror("create thread1 err");
        goto err;
    }
    if(pthread_create(&t2, NULL, handler_contl, ctx) != 0)
    {
        perror("create thread2 err");
        goto err;
    }

    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
err:
    modbus_free(ctx);
    modbus_close(ctx);
    return 0;
}
                                                                                              
                                                                                        

<!DOCTYPE html>
<html lang="en">
 
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
    <script src="js/xhr.js"></script>
    <script>
        function get_info(){
            var v = document.getElementsByName("username");
           
            XHR.post('/cgi-bin/web.cgi',"get",function(x,info){   
                console.log(info); 
                var val = info.split(",");
                v[0].value=val[0];
                v[1].value=val[1] + ',' + val[2] + ','+val[3];
               
            })
        }
        function set_info(obj1){
            XHR.post('/cgi-bin/web.cgi',obj1,function(x,info){   
            })
            if(obj1 == 'set=1 0'){
                console.log("蜂鸣器关!");
            }else if(obj1 == 'set=1 1'){
                console.log("蜂鸣器开!");
            }else if(obj1 == 'set=0 0'){
                console.log("LED灯关！");
            }else if(obj1 == 'set=0 1'){
                console.log("LED灯开！");
            }
        }
    </script>
    
</head>
 
<body>
    <div style = "color: greenyellow;background:darkslategrey">
    <p>
        <h1>********Webserver工业数据采集********</h1>
    </p>
    </div>
        <div style = "color:cyan;background:cornflowerblue">
        <h3>信息采集</h3>
        数据采集 
        <input type="button" name="flash" onclick="get_info()">
        <br/>
        光照强度：
        <input type="text" name="username" value="admin" >
        <br/>
        加速度：
        <input type="text" name="username" value="admin">
        <br/>
        <h3>设备控制</h3>
        LED灯
        on<input type="radio" name = "led" id = "set=0 1" onclick="set_info(id)">
        off<input type="radio" name = "led" id = "set=0 0" checked = "checked" onclick="set_info(id)">
        <br/>
        蜂鸣器
        on<input type="radio" name = "beef" id = "set=1 1" onclick="set_info(id)">
        off<input type="radio" name = "beef" id = "set=1 0" checked = "checked" onclick="set_info(id)">
    </div>
 
    </body>
 
</html>