~chenluhua/Bond2.git

 
// BEQDemoDlg.cpp : ÊµÏÖÎÄ¼þ
//
 
#include "stdafx.h"
#include "BEQDemo.h"
#include "BEQDemoDlg.h"
#include "afxdialogex.h"
#include <map>
#include <chrono>
#include <sstream>
#include <iomanip>
 
#ifdef _DEBUG
#define new DEBUG_NEW
#endif
 
 
// ÓÃÓÚÓ¦ÓÃ³ÌÐò¡°¹ØÓÚ¡±²Ëµ¥ÏîµÄ CAboutDlg ¶Ô»°¿ò
 
class CAboutDlg : public CDialogEx
{
public:
    CAboutDlg();
 
// ¶Ô»°¿òÊý¾Ý
#ifdef AFX_DESIGN_TIME
    enum { IDD = IDD_ABOUTBOX };
#endif
 
    protected:
    virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV Ö§³Ö
 
// ÊµÏÖ
protected:
    DECLARE_MESSAGE_MAP()
};
 
CAboutDlg::CAboutDlg() : CDialogEx(IDD_ABOUTBOX)
{
}
 
void CAboutDlg::DoDataExchange(CDataExchange* pDX)
{
    CDialogEx::DoDataExchange(pDX);
}
 
BEGIN_MESSAGE_MAP(CAboutDlg, CDialogEx)
END_MESSAGE_MAP()
 
 
// CBEQDemoDlg ¶Ô»°¿ò
 
 
 
CBEQDemoDlg::CBEQDemoDlg(CWnd* pParent /*=NULL*/)
    : CDialogEx(IDD_BEQDEMO_DIALOG, pParent)
{
    m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
}
 
void CBEQDemoDlg::DoDataExchange(CDataExchange* pDX)
{
    CDialogEx::DoDataExchange(pDX);
    DDX_Control(pDX, IDC_EDIT_LOG, m_editLog);
    DDX_Control(pDX, IDC_STATIC_DOOR1, m_staticDoor1);
    DDX_Control(pDX, IDC_STATIC_DOOR2, m_staticDoor2);
    DDX_Control(pDX, IDC_STATIC_DOOR3, m_staticDoor3);
    DDX_Control(pDX, IDC_STATIC_DOOR4, m_staticDoor4);
    DDX_Control(pDX, IDC_STATIC_DOOR5, m_staticDoor5);
}
 
BEGIN_MESSAGE_MAP(CBEQDemoDlg, CDialogEx)
    ON_WM_SYSCOMMAND()
    ON_WM_PAINT()
    ON_WM_QUERYDRAGICON()
    ON_BN_CLICKED(IDC_BUTTON_TEST1, &CBEQDemoDlg::OnBnClickedButtonTest1)
    ON_BN_CLICKED(IDC_BUTTON_TEST2, &CBEQDemoDlg::OnBnClickedButtonTest2)
    ON_BN_CLICKED(IDC_BUTTON_TEST3, &CBEQDemoDlg::OnBnClickedButtonTest3)
    ON_BN_CLICKED(IDC_BUTTON_SET_STATE, &CBEQDemoDlg::OnBnClickedButtonSetState)
    ON_BN_CLICKED(IDC_BUTTON_SET_STATE2, &CBEQDemoDlg::OnBnClickedButtonSetState2)
    ON_BN_CLICKED(IDC_BUTTON_SERVO_TEST1, &CBEQDemoDlg::OnBnClickedButtonServoTest1)
    ON_BN_CLICKED(IDC_BUTTON_SERVO_TEST2, &CBEQDemoDlg::OnBnClickedButtonServoTest2)
    ON_BN_CLICKED(IDC_BUTTON_SERVO_TEST3, &CBEQDemoDlg::OnBnClickedButtonServoTest3)
END_MESSAGE_MAP()
 
 
// CBEQDemoDlg ÏûÏ¢´¦Àí³ÌÐò
 
BOOL CBEQDemoDlg::OnInitDialog()
{
    CDialogEx::OnInitDialog();
 
    // ½«¡°¹ØÓÚ...¡±²Ëµ¥ÏîÌí¼Óµ½ÏµÍ³²Ëµ¥ÖÐ¡£
 
    // IDM_ABOUTBOX ±ØÐëÔÚÏµÍ³ÃüÁî·¶Î§ÄÚ¡£
    ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
    ASSERT(IDM_ABOUTBOX < 0xF000);
 
    CMenu* pSysMenu = GetSystemMenu(FALSE);
    if (pSysMenu != NULL)
    {
        BOOL bNameValid;
        CString strAboutMenu;
        bNameValid = strAboutMenu.LoadString(IDS_ABOUTBOX);
        ASSERT(bNameValid);
        if (!strAboutMenu.IsEmpty())
        {
            pSysMenu->AppendMenu(MF_SEPARATOR);
            pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
        }
    }
 
    // ÉèÖÃ´Ë¶Ô»°¿òµÄÍ¼±ê¡£  µ±Ó¦ÓÃ³ÌÐòÖ÷´°¿Ú²»ÊÇ¶Ô»°¿òÊ±£¬¿ò¼Ü½«×Ô¶¯
    //  Ö´ÐÐ´Ë²Ù×÷
    SetIcon(m_hIcon, TRUE);            // ÉèÖÃ´óÍ¼±ê
    SetIcon(m_hIcon, FALSE);        // ÉèÖÃÐ¡Í¼±ê
 
    // TODO: ÔÚ´ËÌí¼Ó¶îÍâµÄ³õÊ¼»¯´úÂë
 
    return TRUE;  // ³ý·Ç½«½¹µãÉèÖÃµ½¿Ø¼þ£¬·ñÔò·µ»Ø TRUE
}
 
void CBEQDemoDlg::OnSysCommand(UINT nID, LPARAM lParam)
{
    if ((nID & 0xFFF0) == IDM_ABOUTBOX)
    {
        CAboutDlg dlgAbout;
        dlgAbout.DoModal();
    }
    else
    {
        CDialogEx::OnSysCommand(nID, lParam);
    }
}
 
// Èç¹ûÏò¶Ô»°¿òÌí¼Ó×îÐ¡»¯°´Å¥£¬ÔòÐèÒªÏÂÃæµÄ´úÂë
//  À´»æÖÆ¸ÃÍ¼±ê¡£  ¶ÔÓÚÊ¹ÓÃÎÄµµ/ÊÓÍ¼Ä£ÐÍµÄ MFC Ó¦ÓÃ³ÌÐò£¬
//  Õâ½«ÓÉ¿ò¼Ü×Ô¶¯Íê³É¡£
 
void CBEQDemoDlg::OnPaint()
{
    if (IsIconic())
    {
        CPaintDC dc(this); // ÓÃÓÚ»æÖÆµÄÉè±¸ÉÏÏÂÎÄ
 
        SendMessage(WM_ICONERASEBKGND, reinterpret_cast<WPARAM>(dc.GetSafeHdc()), 0);
 
        // Ê¹Í¼±êÔÚ¹¤×÷Çø¾ØÐÎÖÐ¾ÓÖÐ
        int cxIcon = GetSystemMetrics(SM_CXICON);
        int cyIcon = GetSystemMetrics(SM_CYICON);
        CRect rect;
        GetClientRect(&rect);
        int x = (rect.Width() - cxIcon + 1) / 2;
        int y = (rect.Height() - cyIcon + 1) / 2;
 
        // »æÖÆÍ¼±ê
        dc.DrawIcon(x, y, m_hIcon);
    }
    else
    {
        CDialogEx::OnPaint();
    }
}
 
//µ±ÓÃ»§ÍÏ¶¯×îÐ¡»¯´°¿ÚÊ±ÏµÍ³µ÷ÓÃ´Ëº¯ÊýÈ¡µÃ¹â±ê
//ÏÔÊ¾¡£
HCURSOR CBEQDemoDlg::OnQueryDragIcon()
{
    return static_cast<HCURSOR>(m_hIcon);
}
 
void CBEQDemoDlg::OnBnClickedButtonTest1()
{
    BEQ::IEquipment* pEuqipment = nullptr;
    BEQ_CreateEquipment(pEuqipment, "BEQ001");
}
 
void CBEQDemoDlg::OnBnClickedButtonTest2()
{
    BEQ::IEquipment* pEuqipment = nullptr;
    BEQ_GetEquipment(pEuqipment, "BEQ001");
    if (pEuqipment != nullptr) {
        pEuqipment->setVersion("1.0.2");
        BEQ::IUnit* pUnit1 = pEuqipment->addUnit("U1", 5);
        pEuqipment->runOnServerMode(8080);
 
        char szName[256];
        pUnit1->getName(szName, 256);
        AfxMessageBox(szName);
        pUnit1->setState(BEQ::EQ_STATE::IDLE);
    }
}
 
void CBEQDemoDlg::OnBnClickedButtonTest3()
{
    BEQ::IEquipment* pEuqipment = nullptr;
    BEQ_GetEquipment(pEuqipment, "Test1");
    if (pEuqipment != nullptr) {
        BEQ_DestroyEquipment(pEuqipment);
    }
}
 
void CBEQDemoDlg::OnBnClickedButtonSetState()
{
    BEQ::IUnit* pUnit = nullptr;
    BEQ::IEquipment* pEuqipment = nullptr;
    BEQ_GetEquipment(pEuqipment, "BEQ001");
    if (pEuqipment != nullptr) {
        pUnit = pEuqipment->getUnit("U1");
    }
 
    if (pUnit != nullptr) {
        // pUnit->setState(BEQ::EQ_STATE::E_TIME);
        // pUnit->setDoorState(BEQ::DOOR_STATE::CLOSE);
        pUnit->setAlarm(0, 0, "");
    }
}
 
void CBEQDemoDlg::OnBnClickedButtonSetState2()
{
    BEQ::IUnit* pUnit = nullptr;
    BEQ::IEquipment* pEuqipment = nullptr;
    BEQ_GetEquipment(pEuqipment, "BEQ001");
    if (pEuqipment != nullptr) {
        pUnit = pEuqipment->getUnit("U1");
    }
 
    if (pUnit != nullptr) {
        // pUnit->setState(BEQ::EQ_STATE::RUN);
        // pUnit->setDoorState(BEQ::DOOR_STATE::OPEN);
        // pUnit->setAlarm(206, 1, "Aµ¥Ôª-ÉÏÇ»ÌåZÖá1Òì³£");
 
        /*
        static int i = 0;
        i++;
        if (i % 6 == 1) {
            pUnit->stepIdle();
        }
        if (i % 6 == 2) {
            pUnit->stepMaterialReceived("A12345");
        }
        if (i % 6 == 3) {
            pUnit->stepProcessingStarted("A12345");
        }
        if (i % 6 == 4) {
            pUnit->stepProcessing("A12345", 15, 1);
        }
        if (i % 6 == 5) {
            pUnit->stepMaterialRemoved("A12345");
        }
        if (i % 6 == 0) {
            pUnit->stepProcessingCompleted("A12345");
        }
        */
 
 
        /*
        auto now = std::chrono::system_clock::now();
        auto duration_in_milliseconds = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch());
        uint64_t timestamp = duration_in_milliseconds.count();
        pUnit->setDataTimeAndResetData(timestamp);
 
        static int i = 0;
        i++;
        if (i < 6) {
            pUnit->addData("TMP", "1.1,2.1,3.2,4.3,5.4,6.6,7.7,8.8,9.9,10.1,11.1,12.1", false);
            pUnit->addData("AIR", "112.19", false);
            pUnit->addData("PRE", "151,152.3,153.4,154.5,155.6", true);
        }
        else {
            pUnit->addData("TMP", "81.1,2.1,3.2,4.3,5.4,6.6,7.7,8.8,9.9,10.1,11.1,12.1", false);
            pUnit->addData("AIR", "8112.19", false);
            pUnit->addData("PRE", "8151,152.3,153.4,154.5,155.6", true);
        }*/
 
        pUnit->addRecipe(1001, "RECIPE_1001", false);
        pUnit->addRecipe(1002, "RECIPE_1002", false);
        pUnit->addRecipe(1003, "RECIPE_1003", false);
        pUnit->addRecipe(1004, "RECIPE_1004", false);
        pUnit->addRecipe(1005, "RECIPE_1005", false);
        pUnit->addRecipe(1006, "RECIPE_1006", true);
    }
}
 
void CBEQDemoDlg::OnBnClickedButtonServoTest1()
{
    BEQ::IServo* pServo = nullptr;
    BEQ_CreateServo(pServo, "BLServo");
    ASSERT(pServo);
 
    BEQ::IRemoteEquipment* pRemoteEquipment = nullptr;
    pServo->createRemoteEquipment(pRemoteEquipment, "127.0.0.1", 8192);
    ASSERT(pRemoteEquipment);
 
    if (pRemoteEquipment != nullptr) {
        BEQ::IUnit* pUnitA = pRemoteEquipment->addUnit("UNITA", 5);
        BEQ::IUnit* pUnitB = pRemoteEquipment->addUnit("UNITB", 5);
    }
 
    char szAddr[64];
    pRemoteEquipment->getAddr(szAddr, 64);
    CString s; s.Format("%s:%d", szAddr, pRemoteEquipment->getPort());
    AfxMessageBox(s);
 
    BEQ::ServoListener listener;
    listener.onRemoteEqConnecting = [&](void* pServo, void* pRemoteEiuipment) -> void {
        TRACE("<ServoListener>onRemoteEqConnecting...\n");
    };
    listener.onRemoteEqConnected = [&](void* pServo, void* pRemoteEiuipment) -> void {
        TRACE("<ServoListener>onRemoteEqConnected...\n");
    };
    listener.onRemoteEqConnectFailed = [&](void* pServo, void* pRemoteEiuipment, int errorCode) -> void {
        TRACE("<ServoListener>onRemoteEqConnectFailed...\n");
    };
    listener.onRemoteEqDisconnecting = [&](void* pServo, void* pRemoteEiuipment) -> void {
        TRACE("<ServoListener>onRemoteEqDisconnecting...\n");
    };
    listener.onRemoteEqDisconnected = [&](void* pServo, void* pRemoteEiuipment) -> void {
        TRACE("<ServoListener>onRemoteEqDisconnected...\n");
    };
    listener.onRemoteEqReadRawdata = [&](void* pServo, void* pRemoteEiuipment, const char* pszData, int len) -> void {
        TRACE("<ServoListener>onRemoteEqReadRawdata...\n");
    };
    listener.onRemoteEqEventUpdate = [&](void* pServo, void* pRemoteEiuipment, void* pUnit, BEQ::REMOTE_EQ_EVENT eventCode) -> void {
        TRACE("<ServoListener>onRemoteEqEventUpdate...\n");
        HandleRemoteEqEventUpdate(eventCode, pUnit);
    };
    pServo->setListener(listener);
    pServo->connectRemoteEquipment(pRemoteEquipment);
}
 
void CBEQDemoDlg::OnBnClickedButtonServoTest2()
{
    BEQ::IServo* pServo = nullptr;
    BEQ_GetServo(pServo, "BLServo");
    ASSERT(pServo);
 
    char szName[256];
    pServo->getName(szName, 256);
    AfxMessageBox(szName);
}
 
void CBEQDemoDlg::OnBnClickedButtonServoTest3()
{
    // TODO: ÔÚ´ËÌí¼Ó¿Ø¼þÍ¨Öª´¦Àí³ÌÐò´úÂë
}
 
void CBEQDemoDlg::AppendTextToLog(const CString& text)
{
    // ×·¼ÓÎÄ±¾Ö®Ç°¼ì²éÐÐÊý
    CString existingText;
    m_editLog.GetWindowText(existingText);
 
    // ¼ÆËãµ±Ç°ÐÐÊý
    int lineCount = 0;
    for (int i = 0; i < existingText.GetLength(); i++)
    {
        if (existingText[i] == '\n')
            lineCount++;
    }
 
    // Èç¹ûÐÐÊý³¬¹ý 100£¬Çå¿Õ¿Ø¼þ
    if (lineCount >= 100)
    {
        m_editLog.SetWindowText(_T("")); // Çå¿Õ¿Ø¼þ
    }
 
    // ×·¼ÓÐÂÎÄ±¾
    m_editLog.SetSel(m_editLog.GetWindowTextLength(), m_editLog.GetWindowTextLength()); // ÉèÖÃ¹â±êµ½ÎÄ±¾Ä©Î²
    m_editLog.ReplaceSel(text + _T("\r\n")); // ×·¼ÓÎÄ±¾²¢»»ÐÐ
}
 
const char* CBEQDemoDlg::ConverUint64ToTimeString(uint64_t time)
{
    static char buffer[32];
    auto timePoint = std::chrono::time_point<std::chrono::system_clock>(std::chrono::milliseconds(time));
    std::time_t t = std::chrono::system_clock::to_time_t(timePoint);
    std::tm tmPtr;
    if (localtime_s(&tmPtr, &t) == 0) {
        strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", &tmPtr);
    }
    else {
        snprintf(buffer, sizeof(buffer), "Invalid Time");
    }
 
    return buffer;
}
 
void CBEQDemoDlg::UpdateDoorStatus(CColorStatic& doorControl, bool isOpen)
{
    if (isOpen) {
        doorControl.SetWindowText(_T("open"));
        doorControl.SetBkColor(RGB(255, 0, 0)); // ºìÉ«±íÊ¾´ò¿ª
    }
    else {
        doorControl.SetWindowText(_T("close"));
        doorControl.SetBkColor(RGB(0, 255, 0)); // ÂÌÉ«±íÊ¾¹Ø±Õ
    }
    doorControl.Invalidate();
}
 
void CBEQDemoDlg::HandleRemoteEqEventUpdate(BEQ::REMOTE_EQ_EVENT eventCode, void* pUnit)
{
    BEQ::IUnit* pUnitEx = (BEQ::IUnit*)pUnit;
    char chUnitName[128] = {0};
    pUnitEx->getName(chUnitName, sizeof(chUnitName));
 
    switch (eventCode) {
    case BEQ::REMOTE_EQ_EVENT::DEVICE_STATUS_CHANGED: {
        // ´¦ÀíÉè±¸×´Ì¬
        CString strStatus;
        static char* eqState[] = { "IDLE", "RUN", "DOWN", "MAINTENANCE", "MCHG", "E_TIME" };
        strStatus.Format("DEVICE_STATUS_CHANGED@%s: %s", chUnitName, eqState[(int)pUnitEx->getState()]);
        AppendTextToLog(strStatus);
        break;
    }
    case BEQ::REMOTE_EQ_EVENT::DOOR_STATUS_CHANGED: {
        // ´¦ÀíÃÅ×´Ì¬
        UpdateDoorStatus(m_staticDoor1, (pUnitEx->getDoorState() >> 0) & 1);
        UpdateDoorStatus(m_staticDoor2, (pUnitEx->getDoorState() >> 1) & 1);
        UpdateDoorStatus(m_staticDoor3, (pUnitEx->getDoorState() >> 2) & 1);
        UpdateDoorStatus(m_staticDoor4, (pUnitEx->getDoorState() >> 3) & 1);
        UpdateDoorStatus(m_staticDoor5, (pUnitEx->getDoorState() >> 4) & 1);
 
        CString strDoorStatus;
        strDoorStatus.Format("DOOR_STATUS_CHANGED@%s: %d", chUnitName, pUnitEx->getDoorState());
        AppendTextToLog(strDoorStatus);
        break;
    }
    case BEQ::REMOTE_EQ_EVENT::ALARM_INFO_CHANGED: {
        // ´¦Àí±¨¾¯ÐÅÏ¢
        CString strAlarmInfo;
        strAlarmInfo.Format("ALARM_INFO_CHANGED@%s: %d %d", chUnitName, pUnitEx->getAlarmCode(), pUnitEx->getAlarmLevel());
        AppendTextToLog(strAlarmInfo);
        break;
    }
    case BEQ::REMOTE_EQ_EVENT::REMOVE_ALARM_INFO: {
        // ´¦Àí½â³ý¸æ¾¯
        CString strRemoveAlarmInfo;
        strRemoveAlarmInfo.Format("REMOVE_ALARM_INFO@%s: %d %d", chUnitName, pUnitEx->getAlarmCode(), pUnitEx->getAlarmLevel());
        AppendTextToLog(strRemoveAlarmInfo);
        break;
    }
    case BEQ::REMOTE_EQ_EVENT::PRODUCTION_PROCESS_CHANGED: {
        // ´¦ÀíÖÆ×÷¹ý³Ì×´Ì¬
        static char* stepState[] = { "IDLE", "MATERIAL_RECEIVED", "MATERIAL_REMOVED", "PROCESSING_STARTED", "PROCESSING", "PROCESSING_COMPLETED" };
        CString strProduction;
        strProduction.Format("PRODUCTION_PROCESS_CHANGED@%s: %s", chUnitName, stepState[(int)pUnitEx->getStepState()]);
        AppendTextToLog(strProduction);
        break;
    }
    case BEQ::REMOTE_EQ_EVENT::SERSOR_DATA_CHANGED: {
        // ´¦Àí×îÐÂÊý¾Ý£¬´«¸ÐÆ÷£¨ÎÂ¶È¡¢Ñ¹Á¦µÈ£©
        CString strSersorData;
        strSersorData.Format("SERSOR_DATA_CHANGED@%s: %s", chUnitName, ConverUint64ToTimeString(pUnitEx->getDataTime()));
        AppendTextToLog(strSersorData);
        break;
    }
    case::BEQ::REMOTE_EQ_EVENT::RECIPE_LIST_CHANGED: {
        // ´¦ÀíÅä·½ÁÐ±í
        CString strRecipeList;
        strRecipeList.Format("RECIPE_LIST_CHANGED@%s: ", chUnitName);
        std::map<int, std::string> mapRec;// = pUnit->getRecipes();
        for (auto it = mapRec.begin(); it != mapRec.end(); it++)
        {
            TRACE("RecipeList[%d]: %s\n", it->first, it->second.c_str());
        }
        AppendTextToLog(strRecipeList);
        break;
    }
    case BEQ::REMOTE_EQ_EVENT::LOAD_EVENT_CHANGED: {
        // ´¦ÀíÉÏ±¨ÊÂ¼þ
        break;
    }
    default:
        // ´¦ÀíÆäËû×´Ì¬...
        TRACE("<ServoListener>Unknown status...\n");
        break;
    }
}