项目框架及流程
这个项目的主要目的是为了通过网页实现对设备的读写操作。
modbus采集程序通过Modbus TCP协议 接收传感器数据，并将采集到的数据储存至共享内存，一旦接收到网页的查询请求，服务器就通过共享内存取出数据并回复，网页收到响应后处理消息并打印。网页通过按键控制led和蜂鸣器的状态，服务器收到请求后利用消息队列发送消息，采集程序收到消息后，再通过Modbus TCP协议实现对硬件设备的控制。
（项目使用Modbus slave模拟硬件设备 ）
modbus采集程序：
采用多线程模式，一个线程用来循环读取传感器数据，一个线程用来发送控制命令。
#include <stdio.h>
#include "Crc_Calc.h"
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include<modbus.h>
#include<pthread.h>
#include <sys/socket.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <errno.h>
#include <sys/msg.h>
modbus_t* ctx;
char *p;
key_t key;
int shmid;
int msgid;
struct msgbuf
{
long type; //必须用long，表示消息的类型，值>0
//正文随便定义
int dev;
int op;
};
//线程A 功能：每隔1秒循环读取传感器数据
void *xcA(void *arg)
{
uint16_t dest[32];
int n;
while(1)
{
sleep(1);
//ctx：实例 0：起始地址 4：读4个传感器 dest：将读到的数据保存至dest
modbus_read_registers(ctx, 0, 4, dest);
//将采集到的消息保存到共享内存
sprintf(p,"%d ,x=%d y=%d z=%d\n",dest[0],dest[1],dest[2],dest[3]);
}
}
//线程B 功能：发送命令，控制LED及蜂鸣器
void *xcB(void *arg)
{
struct msgbuf m; //定义结构体，用于接收消息队列
while (1)
{
msgrcv(msgid, &m, sizeof(m) - sizeof(long), 1, 0);//阻塞等待接收消息 1：消息类型 0：阻塞
modbus_write_bit(ctx, m.dev,m.op);//通过Modbus TCP协议操作单个线圈
}
}
//函数功能：创建共享内存
int gxnc()
{
//创建key值
key = ftok("xm.c", 'd');
if (key < 0)
{
perror("ftok err");
return -1;
}
printf("key: %#x\n", key);
//创建或打开共享内存
shmid = shmget(key, 128, IPC_CREAT | IPC_EXCL | 0666); //没有则创建共享内存，已有则返回-1
if (shmid <= 0)
{
if (errno == EEXIST) //如果已存在则直接打开共享内存
shmid = shmget(key, 128, 0666); //直接打开共享内存，返回共享内存id
else
{
perror("shmget err");
return -1;
}
}
printf("shmid: %d\n", shmid);
//映射共享内存到用户空间
p = (char *)shmat(shmid, NULL, 0);
if (p == (char *)-1)
{
perror("shmat err");
return -1;
}
return 0;
}
//函数功能：创建消息队列
int xxdl()
{
msgid = msgget(key, IPC_CREAT | IPC_EXCL | 0666);
if (msgid <= 0)
{
if (errno == EEXIST)
msgid = msgget(key, 0666);
else
{
perror("msgget err");
return -1;
}
}
printf("msgid: %d\n", msgid);
}
//主函数
int main(int argc, char const *argv[])
{
ctx = modbus_new_tcp("192.168.50.65", 502); //创建实例
modbus_set_slave(ctx, 1); //设置从机ID
modbus_connect(ctx); //建立链接
int ret = gxnc(); //创建or打开共享内存
if(ret<0)
{
return 0;
}
ret = xxdl(); //创建or打开消息队列
if(ret<0)
{
return 0;
}
//开启两个线程
pthread_t a,b;
pthread_create(&a,NULL,xcA,NULL);
pthread_create(&b,NULL,xcB,NULL);
//阻塞等待回收线程资源
pthread_join(a,NULL);
pthread_join(b,NULL);
modbus_close(ctx);
modbus_free( ctx);
//取消内存映射
shmdt(p);
//删除共享内存
shmctl(shmid,IPC_RMID,NULL);
//删除消息队列
msgctl(msgid,IPC_RMID,NULL);
return 0;
}
服务器部分关键代码：
采用的多线程服务器模型，每次接收到一个链接后会开启一个线程用来处理网页请求。
服务器流程：
- 初始化服务器
- 循环等待连接，连接后创建线程，调用线程函数msg_request，在函数中调用handler_msg函数分析请求
- 在handler_msg函数中，先查看请求协议内容，其次获取请求方法、URL、参数，判断请求方法，对need_handler赋值，确定请求资源路径，如果请求地址没有携带任何资源，则默认返回index.html文件，如果资源不存在，返回404，如果需要处理（get带参数、post）调用handle_request函数，如果不需要（get请求不带参数且资源存在），调用echo_www函数，直接返回资源
- handle_request函数主要获取post数据，调用parse_and_process函数处理正文内容
main.c
#include"thttpd.h"
#include <sys/types.h>
#include <sys/wait.h>
static void* msg_request(void *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;
}
//每次接收一个链接后，会自动创建一个线程，这实际上就是线程服务器模型的应用
pthread_t tid;
if(pthread_create(&tid,NULL,msg_request,(void*)sock)>0)
{
perror("pthread_create failed");
close(sock);
}
}
return 0;
}
thttpd.c
处理请求消息，过滤关键信息，并判断是否需要处理
#include "thttpd.h"
#include "custom_handle.h"
#include <sys/types.h>
#include <sys/wait.h>
#include <ctype.h>
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;
}
static int get_line(int sock,char* buf) //按行读取请求报头
{
char ch='\0';
int i=0;
ssize_t ret=0;
while(i<SIZE && ch!='\n')
{
ret=recv(sock,&ch,1,0);
if(ret>0&&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));
}
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);
}
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;
}
}
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";
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;
}
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("---------------------------------------");
printf("recv:%s\n",del_buf);
puts("---------------------------------------");
#endif
//接下来method方法判断之前的代码，可以不用重点关注
//知道是处理字符串，把需要的信息过滤出来即可
char buf[SIZE];
int count=get_line(sock,buf);
int ret=0;
char method[32];
char url[SIZE];
char *query_string=NULL;
int i=0;
int j=0;
int need_handle=0;
//获取请求方法和请求路径//isspace():判断是否是空白字符，不是空白字符返回'0'，是返回'非0'.
while(j<count)
{
if(isspace(buf[j]))
{
break;
}
method[i]=buf[j];
i++;
j++;
}
method[i]='\0';
while(isspace(buf[j])&&j<SIZE) //过滤空格
{
j++;
}
//这里开始就开始判断发过来的请求是GET还是POST了//strcasecmp()比较不区分大小写
if(strcasecmp(method,"POST")&&strcasecmp(method,"GET"))
{
printf("method failed\n"); //如果都不是，那么提示一下
echo_error(sock,405);
ret=5;
goto end;
}
if(strcasecmp(method,"POST")==0)
{
need_handle=1;
}
i=0;
while(j<count)
{
if(isspace(buf[j]))
{
break;
}
if(buf[j]=='?')
{
//将资源路径（和附带数据，如果有的话）保存再url中，并且query_string指向附带数据
query_string=&url[i];
query_string++;
url[i]='\0';
}
else{
url[i]=buf[j];
}
j++;
i++;
}
url[i]='\0';
printf("query_string = %s\n", query_string);
//浏览器通过http://192.168.8.208:8080/?test=1234这种形式请求
//是携带参数的意思，那么就需要额外处理了
if(strcasecmp(method,"GET")==0&&query_string!=NULL)
{
need_handle=1;
}
//我们把请求资源的路径固定为wwwroot/下的资源，这个自己可以改
char path[SIZE];
sprintf(path,"wwwroot%s",url);
printf("path = %s\n", path);
//如果请求地址没有携带任何资源，那么默认返回index.html
if(path[strlen(path)-1]=='/') //判断浏览器请求的是不是目录
{
strcat(path,"index.html"); //如果请求的是目录，则就把该目录下的首页返回回去
}
//如果请求的资源不存在，就要返回传说中的404页面了
struct stat st;
if(stat(path,&st)<0) //获取客户端请求的资源的相关属性
{
printf("can't find file\n");
echo_error(sock,404);
ret=6;
goto end;
}
//到这里基本就能确定是否需要自己的程序来处理后续请求了
printf("need progress handle:%d\n",need_handle);
//如果是POST请求或者带参数的GET请求，就需要我们自己来处理了
//这些是业务逻辑，所以需要我们自己写代码来决定怎么处理
if(need_handle)
{
ret=handle_request(sock,method,path,query_string);
}
else
{
clear_header(sock);
//如果是GET方法，而且没有参数，则直接返回资源
ret=echo_www(sock,path,st.st_size);
}
end:
close(sock);
return ret;
}
handle.c
处理请求
#include <sys/types.h>
#include <sys/socket.h>
#include "custom_handle.h"
#include <sys/ipc.h>
#include <sys/shm.h>
#include <errno.h>
#define KB 1024
#define HTML_SIZE (64 * KB)
//普通的文本回复需要增加html头部
#define HTML_HEAD "Content-Type: text/html\r\n" \
"Connection: close\r\n"
int xxdl();
int gxnc();
char *p;
key_t key;
int shmid;
int msgid;
static int handle_get(int sock, const char *input)
{
gxnc();
send(sock,p,strlen(p),0);
return 0;
}
struct msgbuf
{
long type; //必须用long，表示消息的类型，值>0
//正文随便定义
int dev;
int op;
};
static int handle_set(int sock, const char *input)
{
xxdl();
struct msgbuf msg;
msg.type = 1;
sscanf(input, "set=%d %d", &msg.dev, &msg.op);
msgsnd(msgid, &msg, sizeof(msg) - sizeof(long), 0);
send(sock,input,HTML_SIZE,0);
return 0;
}
//处理自定义请求，在这里添加进程通信
int parse_and_process(int sock, const char *query_string, const char *input)
{
if (strstr(input,"get"))
{
return handle_get(sock, input);
}
else if (strstr(input,"set"))
{
return handle_set(sock, input);
}
else //剩下的都是json请求，这个和协议有关了
{
// 构建要回复的JSON数据
const char* json_response = "{\"message\": \"Hello, client!\"}";
// 发送HTTP响应给客户端
send(sock, json_response, strlen(json_response), 0);
}
return 0;
}
//创建共享内存
int gxnc()
{
//创建key值
key = ftok("../xm.c", 'd');
if (key < 0)
{
perror("ftok err");
return -1;
}
printf("key: %#x\n", key);
//创建或打开共享内存
shmid = shmget(key, 128, IPC_CREAT | IPC_EXCL | 0666); //没有则创建共享内存，已有则返回-1
if (shmid <= 0)
{
if (errno == EEXIST) //如果已存在则直接打开共享内存
shmid = shmget(key, 128, 0666); //直接打开共享内存，返回共享内存id
else
{
perror("shmget err");
return -1;
}
}
printf("shmid: %d\n", shmid);
//映射共享内存到用户空间
p = (char *)shmat(shmid, NULL, 0);
if (p == (char *)-1)
{
perror("shmat err");
return -1;
}
return 0;
}
//创建消息队列
int xxdl()
{
//创建key值
key = ftok("../xm.c", 'd');
if (key < 0)
{
perror("ftok err");
return -1;
}
printf("key: %#x\n", key);
msgid = msgget(key, IPC_CREAT | IPC_EXCL | 0666);
if (msgid <= 0)
{
if (errno == EEXIST)
msgid = msgget(key, 0666);
else
{
perror("msgget err");
return -1;
}
}
printf("msgid: %d\n", msgid);
}网页部分代码
<!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>
function fun_led(obj)
{
var xhr =new XMLHttpRequest();
var url="";
xhr.open("post",url,true);
if(obj=='on')
xhr.send("set=0 1");
else
xhr.send("set=0 0");
}
function fun_fmq(obj)
{
var xhr =new XMLHttpRequest();
var url="";
xhr.open("post",url,true);
if(obj=='on')
xhr.send("set=1 1");
else
xhr.send("set=1 0");
}
function modbus_get()
{
var xhr =new XMLHttpRequest();
var url="";
xhr.open("post",url,true);
xhr.onreadystatechange=function()
{
if(xhr.readyState===4 && xhr.status === 200)
{
var buf =xhr.responseText;
console.log(buf);
var val =buf.split(",",2);
console.log(val[0]);
console.log(val[1]);
var name = document.getElementsByName("guang");
name[0].value=val[0];
name = document.getElementsByName("sudu");
name[0].value=val[1];
}
};
xhr.send("get");
}
</script>
</head>
<body background="aaa.jpg"
style="background-repeat:no-repeat;
background-attachment:fixed;
background-size:100% 100%; "
>
信息采集
<br>
光照强度:<input type="text" name="guang" value="00">
加速度:<input type="text" name="sudu" value="x=0 y=0 z=0">
<button onclick="modbus_get()">刷新</button>
<br>设备控制<br>
控制LED灯<input type="radio" name="led" id="on" onclick="fun_led(id)">on
<input type="radio" name="led" id="off" onclick="fun_led(id)">off
<br>
控制蜂鸣器<input type="radio" name="fmq" id="on" onclick="fun_fmq(id)">on
<input type="radio" name="fmq" id="off" onclick="fun_fmq(id)">off
</body>
</html>
扫一扫
2119
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
