Ubuntu使用 HPsocket

Ubuntu使用 HPsocket

环境：基于树莓派4B +Ubuntu22.04

1.下载HPsocket linux发行版

下载地址：https://gitee.com/ldcsaa/HP-Socket/releases

解压后

include:头文件
lib：库文件，这里仅用arm64文件夹下的库文件libhpsocket.so，这是release版本的

把libhpsocket.so拷贝到 /usr/local/lib里。

在etc/ld.so.conf.d下新建任何以.conf为后缀的文件，在该文件中加入库文件所在的目录，如下：

再运行sudo ldconfig 以更新/etc/ld.so.cache文件.（要sudo 不然QT会报 can’t link ）

QT 引用

包含头文件和库文件

Linux 下与Windows的区别

如下报错：
1.cannot find tchar.h
->把include <tchar.h>直接注释掉，linux下好像不需要这个头文件了
2.cannot open hpsocket_U.lib
->把#pragma comment(lib,“hpsocket_U.lib”)注释掉
3.编译通过但运行报错：error while loading shared libraries:libhpsocket.so…cannot open shared object file
->拷贝到 usr/local/lib 里，在/etc/ld.so.conf.d/目录下新建任何以.conf为后缀的文件，在该文件中加入库文件所在的目录，
->sudo ldconfig 以更新/etc/ld.so.cache文件.要+sudo 不然会报 can’t link

代码-Windows，

Linux Ubuntu下一样
clistenerimpl.h

#ifndef CLISTENERIMPL_H
#define CLISTENERIMPL_H
#pragma once
#include <QString>
#include <HPSocket.h>
#include <SocketInterface.h>
#include <QDebug>



class CListenerImpl:public QObject,public CTcpClientListener
{

    Q_OBJECT
public:
    CListenerImpl(QObject *parent=nullptr);
    virtual EnHandleResult OnPrepareConnect(ITcpClient* pSender, CONNID dwConnID, SOCKET socket);
    virtual EnHandleResult OnHandShake(ITcpClient* pSender, CONNID dwConnID);
    virtual EnHandleResult OnConnect(ITcpClient* pSender, CONNID dwConnID);
    virtual EnHandleResult OnSend(ITcpClient* pSender, CONNID dwConnID, const BYTE* pData, int iLength);
    virtual EnHandleResult OnReceive(ITcpClient* pSender, CONNID dwConnID, const BYTE* pData, int iLength);
    virtual EnHandleResult OnClose(ITcpClient* pSender, CONNID dwConnID, EnSocketOperation enOperation, int iErrorCode);
    virtual EnHandleResult OnShutdown(ITcpClient* pSender);

    ITcpClient* m_pClient;
signals:
    void sendConnOK();
    void sendConnClose();
    void sendRecvData(QString );

private:



};

#endif // CLISTENERIMPL_H

clistenerimpl.cpp

#include "clistenerimpl.h"
// HP-Socket事件处理类

CListenerImpl::CListenerImpl(QObject *parent)
{
    m_pClient=nullptr;

}

EnHandleResult CListenerImpl::OnPrepareConnect(ITcpClient *pSender, CONNID dwConnID, SOCKET socket)
{
    qDebug() << "OnPrepareConnect, Connection ID: " << dwConnID;
    return HR_OK;
}

EnHandleResult CListenerImpl::OnHandShake(ITcpClient *pSender, CONNID dwConnID)
{
    qDebug() << "OnHandShake, Connection ID: " << dwConnID;
    return HR_OK;
}

EnHandleResult CListenerImpl::OnConnect(ITcpClient *pSender, CONNID dwConnID)
{
//    qDebug() << "OnConnect, Connection ID: " << dwConnID;
    emit sendConnOK();
    return HR_OK;
}

EnHandleResult CListenerImpl::OnSend(ITcpClient *pSender, CONNID dwConnID, const BYTE *pData, int iLength)
{
        return HR_OK;
}

EnHandleResult CListenerImpl::OnReceive(ITcpClient *pSender, CONNID dwConnID, const BYTE *pData, int iLength)
{
//    qDebug() << "OnReceive, Connection ID: " << dwConnID;
    QString strData = QString::fromLocal8Bit((char*)pData, iLength);
//    qDebug() << "Received Data: " << strData;
    emit sendRecvData(strData);
    return HR_OK;
}



EnHandleResult CListenerImpl::OnClose(ITcpClient *pSender, CONNID dwConnID, EnSocketOperation enOperation, int iErrorCode)
{
    qDebug() << "OnClose, Connection ID: " << dwConnID << ", Operation: " << enOperation << ", Error Code: " << iErrorCode;
    emit sendConnClose();
    return HR_OK;
}

EnHandleResult CListenerImpl::OnShutdown(ITcpClient *pSender)
{
    return HR_OK;
}

mctcpclient.h

#ifndef MCTCPCLIENT_H
#define MCTCPCLIENT_H
#include "clistenerimpl.h"
#include <tchar.h>
#include <QString>
#include <HPSocket.h>
#include <SocketInterface.h>
#include <QDebug>
#include <QTimer>
#include <QObject>

class mCTcpClient: public QObject
{
    Q_OBJECT
public:
    mCTcpClient(QObject *parent=nullptr);
    ~mCTcpClient();
    bool Connect2TCP(LPCTSTR lpszAddress, USHORT usPort);
    bool Send(LPCTSTR lpszData, int iLength);
public slots:
    void receive_HP_connOK();
    void receive_HP_connClosed();
    void receive_HP_Data(QString data);
    void startConnect(LPCTSTR ipAddress, USHORT port);

private:
    CListenerImpl* m_pListener;
    ITcpClient* m_pClient;

    bool b_isConnectState=false;
    LPCTSTR m_AddIp;
    USHORT m_Port;

    QTimer *m_timerConnect;

};

#endif // MCTCPCLIENT_H

mctcpclient.cpp

#include "mctcpclient.h"

mCTcpClient::mCTcpClient(QObject *parent):QObject{parent}
{
    m_pListener = new CListenerImpl();
    m_pClient = nullptr;

    QObject::connect(m_pListener,&CListenerImpl::sendConnOK,this,&mCTcpClient::receive_HP_connOK);
    QObject::connect(m_pListener,&CListenerImpl::sendConnClose,this,&mCTcpClient::receive_HP_connClosed);
    QObject::connect(m_pListener,&CListenerImpl::sendRecvData,this,&mCTcpClient::receive_HP_Data);

    m_timerConnect = new QTimer();
    connect(m_timerConnect, &QTimer::timeout, [=](){
        qDebug()<<"m_pClient"<<m_pClient;
        if (m_pClient != nullptr)
        {
        qDebug()<<"m_pClient->GetState();"<<m_pClient->GetState();
        }

        if(b_isConnectState)
            return;

        Connect2TCP(m_AddIp,m_Port);


    });

}

mCTcpClient::~mCTcpClient()
{
    if (m_pClient != nullptr)
    {
        HP_Destroy_TcpClient(m_pClient);
        qDebug()<<"~~~~~~~~~~~~~~~~~mCTCPClient~~~~~~~~~~~~~";

        m_pClient = nullptr;
    }

    if (m_pListener != nullptr)
    {
        delete m_pListener;
        m_pListener = nullptr;
    }
}

bool mCTcpClient::Connect2TCP(LPCTSTR lpszAddress, USHORT usPort)
{

    if (!m_pClient->Start(lpszAddress,usPort))
    {
        qDebug() << "HP_Client_Start Failed!";
        return false;
    }

    return true;
}

bool mCTcpClient::Send(LPCTSTR lpszData, int iLength)
{
    if (m_pClient == nullptr)
    {
        qDebug() << "TCP Client Not Initialized!";
        return false;
    }


    if (!m_pClient->Send((const BYTE*)lpszData, iLength))
    {

        qDebug() << "TCP Client Send Failed!";
        return false;
    }
    return true;
}

void mCTcpClient::receive_HP_connOK()
{
    qDebug()<<"receive HPSocket connected";
    b_isConnectState=true;
    m_timerConnect->stop();

}

void mCTcpClient::receive_HP_connClosed()
{
    qDebug()<<"receive HPSocket Connect Closed";
    b_isConnectState=false;
    m_timerConnect->start(1000);

}

void mCTcpClient::receive_HP_Data(QString data)
{
    qDebug()<<"receive HPSocket Data:"<<data;
}

void mCTcpClient::startConnect(LPCTSTR ipAddress, USHORT port)
{
    m_AddIp = ipAddress;
    m_Port = port;

    if (m_pClient != nullptr)
    {
        HP_Destroy_TcpClient(m_pClient);
        m_pClient = nullptr;
    }

    m_pClient=HP_Create_TcpClient(m_pListener);
    if (m_pClient == nullptr)
    {
        qDebug() << "Create_HP_TcpClient Failed!";
        return ;
    }

    m_timerConnect->start(1000);
}

Mainwindow.h

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include <mctcpclient.h>
#include <tchar.h>
#include <clistenerimpl.h>
#include <QDateTime>
#include <stdio.h>

//引用QJson相关头文件
#include <QJsonObject>
#include <QJsonValue>
#include <QJsonDocument>

namespace Ui {
class MainWindow;
}

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    explicit MainWindow(QWidget *parent = 0);
    ~MainWindow();
    void initSocket();

    mCTcpClient tcpClient;

//    CHPThreadPoolListenerImpl *ThreadPoolListener;
    //全局共享变量使用extern关键字修饰
//    extern CHPThreadPoolPtr ThreadPool(&ThreadPoolListener);
//     CHPThreadPoolPtr ThreadPool;

private slots:
    void on_pushButton_clicked();

private:
    Ui::MainWindow *ui;

};

#endif // MAINWINDOW_H

Mainwindow.cpp

#include "mainwindow.h"
#include "ui_mainwindow.h"
#pragma comment(lib,"HPSocket_U.lib")


MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
//    ThreadPool{this}
{
    ui->setupUi(this);


    tcpClient.startConnect(_T("192.168.100.25"), 5555);



}

MainWindow::~MainWindow()
{
    tcpClient.deleteLater();
    qDebug()<<"~~~~~~~~~~~~~~~~~MainWindow~~~~~~~~~~~~~";
    delete ui;


}

void MainWindow::initSocket()
{

}

void MainWindow::on_pushButton_clicked()
{

//QString格式
//    QString sendstr="";
//    QString mtime=QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss");
//    sendstr.append(mtime);
//    sendstr.append(",222.222,33.333");

//    std::string q_str=sendstr.toStdString();

//    LPCTSTR c_str = (LPCTSTR)q_str.c_str();
//    tcpClient.Send(c_str,q_str.length());
    //QString格式



    //Json格式：{"timestamp":1704710460913,"guid":"","volume":0.0,"total_volume":0.0,"state":1}
    QJsonObject send_Json_msg;

    //1）插入时间戳（毫秒）
    QJsonValue Json_currtime=QDateTime::currentMSecsSinceEpoch();
    send_Json_msg.insert("timestamp",Json_currtime);

    //2)插入guid
    QString guid="100000007d1c944f";
    send_Json_msg.insert("guid",QJsonValue(guid));

    //3)插入volume
    double volume=0.01;
    send_Json_msg.insert("volume",QJsonValue(volume));

    //4)插入total_volume
    double total_volume=99.999;
    send_Json_msg.insert("total_volume",QJsonValue(total_volume));

    //5)插入状态
    int curr_State=1;
    send_Json_msg.insert("state",QJsonValue(curr_State));

    qDebug()<<"send_Json_msgsend_Json_msgsend_Json_msg"<<send_Json_msg;

    //QJsonObject转QByteArray再转QString
    QString sendstr=QString(QJsonDocument(send_Json_msg).toJson());

    std::string q_str=sendstr.toStdString();
    LPCTSTR c_str = (LPCTSTR)q_str.c_str();
    tcpClient.Send(c_str,q_str.length());


}