基于webserver的工业数据采集项目源代码
通过浏览器，实现Modbus Slave端数据采集和设备控制
数据采集函数
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#define N 1024 //共享内存空间
int ret; //函数返回值
uint16_t buf[32]; //读取保持寄存器值
uint8_t set[32]; //设置线圈寄存器
modbus_t *sensor; //传感器实例
modbus_t *hardware; //硬件实例
// char c[2]; //00:led关 01:led 开 10: 蜂鸣器关 11:蜂鸣器开
//消息队列结构体
typedef struct msgbuf
{
long mytype; //消息类型
char buf[32]; //消息数据内容
} msg_t;
int msgid;
void *mythread(void *arg)
{
while (1)
{
//读取消息队列
msg_t msg_read; //读取到的消息
msgrcv(msgid, &msg_read, sizeof(msg_read) - sizeof(long), 0, 0); //接收队列中的第一个消息
printf("%s\n", msg_read.buf);
if (msg_read.buf[0] == '0' && msg_read.buf[1] == '0')
{
ret = modbus_write_bit(hardware, 0, 0); //关闭LED
break;
}
else if (msg_read.buf[0] == '0' && msg_read.buf[1] == '1')
{
ret = modbus_write_bit(hardware, 0, 1); //打开LED
}
else if (msg_read.buf[0] == '1' && msg_read.buf[1] == '0')
{
ret = modbus_write_bit(hardware, 1, 0); //关闭蜂鸣器
}
else if (msg_read.buf[0] == '1' && msg_read.buf[1] == '1')
{
ret = modbus_write_bit(hardware, 1, 1); //打开蜂鸣器
}
}
// pthread_exit(NULL);
}
int main(int argc, char const *argv[])
{
key_t key = ftok("./a.txt", 'a'); //产生一个key值
int shmid = shmget(key, N, IPC_CREAT | IPC_EXCL | 0777); //创建或打开共享内存
if (shmid < 0)
{
if (errno == EEXIST)
{
printf("shmget eexist\n"); //已创建
shmid = shmget(key, N, 0777);
}
else
{
perror("shmget err.");
return -1;
}
}
//映射共享内存
char *p = (char *)shmat(shmid, NULL, 0666);
if (p == (void *)-1)
{
perror("shmat err.");
return -1;
}
//创建key值
key_t key2 = ftok("./a.txt", 'b');
//创建或打开消息队列
msgid = msgget(key2, IPC_CREAT | IPC_EXCL | 0666);
if (msgid < 0)
{
if (errno == EEXIST)
{
printf("msgget eexist\n"); //已创建
msgid = msgget(key2, 0666);
}
else
{
perror("msgget err.");
return -1;
}
}
// 1.创建实例 modbus_new_tcp,端口号字符型转整型
//设置传感器读取
sensor = modbus_new_tcp(argv[1], atoi(argv[2]));
// 2.设置从机id modbus_set_slave,连接
ret = modbus_set_slave(sensor, 1);
if (ret < 0)
{
printf("set err\n");
}
// 3.建立连接 modbus_connect
ret = modbus_connect(sensor);
if (ret < 0)
{
printf("connect err.\n");
}
//硬件设置
hardware = modbus_new_tcp(argv[1], atoi(argv[2]));
ret = modbus_set_slave(hardware, 2);
if (ret < 0)
{
printf("set err\n");
}
ret = modbus_connect(hardware);
if (ret < 0)
{
printf("connect err.\n");
}
char data[128];
// 4.寄存器操作
pthread_t tid; //创建一个线程
pthread_create(&tid, NULL, mythread, NULL);
pthread_detach(tid);
while (1)
{
sleep(1);
//4.从0开始读四个寄存器值. 0:光线传感器 1:加速度传感器 X 2:加速度传感器 Y 3:加速度传感器 Z
ret = modbus_read_registers(sensor, 0, 4, buf);
//将从设备读取的内容定向输出到共享内存中
sprintf(data, "%d\n%d\n%d\n%d\n", buf[0], buf[1], buf[2], buf[3]);
strcpy(p, data);
printf("%s", p);
putchar(10);
}
//取消映射
shmdt(p);
//删除映射
shmctl(shmid, IPC_RMID, NULL);
// 5.关闭套接字 modbus_close,先关闭套接字,再释放实例
modbus_close(sensor);
modbus_close(hardware);
// 6.释放实例 modbus_free
modbus_free(sensor);
modbus_free(hardware);
return 0;
}
主函数
#include"thttpd.h"
#include
#include
static void* msg_request(void *arg)
{
//这里客户端描述符通过参数传进来了
int sock=(int)arg;
// int sock = *(int *)arg;一致
// 一般情况下，线程终止后，其终止状态一直保留到其它线程调用pthread_join获取它的状态为止。
//但是线程也可以被置为detach状态，这样的线程一旦终止就立刻回收它占用的所有资源，而不保留终止状态。
pthread_detach(pthread_self());
//handler_msg作为所有的请求处理入口
return (void*)handler_msg(sock);
}
int main(int argc,char* argv[])
{
//如果不传递端口，那么使用默认端口80
int port = 80;
if(argc > 1)
{
port = atoi(argv[1]);
}
//初始化服务器
int lis_sock=init_server(port);
while(1)
{
struct sockaddr_in peer;
socklen_t len=sizeof(peer);
int sock=accept(lis_sock,(struct sockaddr*)&peer,&len);
if(sock<0)
{
perror("accept failed");
continue;
}
printf("accept 0k\n");
//每次接收一个链接后，会自动创建一个线程，这实际上就是线程服务器模型的应用
pthread_t tid;
if(pthread_create(&tid,NULL,msg_request,(void*)sock)>0)
{
perror("pthread_create failed");
close(sock);
}
}
return 0;
}
函数库
#include "thttpd.h"
#include "custom_handle.h"
#include
#include
#include
int init_server(int _port) //创建监听套接字
{
int sock=socket(AF_INET,SOCK_STREAM,0);
if(sock<0)
{
perror("socket failed");
exit(2);
}
//设置地址重用
int opt=1;
setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt));
struct sockaddr_in local;
local.sin_family=AF_INET;
local.sin_port=htons(_port);
local.sin_addr.s_addr=INADDR_ANY;
if(bind(sock,(struct sockaddr*)&local,sizeof(local))<0)
{
perror("bind failed");
exit(3);
}
if(listen(sock,5)<0)
{
perror("listen failed");
exit(4);
}
return sock;
}
//从套接字中按行读取请求报头，并将数据存储在缓冲区 buf 中。返回读取的字符数。
static int get_line(int sock,char* buf)
{
char ch='\0';
int i=0;
ssize_t ret=0;
while(i0&&ch=='\r')
{
ssize_t s=recv(sock,&ch,1,MSG_PEEK);
if(s>0&&ch=='\n')
{
recv(sock,&ch,1,0);
}
else
{
ch='\n';
}
}
buf[i++]=ch;
}
buf[i]='\0';
return i;
}
//清空请求报头，读取并忽略报头内容，直到遇到两个连续的换行符（表示报头结束）为止。
static void clear_header(int sock) //清空消息报头
{
char buf[SIZE];
int ret=0;
do
{
ret=get_line(sock,buf);
}while(ret!=1&&(strcmp(buf,"\n")!=0));
}
//处理 404 错误，即请求的资源未找到。发送 404 状态码和错误页面给客户端。
static void show_404(int sock) //404错误处理
{
clear_header(sock);
char* msg="HTTP/1.0 404 Not Found\r\n";
send(sock,msg,strlen(msg),0); //发送状态行
send(sock,"\r\n",strlen("\r\n"),0); //发送空行
struct stat st;
stat("wwwroot/404.html",&st);
int fd=open("wwwroot/404.html",O_RDONLY);
sendfile(sock,fd,NULL,st.st_size);//通过文件描述符,直接发送文件
close(fd);
}
//根据错误码 err_code 处理不同的错误情况。当前仅实现了处理 404 错误。
void echo_error(int sock,int err_code) //错误处理
{
switch(err_code)
{
case 403:
break;
case 404:
show_404(sock);
break;
case 405:
break;
case 500:
break;
defaut:
break;
}
}
//处理非 CGI 的请求，即静态资源的请求。发送状态行和请求的文件内容给客户端
static int echo_www(int sock,const char * path,size_t s) //处理非CGI的请求
{
int fd=open(path,O_RDONLY);
if(fd<0)
{
echo_error(sock,403);
return 7;
}
char* msg="HTTP/1.0 200 OK\r\n";//发送 HTTP 响应的状态行给客户端，表示请求成功（200 OK）。
send(sock,msg,strlen(msg),0); //发送状态行
send(sock,"\r\n",strlen("\r\n"),0); //发送一个空行，表示响应报头结束。
//sendfile方法可以直接把文件发送到网络对端
if(sendfile(sock,fd,NULL,s)<0)
{
echo_error(sock,500);
return 8;
}
close(fd);
return 0;
}
//处理请求。根据请求方法和路径，判断是否需要自定义处理（如 POST 请求或带有参数的 GET 请求），调用相应的处理函数。
static int handle_request(int sock,const char* method,
const char* path,const char* query_string)
{
char line[SIZE];
int ret=0;
int content_len=-1;
if(strcasecmp(method,"GET")==0)
{
//清空消息报头
clear_header(sock);
}
else
{
//获取post方法的参数大小
do
{
ret=get_line(sock,line);
if(strncasecmp(line,"content-length",14)==0) //post的消息体记录正文长度的字段
{
content_len=atoi(line+16); //求出正文的长度
}
}while(ret!=1&&(strcmp(line,"\n")!=0));
}
printf("method = %s\n", method);
printf("query_string = %s\n", query_string);
printf("content_len = %d\n", content_len);
char req_buf[4096] = {0};
//如果是POST方法，那么肯定携带请求数据，那么需要把数据解析出来
if(strcasecmp(method,"POST")==0)
{
int len = recv(sock, req_buf, content_len, 0);
printf("len = %d\n", len);
printf("req_buf = %s\n", req_buf);
}
//先发送状态码
char* msg="HTTP/1.1 200 OK\r\n\r\n";
send(sock,msg,strlen(msg),0);
//请求交给自定义代码来处理，这是业务逻辑
parse_and_process(sock, query_string, req_buf);
return 0;
}
//浏览器请求处理函数。根据请求方法和路径，决定使用自定义处理函数还是发送静态资源内容给客户端。
int handler_msg(int sock) //浏览器请求处理函数
{
char del_buf[SIZE] = {};
//通常recv()函数的最后一个参数为0，代表从缓冲区取走数据
//而当为MSG_PEEK时代表只是查看数据，而不取走数据。缓存区还有数据
recv(sock,del_buf,SIZE,MSG_PEEK);
#if 1 //初学者强烈建议打开这个开关，看看tcp实际请求的协议格式
puts("-------------------1--------------------");
printf("recv:%s\n",del_buf);
puts("-------------------2--------------------");
#endif
//接下来method方法判断之前的代码，可以不用重点关注
//知道是处理字符串，把需要的信息过滤出来即可
char buf[SIZE];//用于接收从客户端接收的数据
int count=get_line(sock,buf);//存储从客户端读取的行的长度
int ret=0;//存储函数执行的返回值
char method[32];//存储HTTP的请求方法
char url[SIZE];//存储请求资源的路径
char *query_string=NULL;//存储请求的参数字符串
int i=0;
int j=0;
int need_handle=0;//用于判断是否需要自己处理请求
//获取请求方法和请求路径
while(j 数据分析函数
/***********************************************************************************
Copy right: hqyj Tech.
Author: jiaoyue
Date: 2023.07.01
Description: http请求处理
***********************************************************************************/
#include
#include
#include "custom_handle.h"
#include
#include
#include
#include
#define N 1024
#define KB 1024
#define HTML_SIZE (64 * KB)
//普通的文本回复需要增加html头部
#define HTML_HEAD "Content-Type: text/html\r\n" \
"Connection: close\r\n"
typedef struct msgbuf
{
long mytype; //消息类型
char buf[32]; //消息数据内容
} msg_t;
//处理登录请求。从输入中提取用户名和密码，并进行验证。根据验证结果发送相应的响应给客户端。
static int handle_login(int sock, const char *input)
{
char reply_buf[HTML_SIZE] = {0};
char *uname = strstr(input, "username=");
uname += strlen("username=");
char *p = strstr(input, "password");
*(p - 1) = '\0';
printf("用户名username = %s\n", uname);
printf("connect err.\n");
char *passwd = p + strlen("password=");
printf("用户密码passwd = %s\n", passwd);
if (strcmp(uname, "admin") == 0 && strcmp(passwd, "admin") == 0)
{
sprintf(reply_buf, "", uname);
strcat(reply_buf, "");
send(sock, reply_buf, strlen(reply_buf), 0);
}
else
{
printf("web login failed\n");
//"用户名或密码错误"提示，chrome浏览器直接输送utf-8字符流乱码，没有找到太好解决方案，先过渡
char out[128] = {0xd3, 0xc3, 0xbb, 0xa7, 0xc3, 0xfb, 0xbb, 0xf2, 0xc3, 0xdc, 0xc2, 0xeb, 0xb4, 0xed, 0xce, 0xf3};
sprintf(reply_buf, "", out);
strcat(reply_buf, "");
send(sock, reply_buf, strlen(reply_buf), 0);
}
return 0;
}
//处理求和请求。从输入中提取两个数值，并计算它们的和。将计算结果作为响应发送给客户端。
static int handle_add(int sock, const char *input)
{
int number1, number2;
//input必须是"data1=1data2=6"类似的格式，注意前端过来的字符串会有双引号
sscanf(input, "\"data1=%ddata2=%d\"", &number1, &number2);
printf("num1 = %d\n", number1);
char reply_buf[HTML_SIZE] = {0};
printf("num = %d\n", number1 + number2);
sprintf(reply_buf, "%d", number1 + number2);
printf("resp = %s\n", reply_buf);
send(sock, reply_buf, strlen(reply_buf), 0);
return 0;
}
//处理获取设备数据请求
static int handle_get(int sock, const char *input)
{
key_t key = ftok("./a.txt", 'a'); //产生一个key值
int shmid = shmget(key, N, IPC_CREAT | IPC_EXCL | 0777); //创建或打开共享内存
if (shmid < 0)
{
if (errno == EEXIST)
{
printf("shmget eexist\n"); //已创建
shmid = shmget(key, N, 0777);
}
else
{
perror("shmget err.");
return -1;
}
}
//映射共享内存
char *p = (char *)shmat(shmid, NULL, 0666);
if (p == (void *)-1)
{
perror("shmat err.");
return -1;
}
char reply_buf[HTML_SIZE] = {0};
send(sock, p, strlen(p), 0);
return 0;
}
//处理控制设备数据请求
static int handle_post(int sock, const char *input)
{
msg_t ctl;
//创建key值
key_t key2 = ftok("./a.txt", 'b');
//创建或打开消息队列
int msgid = msgget(key2, IPC_CREAT | IPC_EXCL | 0666);
if (msgid < 0)
{
if (errno == EEXIST)
{
printf("msgget eexist\n"); //已创建
msgid = msgget(key2, 0666);
}
else
{
perror("msgget err.");
return -1;
}
}
char reply_buf[HTML_SIZE] = {0};
//分离请求内容为post
char *post = strstr(input, "post");
char *p = strstr(input, "change=");
*(p - 1) = '\0';
printf("请求 = %s\n", post);
//分离控制内容为 *change
char *change = p + strlen("change=");
*(change+2)='\0';
printf("操作change = %s\n", change);
//设置消息类型为1
ctl.mytype = 1;
//将控制信号放入到消息数据中
strcpy(ctl.buf, change);
printf("消息内容为:%s\n",ctl.buf);
//将控制消息发送到消息队列中
msgsnd(msgid, &ctl, sizeof(ctl) - sizeof(long), 0);
sprintf(reply_buf, "", post);
strcat(reply_buf, "");
send(sock, reply_buf, strlen(reply_buf), 0);
//删除消息队列
// msgctl(msgid,IPC_RMID,NULL);
return 0;
}
/**
* @brief 处理自定义请求，在这里添加进程通信
* @param input
* @return
*/
/*解析并处理自定义请求。根据不同的请求类型（登录、求和、其他），
调用相应的处理函数进行处理。如果是其他类型的请求（如 JSON 请求），则发送示例的 JSON 响应给客户端。*/
int parse_and_process(int sock, const char *query_string, const char *input)
{
//query_string不一定能用的到
//先处理登录操作
//strstr函数:从字符串Input中查找username=第一次出现的位置
if (strstr(input, "username=") && strstr(input, "password="))
{
return handle_login(sock, input);
}
//处理求和请求
else if (strstr(input, "data1=") && strstr(input, "data2="))
{
return handle_add(sock, input);
}
//处理get请求
else if (strstr(input, "get"))
{
return handle_get(sock, input);
}
//处理post请求
else if (strstr(input, "post"))
{
return handle_post(sock, input);
}
else //剩下的都是json请求，这个和协议有关了
{
// 构建要回复的JSON数据
const char *json_response = "{\"message\": \"Hello, client!\"}";
// 发送HTTP响应给客户端
send(sock, json_response, strlen(json_response), 0);
}
return 0;
}
html5页面开发
设备控制端
设备数据控制与读取
实现Modbus Slave端数据采集和设备控制,可以在网页进行查询和控制设备状态.
get当前状态:
设备状态:
光线传感器:
加速度传感器:
x
y
z
LED: on
off
蜂鸣器: on
off