gtcvr/Test/modbustest.hpp

//
// Created by lloyd on 2020/10/20.
//
#include <iostream>
#include "modbus.h"
#include "../DataMapping/dgns_gtgktype.h"

class modbustest {
public:
    char DataStr[4000];
public:
    void maintest() {
        printf("Compiled with libmodbus version %s\n", LIBMODBUS_VERSION_STRING);
        printf("Linked with libmodbus version %d.%d.%d\n",
               libmodbus_version_major, libmodbus_version_minor, libmodbus_version_micro);

        if (LIBMODBUS_VERSION_CHECK(2, 1, 0)) {
            printf("The functions to read/write float values are available (2.1.0).\n");
        }

        if (LIBMODBUS_VERSION_CHECK(2, 1, 1)) {
            printf("Oh gosh, brand new API (2.1.1)!\n");
        }
    }

    void testMondbusTCPClient() {
        const char *chIp = "192.168.1.57";
        int nPort = 502;
        modbus_t *pmbs_ctx = modbus_new_tcp(chIp, nPort);
        int nRet = modbus_connect(pmbs_ctx);
        if (-1 == nRet) {
            printf("connect failed: %s\n", modbus_strerror(errno));
            modbus_free(pmbs_ctx);
        }

        // 设置Modbus超时时间
        struct timeval tv;
        tv.tv_sec = 1;
        tv.tv_usec = 0;
        //设置modbus超时时间为1000毫秒
        modbus_set_response_timeout(pmbs_ctx, &tv);
        // 定义存放数据的数组
        //uint16_t tab_reg[9999] = {0};
        // 每隔1秒钟发送Modbus TCP请求，读取对应寄存器并打印出数据
//        while (true)
//        {
        printf("--------------------------------------------------\n");

        /*int address;
        switch (address) {
            case 40984:
                break;
            case 40985:
                break;
            case 40991:
                break;
            case 40993:
                break;
//            case 40985:
//                break;
//            case 40985:
//                break;
            default:
                break;
        }*/

        //1.gtdata read
        // 读取保持寄存器的值，起始地址为 ，寄存器个数为 ，读取到 数组中
        uint16_t pointnum;
        modbus_set_slave(pmbs_ctx, 1);
        int regs = modbus_read_registers(pmbs_ctx, 40984, 1, &pointnum);
        if (regs != 1) return;
        printf("gt pointnum: %d \n", pointnum);

        uint16_t timebyte[5];
        modbus_set_slave(pmbs_ctx, 1);
        regs = modbus_read_registers(pmbs_ctx, 40985, 6, timebyte);
        if (regs != 6) return;
        printf("gt date： %04X年%02X月%02X日 %02X:%02X:%02X\n", timebyte[0], timebyte[1], timebyte[2], timebyte[3],
               timebyte[4], timebyte[5]);

        uint16_t chongci;
        modbus_set_slave(pmbs_ctx, 1);
        regs = modbus_read_registers(pmbs_ctx, 40991, 1, &chongci);
        if (regs != 1) return;
        printf("gt chongci: %5.2f \n", 60.0 / (chongci / 1000.0));

        uint16_t chongcheng;
        modbus_set_slave(pmbs_ctx, 1);
        regs = modbus_read_registers(pmbs_ctx, 40993, 1, &chongcheng);
        if (regs != 1) return;
        printf("gt chongcheng: %5.2f \n", chongcheng / 100.0);

        uint16_t WeiYi[250];
        uint16_t ZaiHe[250];
        //weiyi
        modbus_set_slave(pmbs_ctx, 1);
        regs = modbus_read_registers(pmbs_ctx, 41001, 125, &WeiYi[0]);
        if (regs != 125) return;
        modbus_set_slave(pmbs_ctx, 1);
        regs = modbus_read_registers(pmbs_ctx, 41126, 125, &WeiYi[125]);
        if (regs != 125) return;
        //zaihe
        modbus_set_slave(pmbs_ctx, 1);
        regs = modbus_read_registers(pmbs_ctx, 41251, 125, &ZaiHe[0]);
        if (regs != 125) return;
        modbus_set_slave(pmbs_ctx, 1);
        regs = modbus_read_registers(pmbs_ctx, 41376, 125, &ZaiHe[125]);
        if (regs != 125) return;

        //char DataStr[4000];
        char *strTMP = new char[8];
        for (int i = 0; i < 250; i++) {
            sprintf(strTMP, "%03d%05d", WeiYi[i], ZaiHe[i]);
            for (int j = 0; j < 8; j++) {
                DataStr[i * 8 + j] = strTMP[j];
            }
        }

        printf("gt weiyi + zaihe: %s \n", DataStr);

        printf("--------------------------------------------------\n");


        // 获取当前时间
        // 获取系统时间
        //time_t now_time = time(NULL);
        // 获取本地时间
        //struct tm *t_tm = localtime(&now_time);
        // 将时间转换为秒
        //time_t mk_time = mktime(t_tm);
        // 输出当前时间
        //printf("当前数据时间为：%04d-%02d-%02d %02d:%02d:%02d\n", t_tm->tm_year+1900, t_tm->tm_mon + 1,t_tm->tm_mday, t_tm->tm_hour, t_tm->tm_min,t_tm->tm_sec);


        //2.gongtu shuju  write       where wrtie?
        //预置单寄存器 把具体二进值装入一个保持寄存器
        uint16_t tmpbuff[5] = {1, 2, 3, 4, 5};
        nRet = modbus_write_registers(pmbs_ctx, 42001, 5, tmpbuff);
        //
        //            Sleep(1000);
//        }


        // 关闭modbus连接
        modbus_close(pmbs_ctx);
        //释放modbus资源，使用完libmodbus需要释放掉
        modbus_free(pmbs_ctx);
    }

    std::map<int, std::string> gktypes;
    std::map<std::string, dgns_gtgktype> gktypes_;

    uint16_t *trans_gtcvr_out_content_to_modbuscode_rf(std::string gk_content) {

        dgns_gtgktype type_gkout = gktypes_[gk_content];
        //modbustranscode ----> uint16_t[]
// delete [
// delete last ]
// split ] ---std::string[]
//for std::string[] --->int[]

//std::vector<uint16_t> p;
        uint16_t *p = new uint16_t[5];
        std::list<uint16_t> p1;

        return p;
    }

    /**
     * 标准工况类型编码后内容输入到modbus server
     * @param buff 工况既定标准输出编码数组
     * @param buffnum 个数
     * @return
     */
    bool write_gtcvr_out_content_to_modbus_tcp_server(uint16_t *buff, unsigned int buffnum) {

        //TODO:完成工况类型标准输入modbus server
        //like ::::
        //int nRet = modbus_write_registers(pmbs_ctx, 42001, 5, tmpbuff);
        return true;//返回写入成功与否
    }

    /**
     * 标准工况类型编码后内容输入到modbus server
     * @param buff 工况既定标准输出编码数组 using vector as container
     * @return
     */
    bool write_gtcvr_out_content_to_modbus_tcp_server(std::vector<uint16_t> buff) {

        //TODO:完成工况类型标准输入modbus server
        //like ::::
        //int nRet = modbus_write_registers(pmbs_ctx, 42001, 5, tmpbuff);
        return true;//返回写入成功与否
    }
};