• 日期: 2025-11-04
  • 标签: 常规

智能家居系统：空调和加湿器建议生成服务器

本服务器使用SQLite数据库存储设备状态信息，根据实时设备状态生成空调和加湿器建议，并通过网络发送给客户端。

代码实现

#include <stdio.h>
#include <stdlib.h>
#include 'server.h'

int main() {
    startServer();
    return 0;
}

#ifndef SERVER_H
#define SERVER_H

#include <netinet/in.h>
#include <sqlite3.h>


typedef struct {
    int uid;
    char device_name[20];
    char device_state[20];
    char value[20];
    char mode[20];
} Status;

typedef struct {
    int sockfd;
    struct sockaddr_in client_addr;
    socklen_t client_addr_len;
    sqlite3 *db;
} ServerContext;

void startServer(); // 启动服务器
int createSocket(); // 创建套接字
void bindSocket(int sockfd, struct sockaddr_in *server_addr); // 绑定套接字
void listenSocket(int sockfd); // 监听套接字
sqlite3* openDatabase(); // 打开数据库连接
void closeSocket(int sockfd); // 关闭套接字
void closeDatabase(sqlite3 *db); // 关闭数据库连接
void sig_handler(int signo) ;//信号处理函数

#endif

#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sqlite3.h>
#include <signal.h>
#include "server.h"
#include "handle.h"

int createSocket() {
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd == -1) {
        perror("连接失败\nsocket");
        exit(1);
    }
    return sockfd;
}

void bindSocket(int sockfd, struct sockaddr_in *server_addr) {
    if (bind(sockfd, (struct sockaddr *)server_addr, sizeof(*server_addr)) == -1) {
        perror("连接失败\nbind");
        close(sockfd);
        exit(1);
    }
}

void listenSocket(int sockfd) {
    if (listen(sockfd, 5) == -1) {
        perror("连接失败\nlisten");
        close(sockfd);
        exit(1);
    }
}

void closeSocket(int sockfd) {
    if (close(sockfd) == -1) {
        perror("套接字关闭失败\nclose");
        exit(1);
    }
}

sqlite3* openDatabase() {
    sqlite3 *db;
    int rc = sqlite3_open("/mnt/g/Qt/Client/Smarthome_Client/database/database.db", &db);//根据实际数据库路径进行更改，此路径挂载G盘共享文件夹
    if (rc != SQLITE_OK) {
        fprintf(stderr, "数据库打开失败: %s\n", sqlite3_errmsg(db));
        exit(1);
    }
    return db;
}

void closeDatabase(sqlite3 *db) {
    if (sqlite3_close(db) != SQLITE_OK) {
        fprintf(stderr, "数据库关闭失败: %s\n", sqlite3_errmsg(db));
        exit(1);
    }
}

void sig_handler(int signo) {
    if (signo == SIGTSTP) {
        printf("服务器登出\n");
        exit(-1);
    }
}

void startServer() {
    printf("正在连接中...\n");
    // 注册信号处理函数
    signal(SIGTSTP, sig_handler);
    int sockfd = createSocket();

    struct sockaddr_in server_addr;
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = INADDR_ANY;
    server_addr.sin_port = htons(12345);

    bindSocket(sockfd, &server_addr);
    listenSocket(sockfd);

    sqlite3 *db = openDatabase();

    ServerContext context;
    context.sockfd = sockfd;
    context.client_addr_len = sizeof(context.client_addr);
    context.db = db;

    handleClientRequests(&context, sockfd);

    closeSocket(sockfd);
    closeDatabase(db);
}
#ifndef HANDLE_H
#define HANDLE_H

#include <string.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sqlite3.h>
#include "server.h"
#define MAX_BUFFER_SIZE 1024

void handleClientRequests(ServerContext *context,int sockfd);// 处理客户端请求
void handleClientRequest(ServerContext *context);// 处理单个客户端请求
int receiveUserId(int sockfd);// 接收客户端发送的userid
sqlite3_stmt* prepareStatement(sqlite3 *db, int userid); // 准备数据库查询语句
void initializeStatus(Status *status);// 初始化设备状态
void updateAcStatus(Status *acStatus, int uid, const unsigned char *device_state, const unsigned char *value) ;// 更新设备状态
void generateAcSuggestion(const Status *acStatus, char *suggestion);// 生成空调建议
void generateHumidifierSuggestion(const Status *humidifierStatus, char *suggestion);//生成加湿器建议
char* combineSuggestions(const char *suggestion, const char *humidifierSuggestion); // 合并建议
void sendSuggestion(int sockfd,char *suggestion) ;// 发送建议

#endif
#include <stdio.h>
#include <unistd.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include "handle.h"

int receiveUserId(int sockfd) {
    int userid;
    ssize_t recvSize = recv(sockfd, &userid, sizeof(int), 0);
    if (recvSize == -1 || recvSize == 0 || recvSize != sizeof(int)) {
        perror("接收userid失败");
        return -1;
    }
    return ntohl(userid);
}

sqlite3_stmt* prepareStatement(sqlite3 *db, int userid) {
    char sql[100];
    snprintf(sql, sizeof(sql), "SELECT * FROM Status WHERE uid = %d", userid);
    sqlite3_stmt *stmt = NULL;
    int rc = sqlite3_prepare_v2(db, sql, -1, &stmt, NULL);
    if (rc != SQLITE_OK) {
        fprintf(stderr, "无法执行的语句: %s\n", sqlite3_errmsg(db));
        return NULL;
    }
    return stmt;
}

void initializeStatus(Status *status) {
    memset(status, 0, sizeof(Status));
    status->uid = 0;
    status->device_name[0] = '\0';
}

void updateAcStatus(Status *acStatus, int uid, const unsigned char *device_state, const unsigned char *value) {
    acStatus->uid = uid;
    strncpy(acStatus->device_state, device_state, sizeof(acStatus->device_state) - 1);
    acStatus->device_state[sizeof(acStatus->device_state) - 1] = '\0';
    strncpy(acStatus->value, value, sizeof(acStatus->value) - 1);
    acStatus->value[sizeof(acStatus->value) - 1] = '\0';

}

void generateAcSuggestion(const Status *acStatus, char *suggestion) {
    int temperature = atoi(acStatus->value);
    
    if (temperature < 24) {
        snprintf(suggestion, MAX_BUFFER_SIZE, "空调温度过低，建议提高温度至26℃");
    } else if(temperature>35){
        snprintf(suggestion, MAX_BUFFER_SIZE, "空调温度过高，建议降低温度至26℃");
    }
    else{
        snprintf(suggestion, MAX_BUFFER_SIZE, "空调温度适宜");
    }
}

void generateHumidifierSuggestion(const Status *humidifierStatus, char *suggestion) {
    int humidity = atoi(humidifierStatus->value);
    if (humidity < 40) {
        snprintf(suggestion, MAX_BUFFER_SIZE, "加湿器湿度过低，建议调整加湿器湿度");
    } else if (humidity > 70) {
        snprintf(suggestion, MAX_BUFFER_SIZE, "加湿器湿度过高，建议调整加湿器湿度");
    } else {
        snprintf(suggestion, MAX_BUFFER_SIZE, "加湿器湿度适宜");
    }
}

char* combineSuggestions(const char *suggestion, const char *humidifierSuggestion) {
    int combinedSuggestionSize = strlen(suggestion) + strlen(humidifierSuggestion) + 2;
    char *combinedSuggestion = malloc(combinedSuggestionSize);
    snprintf(combinedSuggestion, combinedSuggestionSize, "%s\n%s", suggestion, humidifierSuggestion);
    return combinedSuggestion;
}

void sendSuggestion(int sockfd, char *suggestion) {
    ssize_t sendSize = send(sockfd, suggestion, strlen(suggestion)+1, 0);
    if (sendSize == -1) {
        perror("发送失败\nsend");
        free(suggestion);
        return;
    } else {
        printf("建议已发送\n");
    }
}

void handleClientRequest(ServerContext *context) {
    int userid = receiveUserId(context->sockfd);
    if (userid == -1) {
        perror("接收userid失败");
        return;
    }

    printf("客户端已连接\n");
    printf("userid:%d\n", userid);

    sqlite3_stmt *stmt = prepareStatement(context->db, userid);
    if (stmt == NULL) {
        fprintf(stderr, "无法执行的语句: %s\n", sqlite3_errmsg(context->db));
        return;
    }

    Status acStatus, humidifierStatus;
    initializeStatus(&acStatus);
    initializeStatus(&humidifierStatus);

    char suggestion[MAX_BUFFER_SIZE] = "";
    char humidifierSuggestion[MAX_BUFFER_SIZE] = "";

    int acOpened = 0;
    int humidifierOpened = 0;

    while (sqlite3_step(stmt) == SQLITE_ROW) {
        int uid = sqlite3_column_int(stmt, 1);
        const unsigned char *device_name = sqlite3_column_text(stmt, 2);
        const unsigned char *device_state = sqlite3_column_text(stmt, 3);
        const unsigned char *value = sqlite3_column_text(stmt, 4);

        if (strcmp(device_name, "空调") == 0) {
            if (strcmp(device_state, "开启") == 0){
                updateAcStatus(&acStatus, uid, device_state, value);
                generateAcSuggestion(&acStatus, suggestion);
                acOpened = 1;
            } else if (strcmp(device_state, "关闭") == 0) {
                updateAcStatus(&acStatus, uid, device_state, value);
                // 更新设备状态为关闭
                acOpened = 0;
            }
        } else if (strcmp(device_name, "加湿器") == 0) {
            if (strcmp(device_state, "开启") == 0){
                updateAcStatus(&humidifierStatus, uid, device_state, value);
                generateHumidifierSuggestion(&humidifierStatus, humidifierSuggestion);
                humidifierOpened = 1;
            } else if (strcmp(device_state, "关闭") == 0) {
                updateAcStatus(&humidifierStatus, uid, device_state, value);
                // 更新设备状态为关闭
                humidifierOpened = 0;
            }
        }
    }

    sqlite3_finalize(stmt);

    if (!acOpened) {
        snprintf(suggestion, MAX_BUFFER_SIZE, "空调未开启");
        }

    if (!humidifierOpened) {
        snprintf(humidifierSuggestion, MAX_BUFFER_SIZE, "加湿器未开启");
    }

    char *combinedSuggestion = combineSuggestions(suggestion, humidifierSuggestion);
    sendSuggestion(context->sockfd, combinedSuggestion);
    printf("建议为：\n%s\n", combinedSuggestion);

    free(combinedSuggestion);

    // 关闭连接
    shutdown(context->sockfd, SHUT_RDWR);
    printf("按下Ctrl + Z登出...\n");
}

void handleClientRequests(ServerContext *context, int sockfd) {
    fd_set readfds;
    int maxfd = sockfd;

    while (1) {
        FD_ZERO(&readfds);
        FD_SET(sockfd, &readfds);

        int activity = select(maxfd + 1, &readfds, NULL, NULL, NULL);
        if (activity == -1) {
            perror("select");
            break;
        }

        if (FD_ISSET(sockfd, &readfds)) {
            int clientSockfd = accept(sockfd, (struct sockaddr *)&context->client_addr, &context->client_addr_len);
            if (clientSockfd == -1) {
                perror("套接字接收失败\naccept");
                break;
            }

            context->sockfd = clientSockfd;
            handleClientRequest(context);

            close(clientSockfd);
        }
    }
}

功能说明

  1. 服务器启动：
    • 创建一个套接字，绑定到指定的地址和端口（默认端口号为12345）。
    • 监听连接请求。
    • 打开SQLite数据库连接。
    • 创建ServerContext结构体，用于存储服务器上下文信息。
    • 启动处理客户端请求的循环。
  2. 处理客户端请求：
    • 接收客户端发送的userid。
    • 根据userid查询数据库，获取设备状态信息。
    • 根据设备状态信息，生成空调和加湿器建议。
    • 将建议发送给客户端。
    • 关闭连接。
  3. 设备状态更新：
    • 使用updateAcStatus函数更新空调和加湿器的状态。
  4. 建议生成：
    • 使用generateAcSuggestion和generateHumidifierSuggestion函数生成空调和加湿器的建议。
  5. 建议发送：
    • 使用sendSuggestion函数将建议发送给客户端。

使用说明

  1. 安装依赖库：
    • sqlite3 库用于连接SQLite数据库。
  2. 配置数据库路径：
    • 在 openDatabase 函数中，将 "/mnt/g/Qt/Client/Smarthome_Client/database/database.db" 替换为实际的数据库路径。
  3. 启动服务器：
    • 编译并运行服务器代码。
  4. 客户端测试：
    • 使用Postman或其他工具，发送HTTP请求到服务器的地址和端口。
    • 请求体中包含 "userid": 123 ，其中 123 是用户的ID。

注意事项

  • 请确保服务器和客户端在同一网络环境下。
  • 服务器使用的端口号可以根据实际情况进行调整。
  • 建议将数据库路径设置为更安全的路径。
  • 建议使用安全的通信协议，例如HTTPS，以保护数据传输安全。

扩展功能

  • 添加其他设备类型，例如灯光、窗帘等。
  • 添加用户认证和权限管理。
  • 实现更复杂的建议生成逻辑，例如根据天气、时间、用户偏好等因素进行调整。
  • 使用图形界面或移动应用程序进行交互。

代码示例

#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sqlite3.h>
#include <signal.h>
#include "server.h"
#include "handle.h"

int createSocket() {
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd == -1) {
        perror("连接失败\nsocket");
        exit(1);
    }
    return sockfd;
}

void bindSocket(int sockfd, struct sockaddr_in *server_addr) {
    if (bind(sockfd, (struct sockaddr *)server_addr, sizeof(*server_addr)) == -1) {
        perror("连接失败\nbind");
        close(sockfd);
        exit(1);
    }
}

void listenSocket(int sockfd) {
    if (listen(sockfd, 5) == -1) {
        perror("连接失败\nlisten");
        close(sockfd);
        exit(1);
    }
}

void closeSocket(int sockfd) {
    if (close(sockfd) == -1) {
        perror("套接字关闭失败\nclose");
        exit(1);
    }
}

sqlite3* openDatabase() {
    sqlite3 *db;
    int rc = sqlite3_open("/mnt/g/Qt/Client/Smarthome_Client/database/database.db", &db);//根据实际数据库路径进行更改，此路径挂载G盘共享文件夹
    if (rc != SQLITE_OK) {
        fprintf(stderr, "数据库打开失败: %s\n", sqlite3_errmsg(db));
        exit(1);
    }
    return db;
}

void closeDatabase(sqlite3 *db) {
    if (sqlite3_close(db) != SQLITE_OK) {
        fprintf(stderr, "数据库关闭失败: %s\n", sqlite3_errmsg(db));
        exit(1);
    }
}

void sig_handler(int signo) {
    if (signo == SIGTSTP) {
        printf("服务器登出\n");
        exit(-1);
    }
}

void startServer() {
    printf("正在连接中...\n");
    // 注册信号处理函数
    signal(SIGTSTP, sig_handler);
    int sockfd = createSocket();

    struct sockaddr_in server_addr;
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = INADDR_ANY;
    server_addr.sin_port = htons(12345);

    bindSocket(sockfd, &server_addr);
    listenSocket(sockfd);

    sqlite3 *db = openDatabase();

    ServerContext context;
    context.sockfd = sockfd;
    context.client_addr_len = sizeof(context.client_addr);
    context.db = db;

    handleClientRequests(&context, sockfd);

    closeSocket(sockfd);
    closeDatabase(db);
}

代码解读

  • createSocket() 函数用于创建套接字。
  • bindSocket() 函数用于绑定套接字到指定的地址和端口。
  • listenSocket() 函数用于监听套接字上的连接请求。
  • closeSocket() 函数用于关闭套接字。
  • openDatabase() 函数用于打开SQLite数据库连接。
  • closeDatabase() 函数用于关闭SQLite数据库连接。
  • sig_handler() 函数用于处理信号，在本例中，Ctrl+Z 信号会使服务器退出。
  • startServer() 函数用于启动服务器。
  • handleClientRequests() 函数用于处理客户端请求。
  • handleClientRequest() 函数用于处理单个客户端请求。
  • receiveUserId() 函数用于接收客户端发送的userid。
  • prepareStatement() 函数用于准备数据库查询语句。
  • initializeStatus() 函数用于初始化设备状态。
  • updateAcStatus() 函数用于更新空调和加湿器的状态。
  • generateAcSuggestion() 函数用于生成空调建议。
  • generateHumidifierSuggestion() 函数用于生成加湿器建议。
  • combineSuggestions() 函数用于合并空调和加湿器的建议。
  • sendSuggestion() 函数用于发送建议给客户端。

总结

本服务器代码提供了一个简单的智能家居系统建议生成示例，您可以根据实际需求进行扩展和改进。

智能家居系统：基于SQLite数据库的空调和加湿器建议生成服务器

原文地址: https://www.cveoy.top/t/topic/fKk9 著作权归作者所有。请勿转载和采集!

免费AI点我,无需注册和登录