增加了数据库及测试程序

src/pPowerManger/CMakeLists.txt

@@ -15,12 +15,16 @@ else (${WIN32})
       pthread )
 endif (${WIN32})
 
+# Find SQLite3 package
+find_package(SQLite3 REQUIRED)
+
 SET(SRC
   PowerManger.cpp
   PowerManger_Info.cpp
   udpComm.cpp
   fsm.cpp
   main.cpp
+  SQLiteDB.cpp
 )
 
 ADD_EXECUTABLE(pPowerManger ${SRC})
@@ -32,5 +36,13 @@ TARGET_LINK_LIBRARIES(pPowerManger
    m
    pthread
    jsoncpp
-   ${SYSTEM_LIBS})
+   ${SYSTEM_LIBS}
+   SQLiteDB
+   sqlite3)
 
+# Add SQLiteDB static library
+SET(SQLITEDB_SRC
+  SQLiteDB.cpp
+)
+
+ADD_LIBRARY(SQLiteDB STATIC ${SQLITEDB_SRC})

src/pPowerManger/PowerManger.cpp

@@ -35,6 +35,12 @@ PowerManger::PowerManger()
   m_faultNum = 0;
   faultCode.push_back(0);
 
+  //初始化数据库
+  string dbPath = "/home/zjk/project/H100/H100PowerManger/data/power_data.db";
+  m_db = new SQLiteDB(dbPath);
+  m_db->createTables();
+  
+  
   //注册状态机
   m_fsm.RegisterState("Init",  1, m_Inite_s1);
   m_fsm.RegisterState("Fault", 99, m_Fault_s99);
@@ -106,6 +112,15 @@ bool PowerManger::Iterate()
   updateTime();
   //2. 运行状态机
   m_fsm.run(m_pmState,this);
+  // 数据库测试
+  PowerData data;
+  data.id = 1;
+  data.timestamp = "2023-05-22 10:00:00";
+  data.voltage = 12.3 + rand() % 100 / 100.0;
+  data.current = 4.5 + rand() % 100 / 100.0;
+  data.power = 56.7 + rand() % 100 / 100.0;
+  data.temperature = 25.0 + rand() % 100 / 100.0; 
+  m_db->insertPowerData(data.voltage, data.current, data.power, data.temperature);
   //3. 输出报告
   buildPowerSysReport();
   //4. 打印错误信息

src/pPowerManger/PowerManger.h

@@ -30,6 +30,7 @@
 #include "udpComm.h"
 #include "pmSysvariable.h"
 #include "fsm.h"
+#include "SQLiteDB.h"
 
 #define VAR_TO_STR(var) #var
 
@@ -69,8 +70,6 @@ class PowerManger : public AppCastingMOOSApp
   bool IsSkewed(double dfTimeNow, double * pdfSkew = NULL);
   string getTypeName(const string typeName);
 
- 
-
   //通信相关
   XPCUdpSocket* setUdpScoket(long lPort);
   bool disSystemOperation(disBreaker optBreaker, disBreakerOpt);
@@ -104,6 +103,9 @@ class PowerManger : public AppCastingMOOSApp
   double        m_current_time;
   unsigned int  m_faultNum;
 
+  //数据库
+  SQLiteDB* m_db;
+
   //  CMOOSThread m_SendThread;
  private: //
  bool inline saveStringToJsonFile(const string &strJson, const string &strFileName);

src/pPowerManger/SQLiteDB.cpp

@@ -0,0 +1,125 @@
+#include "SQLiteDB.h"
+#include <iostream>
+#include <ctime>
+#include <json/json.h>
+
+SQLiteDB::SQLiteDB(const std::string& dbPath) {
+    if (sqlite3_open(dbPath.c_str(), &m_db) != SQLITE_OK) {
+        std::cerr << "Error opening database: " << sqlite3_errmsg(m_db) << std::endl;
+        m_db = nullptr;
+    }
+}
+
+SQLiteDB::~SQLiteDB() {
+    if (m_db) {
+        sqlite3_close(m_db);
+    }
+}
+
+void SQLiteDB::createTables() {
+    if (!m_db) return;
+
+    const char* sql = "CREATE TABLE IF NOT EXISTS power_data ("
+                      "id INTEGER PRIMARY KEY AUTOINCREMENT,"
+                      "timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,"
+                      "voltage REAL NOT NULL,"
+                      "current REAL NOT NULL,"
+                      "power REAL NOT NULL,"
+                      "temperature REAL NOT NULL);";
+
+    char* errMsg = nullptr;
+    if (sqlite3_exec(m_db, sql, nullptr, nullptr, &errMsg) != SQLITE_OK) {
+        std::cerr << "SQL error: " << errMsg << std::endl;
+        sqlite3_free(errMsg);
+    }
+}
+
+void SQLiteDB::insertPowerData(float voltage, float current, float power, float temperature) {
+    if (!m_db) return;
+
+    const char* sql = "INSERT INTO power_data (voltage, current, power, temperature) VALUES (?, ?, ?, ?);";
+    sqlite3_stmt* stmt;
+
+    if (sqlite3_prepare_v2(m_db, sql, -1, &stmt, nullptr) == SQLITE_OK) {
+        sqlite3_bind_double(stmt, 1, voltage);
+        sqlite3_bind_double(stmt, 2, current);
+        sqlite3_bind_double(stmt, 3, power);
+        sqlite3_bind_double(stmt, 4, temperature);
+
+        if (sqlite3_step(stmt) != SQLITE_DONE) {
+            std::cerr << "Error inserting data: " << sqlite3_errmsg(m_db) << std::endl;
+        }
+
+        sqlite3_finalize(stmt);
+    } else {
+        std::cerr << "Error preparing statement: " << sqlite3_errmsg(m_db) << std::endl;
+    }
+}
+
+std::vector<PowerData> SQLiteDB::getPowerData(int limit) {
+    std::vector<PowerData> data;
+    if (!m_db) return data;
+
+    const char* sql = "SELECT id, timestamp, voltage, current, power, temperature FROM power_data ORDER BY timestamp DESC LIMIT ?;";
+    sqlite3_stmt* stmt;
+
+    if (sqlite3_prepare_v2(m_db, sql, -1, &stmt, nullptr) == SQLITE_OK) {
+        sqlite3_bind_int(stmt, 1, limit);
+
+        while (sqlite3_step(stmt) == SQLITE_ROW) {
+            PowerData record;
+            record.id = sqlite3_column_int(stmt, 0);
+            record.timestamp = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 1));
+            record.voltage = sqlite3_column_double(stmt, 2);
+            record.current = sqlite3_column_double(stmt, 3);
+            record.power = sqlite3_column_double(stmt, 4);
+            record.temperature = sqlite3_column_double(stmt, 5);
+            data.push_back(record);
+        }
+
+        sqlite3_finalize(stmt);
+    } else {
+        std::cerr << "Error preparing statement: " << sqlite3_errmsg(m_db) << std::endl;
+    }
+
+    return data;
+}
+// 显式实例化模板
+template void SQLiteDB::insertStructData<PowerData>(const std::string&, const PowerData&);
+template<typename T>
+std::string SQLiteDB::serializeStruct(const T& data) {
+    Json::Value j;
+    j["id"] = data.id;
+    j["timestamp"] = data.timestamp;
+    j["voltage"] = data.voltage;
+    j["current"] = data.current;
+    j["power"] = data.power;
+    j["temperature"] = data.temperature;
+    
+    Json::StreamWriterBuilder writer;
+    return Json::writeString(writer, j);
+}
+
+template<typename T>
+void SQLiteDB::insertStructData(const std::string& tableName, const T& data) {
+    if (!m_db) return;
+
+    std::string jsonData = serializeStruct(data);
+    
+    std::string sql = "INSERT INTO " + tableName + " (data) VALUES (?);";
+    sqlite3_stmt* stmt;
+
+    if (sqlite3_prepare_v2(m_db, sql.c_str(), -1, &stmt, nullptr) == SQLITE_OK) {
+        sqlite3_bind_text(stmt, 1, jsonData.c_str(), -1, SQLITE_TRANSIENT);
+
+        if (sqlite3_step(stmt) != SQLITE_DONE) {
+            std::cerr << "Error inserting data: " << sqlite3_errmsg(m_db) << std::endl;
+        }
+
+        sqlite3_finalize(stmt);
+    } else {
+        std::cerr << "Error preparing statement: " << sqlite3_errmsg(m_db) << std::endl;
+    }
+}
+
+

src/pPowerManger/SQLiteDB.h

@@ -0,0 +1,39 @@
+#ifndef SQLITEDB_H
+#define SQLITEDB_H
+
+#include <sqlite3.h>
+#include <string>
+#include <vector>
+#include "json/json.h"
+// #include <nlohmann/json.hpp>
+
+struct PowerData {
+    int id;
+    std::string timestamp;
+    double voltage;
+    double current;
+    double power;
+    double temperature;
+};
+
+
+class SQLiteDB {
+public:
+    SQLiteDB(const std::string& dbPath);
+    ~SQLiteDB();
+    
+    void createTables();
+    void insertPowerData(float voltage, float current, float power, float temperature);
+    std::vector<PowerData> getPowerData(int limit = 100);
+    
+    template<typename T>
+    void insertStructData(const std::string& tableName, const T& data);
+    
+private:
+    sqlite3* m_db;
+    
+    template<typename T>
+    std::string serializeStruct(const T& data);
+};
+
+#endif // SQLITEDB_H