0

嗨，我目前正在做一个项目，我们正在创建一个 UDP 服务器来与 KUKA 机器人通信。我们能够建立与机器人的连接并来回交换数据，但是当发生诸如机器人因电机过转矩而发生故障等事件时。因此，为了检测此故障，我们在代码中添加了超时，以便主对话框将关闭并重新打开，以便重新初始化所有变量，我们可以将连接设置为重新建立。

这是服务器代码：

#include "stdafx.h"
#include "HapticRobot.h"

#include "CMaths.h"
using namespace chai3d;


#include <winsock.h>
using namespace std;
#pragma comment(lib, "Ws2.lib")
#include <fstream>
#include <string>
#include <sstream>

DWORD WINAPI DoGravity(LPVOID lpParameter);

#define REFRESH_INTERVAL  0   // sec

const int kBufferSize = 1024;
int nTempHold;

extern HapticDevice hd;
extern HWND g_hWndHapticBox;
extern bool bRobotInMotion, bRobotConnectInit, bRobotConnected;
extern Handles hc;
bool err;
std::string stSend, stSendXML, stLine;
std::string stRobotStatus , stAppend;
TCHAR *chRobotStatus;
//variables for timeout
fd_set fds;
int n;
struct timeval tv;

//// Prototypes ////////////////////////////////////////////////////////

SOCKET SetUpListener(const char* pcAddress, int nPort);
bool EchoIncomingPackets(SOCKET sd);


//// DoWinsock /////////////////////////////////////////////////////////
// The module's driver function -- we just call other functions and
// interpret their results.


int DoWinsock(const char* pcAddress, int nPort)
{
    int nRetval = 0;

    ifstream inFile("HardDisk/ExternalData.xml");
    if (inFile.is_open())
    {
        while ( inFile.good() )
        {
            getline ( inFile, stLine);
            stSendXML.append(stLine);
        }
        inFile.close();
    }

    SendDlgItemMessage(g_hWndHapticBox, IDC_LIST_Server, LB_INSERTSTRING, 0, (LPARAM)L"Establishing the listener...");
    SOCKET ListeningSocket = SetUpListener(pcAddress, htons(nPort));
    SendDlgItemMessage(g_hWndHapticBox, IDC_LIST_Server, LB_INSERTSTRING, 0, (LPARAM)L"Waiting for connections...");
    bRobotConnectInit = true;
    SetDlgItemText(g_hWndHapticBox, IDC_STATIC_RobotStatus, _T("Waiting for robot"));
    while (1)
    {
        EchoIncomingPackets(ListeningSocket);
        bRobotConnected = false;
        bRobotConnectInit = true;

        SendDlgItemMessage(g_hWndHapticBox, IDC_LIST_Server, LB_INSERTSTRING, 0, (LPARAM)L"Acceptor restarting...");

    }
}


//// SetUpListener /////////////////////////////////////////////////////
// Sets up a listener on the given interface and port, returning the
// listening socket if successful; if not, returns INVALID_SOCKET.

SOCKET SetUpListener(const char* pcAddress, int nPort)
{
    u_long nInterfaceAddr = inet_addr(pcAddress);
    if (nInterfaceAddr != INADDR_NONE)
    {
        SOCKET sd = socket(AF_INET, SOCK_DGRAM, 0);

        sockaddr_in sinInterface;
        sinInterface.sin_family = AF_INET;
        sinInterface.sin_addr.s_addr = nInterfaceAddr;
        sinInterface.sin_port = nPort;
        if (bind(sd, (sockaddr*)&sinInterface, 
                sizeof(sockaddr_in)) != SOCKET_ERROR)
        {
            return sd;
        }

    }

    return INVALID_SOCKET;
}

//// EchoIncomingPackets ///////////////////////////////////////////////
// Bounces any incoming packets back to the client.  We return false
// on errors, or true if the client closed the socket normally.

bool EchoIncomingPackets(SOCKET sd)
{
    // Read data from client

    std::string stReceive;
    std::string stIPOC;

    std::wstring stTime;
    int nStartPos, nEndPos;
    char acReadBuffer[kBufferSize], acWriteBuffer[512];
    int nReadBytes;

    struct sockaddr_in clientAddr;
    int sockAddrSize = sizeof(struct sockaddr_in);


    //declarations for the low pass filter
    int CURRENT_VALUE = 2;
    double T = .004, w_co, OMEGA_co, f_co;

    hd.bFirstRunRobot = true;



    do
    {

    //This will be to timeout the socket connection
        FD_ZERO(&fds);
        FD_SET(sd, &fds);

        tv.tv_sec = 5;
        tv.tv_usec = 0;

        n = select (sd, &fds, NULL, NULL, &tv );
        if (n == 0)
        {

            PostMessage(g_hWndHapticBox,WM_CLOSE, 0, 0);
            Sleep(5000);

            PostMessage(g_hWndHapticBox, WM_INITDIALOG, 0, 0);
            Sleep(1000);
            //printf("Timeout..\n");
            //HapticBox(HWND, UINT, WPARAM, LPARAM);
            //return 0;
        }
        else if (n == -1)
        {
            printf("Error..\n");
            return 1;
        }
        //  end timeout

        nReadBytes = recvfrom(sd, acReadBuffer, sizeof(acReadBuffer), 0, (struct sockaddr*)&clientAddr, &sockAddrSize);

        //nReadBytes = recvfrom(sd, acReadBuffer, sizeof(acReadBuffer), MSG_PEEK, (struct sockaddr*)&clientAddr, &sockAddrSize);
        //if (nReadBytes == SOCKET_ERROR)
        //{
        //  SetDlgItemText(g_hWndHapticBox, IDC_STATIC_RobotStatus, _T("ERROR"));
        //}

        if (nReadBytes < 0 || nReadBytes == 0)
        {
            SetDlgItemText(g_hWndHapticBox, IDC_STATIC_RobotStatus, _T("ERROR 1"));
            return true;
        }

        if (nReadBytes > 0)
        {
            if (bRobotConnectInit)
            {
                bRobotConnectInit = false;
                bRobotConnected = true;
                SetDlgItemText(g_hWndHapticBox, IDC_STATIC_RobotStatus, _T("Connected to Robot"));
            }
        }


        stSend = stSendXML;
        stReceive = acReadBuffer;

        nStartPos = stReceive.find ("<IPOC>") + 6;
        nEndPos = stReceive.find ("</IPOC>");
        stIPOC = stReceive.substr (nStartPos, nEndPos - nStartPos);

        nStartPos = stSend.find ("<IPOC>") + 6;
        nEndPos = stSend.find ("</IPOC>");
        stSend.replace(nStartPos, nEndPos - nStartPos, stIPOC);

        //Raw sensor data
        nStartPos = stReceive.find ("RFx=") + 5;
        nEndPos = stReceive.find ("RFy=") - 2;
        hd.stRFx = stReceive.substr (nStartPos, nEndPos - nStartPos);
        hd.szRFx = hd.stRFx.c_str();
        hd.RFx = strtod(hd.szRFx, NULL);
        hd.RFx = hd.RFx * 0.22;

        nStartPos = stReceive.find ("RFy=") + 5;
        nEndPos = stReceive.find ("RFz=") - 2;
        hd.stRFy = stReceive.substr (nStartPos, nEndPos - nStartPos);
        hd.szRFy = hd.stRFy.c_str();
        hd.RFy = strtod(hd.szRFy, NULL);
        hd.RFy = hd.RFy * 0.22;



                **//...more XML stuff...//**


        //data the is to be sent to the robot
        if (hd.FirstTimePosition)
        {
            hd.RobotXStartPosition = hd.RobotXPosition;
            hd.RobotYStartPosition = hd.RobotYPosition;
            hd.RobotZStartPosition = hd.RobotZPosition;         
            hd.FirstTimePosition = false;
        }



        if(hd.LinearScale == 4)
        {
            f_co = 0.5;
        }
        else if (hd.LinearScale == 3)
        {
            f_co = 0.5;
        }
        else if (hd.LinearScale == 2)
        {
            f_co = 1;
        }
        else if (hd.LinearScale == 1)
        {
            f_co = 2;
        }
        else if (hd.LinearScale == 0.5)
        {
            f_co = 2;
        }
        else
        {
            f_co = 0.5;
        }

        if (hd.Fz < hd.MaxForcePos)
        {
            hd.ForceLimitPosZ = false;
        }
        if (hd.Fz > hd.MaxForceNeg)
        {
            hd.ForceLimitNegZ = false;
        }
        if (hd.Fz > hd.MaxForcePos || hd.ForceLimitPosZ)
        {
            if (!hd.ForceLimitPosZ)
            {
                hd.CurrentZtoRobotPosition = hd.ZtoRobot;
            }
            if (hd.CurrentZtoRobotPosition >= hd.ZtoRobot)
            {
                hd.NewZtoRobot = hd.PreviousZtoRobot;
                hd.ForceLimitPosZ = true;
            }
            else
            {
                hd.ForceLimitPosZ = false;
            }
        }

        if (hd.ForceLimitPosZ)
        {
            hd.ForceZtoRobot = hd.NewZtoRobot;
        }
        else
        {
            hd.ForceZtoRobot = hd.ZtoRobot;
        }

        w_co = f_co * C_TWO_PI;
        OMEGA_co = (2/T) * cTanRad((w_co * T) / 2);

        hd.raw_x[CURRENT_VALUE] = hd.XtoRobot;
        hd.raw_y[CURRENT_VALUE] = hd.YtoRobot;
        hd.raw_z[CURRENT_VALUE] = hd.ForceZtoRobot;

        hd.filtered_x[CURRENT_VALUE] = (pow(((OMEGA_co) / ((2 / T) + OMEGA_co)), 2)) * 
            ((hd.raw_x[CURRENT_VALUE]) + (2 * hd.raw_x[CURRENT_VALUE - 1] + hd.raw_x[CURRENT_VALUE - 2])) 
            - (((2 * (OMEGA_co - (2 / T))) / ((2 / T) + OMEGA_co)) * hd.filtered_x[CURRENT_VALUE - 1])
            - ((pow(((OMEGA_co - (2 / T)) / ((2 / T) + OMEGA_co)),2)) * hd.filtered_x[CURRENT_VALUE - 2]);

        **//more digital filter stuff//**    

        hd.raw_x[CURRENT_VALUE - 2] = hd.raw_x[CURRENT_VALUE - 1];
        hd.raw_y[CURRENT_VALUE - 2] = hd.raw_y[CURRENT_VALUE - 1];
        hd.raw_z[CURRENT_VALUE - 2] = hd.raw_z[CURRENT_VALUE - 1];

        hd.raw_x[CURRENT_VALUE - 1] = hd.raw_x[CURRENT_VALUE];
        hd.raw_y[CURRENT_VALUE - 1] = hd.raw_y[CURRENT_VALUE];
        hd.raw_z[CURRENT_VALUE - 1] = hd.raw_z[CURRENT_VALUE];

        hd.filtered_x[CURRENT_VALUE - 2] = hd.filtered_x[CURRENT_VALUE - 1];
        hd.filtered_y[CURRENT_VALUE - 2] = hd.filtered_y[CURRENT_VALUE - 1];
        hd.filtered_z[CURRENT_VALUE - 2] = hd.filtered_z[CURRENT_VALUE - 1];

        hd.filtered_x[CURRENT_VALUE - 1] = hd.filtered_x[CURRENT_VALUE];
        hd.filtered_y[CURRENT_VALUE - 1] = hd.filtered_y[CURRENT_VALUE];
        hd.filtered_z[CURRENT_VALUE - 1] = hd.filtered_z[CURRENT_VALUE];



        hd.stXtoRobot = dtostr(hd.filtered_x[CURRENT_VALUE]);
        nStartPos = stSend.find ("X=") + 3;
        stSend.replace(nStartPos, 6, hd.stXtoRobot);

        hd.stYtoRobot = dtostr(hd.filtered_y[CURRENT_VALUE]);
        nStartPos = stSend.find ("Y=") + 3;
        stSend.replace(nStartPos, 6, hd.stYtoRobot);

        hd.stZtoRobot = dtostr(hd.filtered_z[CURRENT_VALUE]);
        nStartPos = stSend.find ("Z=") + 3;
        stSend.replace(nStartPos, 6, hd.stZtoRobot);

        if (hd.ForceLimitPosZ)
        {
            hd.PreviousZtoRobot = hd.NewZtoRobot;
        }
        else
        {
            hd.PreviousZtoRobot = hd.ZtoRobot;
        }

        strcpy( static_cast<char*>( &acWriteBuffer[0] ), stSend.c_str() );

        if (nReadBytes > 0)
        {
            int nSentBytes = 0;
            int SendLength = strlen(acWriteBuffer);
            while (nSentBytes < SendLength)
            {
                int nTemp = sendto(sd, acWriteBuffer, SendLength, 0, (const sockaddr*)&clientAddr, sockAddrSize);
                nTempHold = nTemp;

                if (nTemp > 0)
                {
                    nSentBytes += nTemp;
                }
                else if (nTemp == SOCKET_ERROR)
                {
                    return false;
                }
                else
                {
                    // Client closed connection before we could reply to
                    // all the data it sent, so bomb out early.
                    SendDlgItemMessage(g_hWndHapticBox, IDC_LIST_Server, LB_INSERTSTRING, 0, (LPARAM)L"Peer unexpectedly dropped connection!");
                    return true;
                }
            }
        }
        else if (nReadBytes == SOCKET_ERROR)
        {
            return false;
        }
        hd.bFirstRunRobot = false;
    }while (nReadBytes != 0);

    SendDlgItemMessage(g_hWndHapticBox, IDC_LIST_Server, LB_INSERTSTRING, 0, (LPARAM)L"Connection closed by peer.");
    bRobotConnected = false;
    bRobotConnectInit = true;
    SetDlgItemText(g_hWndHapticBox, IDC_STATIC_RobotStatus, _T("Waiting for robot"));
    SetDlgItemText(g_hWndHapticBox, IDC_STATIC_RobotInMotion, _T("Robot not in motion"));

    return true;
    //}
}

这是 GUI 的代码：

// HapticRobot.cpp : Defines the entry point for the application.
//

#include "stdafx.h"
#include "HapticRobot.h"
#include <sstream>
#include <string>
using namespace std;

#define MAX_LOADSTRING 100

// Global Variables:
HINSTANCE           g_hInst;            // current instance
HWND                g_hWndCommandBar;   // command bar handle
HWND                g_hWndHapticBox;    // haptic dialog handle

bool bRobotInMotion, bRobotConnectInit, bRobotConnected;
extern HapticDevice hd;
HDC hdc;
Handles hc;
DWORD WINAPI DoGravity(LPVOID lpParameter);
DWORD WINAPI DoConnectRobot(LPVOID lpParameter);

// Forward declarations of functions included in this code module:
ATOM                MyRegisterClass(HINSTANCE, LPTSTR);
BOOL                InitInstance(HINSTANCE, int);
LRESULT CALLBACK    WndProc(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK    About(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK    HapticBox(HWND, UINT, WPARAM, LPARAM);

int WINAPI WinMain(HINSTANCE hInstance,
                   HINSTANCE hPrevInstance,
                   LPTSTR    lpCmdLine,
                   int       nCmdShow)
{
    MSG msg;

    // Perform application initialization:
    if (!InitInstance(hInstance, nCmdShow)) 
    {
        return FALSE;
    }

    HACCEL hAccelTable;
    hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_HAPTICROBOT));

    DialogBox(hInstance, (LPCTSTR)IDD_HAPTIC, NULL, HapticBox);

    // Main message loop:
    while (GetMessage(&msg, NULL, 0, 0)) 
    {
        if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg)) 
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }

    return (int) msg.wParam;
}

//
//  FUNCTION: MyRegisterClass()
//
//  PURPOSE: Registers the window class.
//
//  COMMENTS:
//
ATOM MyRegisterClass(HINSTANCE hInstance, LPTSTR szWindowClass)
{
    WNDCLASS wc;

    wc.style         = CS_HREDRAW | CS_VREDRAW;
    wc.lpfnWndProc   = WndProc;
    wc.cbClsExtra    = 0;
    wc.cbWndExtra    = 0;
    wc.hInstance     = hInstance;
    wc.hIcon         = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_HAPTICROBOT));
    wc.hCursor       = 0;
    wc.hbrBackground = (HBRUSH) GetStockObject(WHITE_BRUSH);
    wc.lpszMenuName  = 0;
    wc.lpszClassName = szWindowClass;

    return RegisterClass(&wc);
}


//FUNCTION: InitInstance(HINSTANCE, int)

//PURPOSE: Saves instance handle and creates main window

//COMMENTS:

//     In this function, we save the instance handle in a global variable and
//     create and display the main program window.

BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
    HWND hWnd;
    TCHAR szTitle[MAX_LOADSTRING];          // title bar text
    TCHAR szWindowClass[MAX_LOADSTRING];    // main window class name

    g_hInst = hInstance; // Store instance handle in our global variable


    LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING); 
    LoadString(hInstance, IDC_HAPTICROBOT, szWindowClass, MAX_LOADSTRING);


    if (!MyRegisterClass(hInstance, szWindowClass))
    {
        return FALSE;
    }

    hWnd = CreateWindow(szWindowClass, szTitle, WS_VISIBLE,
        CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, NULL, NULL, hInstance, NULL);

    if (!hWnd)
    {
        return FALSE;
    }


    ShowWindow(hWnd, nCmdShow);
    UpdateWindow(hWnd);

    if (g_hWndCommandBar)
    {
        CommandBar_Show(g_hWndCommandBar, TRUE);
    }

    return TRUE;
}

//
//  FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM)
//
//  PURPOSE:  Processes messages for the main window.
//
//  WM_COMMAND  - process the application menu
//  WM_PAINT    - Paint the main window
//  WM_DESTROY  - post a quit message and return
//
//
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    int wmId, wmEvent;
    PAINTSTRUCT ps;
    HDC hdc;


    switch (message) 
    {
        case WM_COMMAND:
            wmId    = LOWORD(wParam); 
            wmEvent = HIWORD(wParam); 
            // Parse the menu selections:
            switch (wmId)
            {
                case IDM_HELP_ABOUT:
                    DialogBox(g_hInst, (LPCTSTR)IDD_ABOUTBOX, hWnd, About);
                    break;
                case IDM_FILE_EXIT:
                    dhdClose ();
                    DestroyWindow(hWnd);
                    break;
                default:
                    return DefWindowProc(hWnd, message, wParam, lParam);
            }
            break;
        case WM_CREATE:
            g_hWndCommandBar = CommandBar_Create(g_hInst, hWnd, 1);
            CommandBar_InsertMenubar(g_hWndCommandBar, g_hInst, IDR_MENU, 0);
            CommandBar_AddAdornments(g_hWndCommandBar, 0, 0);
            break;
        case WM_PAINT:
            hdc = BeginPaint(hWnd, &ps);

            // TODO: Add any drawing code here...

            EndPaint(hWnd, &ps);
            break;
        case WM_DESTROY:
            dhdClose ();        
            CommandBar_Destroy(g_hWndCommandBar);
            PostQuitMessage(0);
            break;


        default:
            return DefWindowProc(hWnd, message, wParam, lParam);
    }
    return 0;
}

// Message handler for about box.
INT_PTR CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch (message)
    {
        case WM_INITDIALOG:
            RECT rectChild, rectParent;
            int DlgWidth, DlgHeight;    // dialog width and height in pixel units
            int NewPosX, NewPosY;

            // trying to center the About dialog
            if (GetWindowRect(hDlg, &rectChild)) 
            {
                GetClientRect(GetParent(hDlg), &rectParent);
                DlgWidth    = rectChild.right - rectChild.left;
                DlgHeight   = rectChild.bottom - rectChild.top ;
                NewPosX     = (rectParent.right - rectParent.left - DlgWidth) / 2;
                NewPosY     = (rectParent.bottom - rectParent.top - DlgHeight) / 2;

                // if the About box is larger than the physical screen 
                if (NewPosX < 0) NewPosX = 0;
                if (NewPosY < 0) NewPosY = 0;
                SetWindowPos(hDlg, 0, NewPosX, NewPosY,
                    0, 0, SWP_NOZORDER | SWP_NOSIZE);
            }
            return (INT_PTR)TRUE;

        case WM_COMMAND:
            if ((LOWORD(wParam) == IDOK) || (LOWORD(wParam) == IDCANCEL))
            {
                EndDialog(hDlg, LOWORD(wParam));
                return TRUE;
            }
            break;

        case WM_CLOSE:
            EndDialog(hDlg, message);
            return TRUE;

    }
    return (INT_PTR)FALSE;
}

// Message handler for haptic box.
BOOL CALLBACK HapticBox(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{

    switch (message)
    {
        case WM_INITDIALOG:
            SetWindowPos(hDlg, 0, 130, 200,
                0, 0, SWP_NOZORDER | SWP_NOSIZE);
            hd.Done = 1;
            bRobotInMotion = false;
            bRobotConnectInit = false;
            g_hWndHapticBox = hDlg;
            hd.HapticScaleX = 100;
            hd.HapticScaleY = 100;
            hd.HapticScaleZ = 100;
            hd.MaxForcePos = 160;
            hd.MaxForceNeg = -160;
            hd.EnableForces = true;
            hd.ForceLimitPosX = false;
            hd.ForceLimitPosY = false;
            hd.ForceLimitPosZ = false;
            hd.ForceLimitNegX = false;
            hd.ForceLimitNegY = false;
            hd.ForceLimitNegZ = false;
            hd.filtered_x[0,1,2] = 0;       //low pass output for x
            hd.filtered_y[0,1,2] = 0;       //low pass output for y
            hd.filtered_z[0,1,2] = 0;       //low pass output for z
            hd.raw_x[0,1,2] = 0;            //raw haptic data for low pass x
            hd.raw_y[0,1,2] = 0;            //raw haptic data for low pass y
            hd.raw_z[0,1,2] = 0;            //raw haptic data for low pass z
            hc.Xmm = GetDlgItem(g_hWndHapticBox, IDC_STATIC_X);
            hc.Ymm = GetDlgItem(g_hWndHapticBox, IDC_STATIC_Y);
            hc.Zmm = GetDlgItem(g_hWndHapticBox, IDC_STATIC_Z);

            hc.XtoRobot = GetDlgItem(g_hWndHapticBox, IDC_STATIC_XtoRobot);
            hc.YtoRobot = GetDlgItem(g_hWndHapticBox, IDC_STATIC_YtoRobot);
            hc.ZtoRobot = GetDlgItem(g_hWndHapticBox, IDC_STATIC_ZtoRobot);

            hc.Fx = GetDlgItem(g_hWndHapticBox, IDC_STATIC_Fx);
            hc.Fy = GetDlgItem(g_hWndHapticBox, IDC_STATIC_Fy);
            hc.Fz = GetDlgItem(g_hWndHapticBox, IDC_STATIC_Fz);

            hc.rHz = GetDlgItem(g_hWndHapticBox, IDC_STATIC_Rate);

            hc.HapticStatus = GetDlgItem(g_hWndHapticBox, IDC_STATIC_HapticStatus);
            hc.RobotInMotion = GetDlgItem(g_hWndHapticBox, IDC_STATIC_RobotInMotion);
            hc.RobotStatus = GetDlgItem(g_hWndHapticBox, IDC_STATIC_RobotStatus);

///////////////////////////////////////////////////////////////////////////////////////
            hd.HapticConnected = false;
            if (hd.HapticConnected == false)
            {

                DWORD nThreadID;
                CreateThread(0, 0, DoConnectRobot, 0, 0, &nThreadID);
                Sleep(100);
                CreateThread(0, 0, DoGravity, 0, 0, &nThreadID);
                hd.HapticConnected = true;

            }

            return (INT_PTR)TRUE;

        case WM_CTLCOLORSTATIC:

            if(IDC_STATIC_HapticStatus == ::GetDlgCtrlID((HWND)lParam))
            {
                hdc = (HDC)wParam;
                if (hd.Done == 1)
                {
                    SetBkColor(hdc, RGB(255,0,0)); //red
                    return (BOOL)::CreateSolidBrush(RGB(255,0,0)); //red
                }
                else
                {
                    SetBkColor(hdc, RGB(0,255,0)); //green
                    return (BOOL)::CreateSolidBrush(RGB(0,255,0)); //green
                }
            }
            if(IDC_STATIC_RobotStatus == ::GetDlgCtrlID((HWND)lParam))
            {

                hdc = (HDC)wParam;
                if (bRobotConnectInit)
                {
                    SetBkColor(hdc, RGB(250, 255, 5)); //yellow
                    return (BOOL)::CreateSolidBrush(RGB(250, 255, 5));
                }
                else if (bRobotConnected)
                {
                    SetBkColor(hdc, RGB(0,255,0)); //green
                    return (BOOL)::CreateSolidBrush(RGB(0,255,0));
                }
                else
                {
                    SetBkColor(hdc, RGB(255,0,0)); //red
                    return (BOOL)::CreateSolidBrush(RGB(255,0,0));
                }
            }

            if(IDC_STATIC_RobotInMotion == ::GetDlgCtrlID((HWND)lParam))
            {

                hdc = (HDC)wParam;
                if (bRobotInMotion)
                {
                    SetBkColor(hdc, RGB(0,255,0)); //green
                    return (BOOL)::CreateSolidBrush(RGB(0,255,0));
                }
                else
                {
                    SetBkColor(hdc, RGB(255,0,0)); //red
                    return (BOOL)::CreateSolidBrush(RGB(255,0,0));
                }
            }

            break;

        case WM_CLOSE:
            hd.Done = 1;
            EndDialog(hDlg, message);
            return TRUE;

    }
    return (INT_PTR)FALSE;
}

有更多与解决方案相关的代码，如果需要，我可以附加。我的想法被认为只是打电话给这个WM_INITDIALOG案例，这样基本上它与关闭程序并重新打开它是一样的。任何建议都会被采纳。

4

2 回答 2

0

Callign WM_INITDIALOG 绝对不会像你想象的那样做。除非您完全理解它们，否则不要发送随机的 Windows 消息。

鉴于您的设计，我的建议是让您的程序启动另一个自身实例并退出旧实例。查看MSDN 上的CreateProcess以了解有关如何启动另一个进程的详细信息。考虑到您已经拥有的东西，我认为这将是最可维护且易于编码的解决方案。

于 2013-01-10T20:11:56.703 回答
0

我建议像这样反复调用 DialogBox：

do
{
  DialogBox(hInstance, (LPCTSTR)IDD_HAPTIC, NULL, HapticBox);

} while (ReOpenDialog);

ReOpenDialog您根据操作成功设置的全局在哪里（或者，为了避免全局，您可以使用 DialogBox 通过EndDialog的对话框返回结果）。

此外，您不需要消息循环，因为DialogBox调用内部有自己的，因此创建了一个阻塞调用（这就是我上面的循环实际上可以工作的原因！）。

于 2013-01-10T22:20:42.460 回答