游戏手柄（JoyStick）编程学习笔记（2）

最新推荐文章于 2024-08-12 14:47:11 发布
最新推荐文章于 2024-08-12 14:47:11 发布
阅读量1.5k 收藏 3
点赞数
分类专栏： 游戏手柄开发 文章标签： C++
本文介绍了一种基于Qt的游戏手柄编程方法，通过编写监听线程实现对手柄按键、摇杆及视觉头盔状态变化的实时响应，并提供了详细的代码示例。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

游戏手柄（JoyStick）编程学习笔记（2）


分类：
作者同类文章 X

    版权声明：本文为博主原创文章，未经博主允许不得转载。

    在我的上一篇博客中（http://blog.youkuaiyun.com/liyuanbhu/article/details/51714045），介绍了通过 multimedia joystick API 来访问游戏手柄的基本方法。

    最后说到了利用 joySetCapture 函数监听手柄事件的方式并不是非常的好用。建议大家字节写个监听线程，有针对性的监听需要的事件。这里，我把我以前写的一份代码放上来。代码是基于 Qt 的，监听了按键、摇杆和视觉头盔的状态，在状态发生改变时发出Qt 的信号。

    按键对应两个信号：

    void Joy_ButtonPressed(int i);
void Joy_ButtonReleased(int i);
    
    • 1
    • 2

    摇杆分为两种模式：SWITCH_MODE 和 COORDINATE_MODE

    SWITCH_MODE 模式下，输出四个方向的开关量。对应的信号是：

        void Joy_MoveForward();
    void Joy_MoveBackward();
    void Joy_MoveForwardStop();
    void Joy_MoveBackwardStop();
    void Joy_MoveLeft();
    void Joy_MoveRight();
    void Joy_MoveLeftStop();
    void Joy_MoveRightStop();
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    COORDINATE_MODE 模式直接输出坐标值（只有在摇杆位置发生变化时才会有输出）。

    void Joy_Position(int x, int y);
    
    • 1

    视觉头盔模拟了摇杆的开关量模式。对应的信号同样是：

        void Joy_MoveForward();
    void Joy_MoveBackward();
    void Joy_MoveForwardStop();
    void Joy_MoveBackwardStop();
    void Joy_MoveLeft();
    void Joy_MoveRight();
    void Joy_MoveLeftStop();
    void Joy_MoveRightStop();
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    具体的代码不用过多介绍，主要就是几个状态机。下面贴出代码来。
    首先是头文件：

    #ifndef JOYSTICK_H
#define JOYSTICK_H

#include <QObject>
#include <QThread>
#include <Windows.h>
#include <Mmsystem.h>

class JoyStick;

/**
 * @brief The JoyStickThread class
 * @details 内部类，定时轮询 JoyStick 的状态。
 */
class JoyStickThread : public QThread
{
public:
    explicit JoyStickThread();
    void setJoyStick(JoyStick *joystick);
    void run();
    void stop();
private:
    void Coordinate_StateMachine(int xPos, int yPos);
    void AxisX_StateMachine(int xPos);
    void AxisY_StateMachine(int yPos);
    void Button_StateMachine(int button);
    void POV_StateMachine_Axis(int pov);
    void POV_StateMachine(int pov);
    int old_xPos;
    int old_yPos;
    int old_pov;
    bool pov_forward;
    bool pov_backward;
    bool pov_left;
    bool pov_right;
    bool pov_center;
    int m_button[16];
    JoyStick *m_joystick;
    bool m_run;
};

class JoyStick : public QObject
{
    Q_OBJECT
public:
    enum MODE{SWITCH_MODE, COORDINATE_MODE};
    /**
     * @brief JoyStick
     * @param mode SWITCH_MODE 模式时，摇杆输出开关量。COORDINATE_MODE 模式时，输出摇杆的位置。
     * @param parent
     */
    explicit JoyStick(enum MODE mode = SWITCH_MODE, QObject *parent = 0);

    enum MODE mode() const {return m_mode;}
    ~JoyStick();
    /**
     * @brief listen
     * @return 启动监听线程，之后就可以接收手柄的各种消息了。
     */
    bool listen();
    /**
     * @brief stop 停止监听线程，不需要接收手柄消息时可以调用这个函数。
     */
    void stop();
signals:
    /// JoyStick 的摇杆的各种信号。
    /// 高级些的手柄是可以返回摇杆的坐标值的。
    /// 这里模仿的是工业摇杆，输出的都是开关量。
    /// 前后左右四组开关量。
    void Joy_MoveForward();
    void Joy_MoveBackward();
    void Joy_MoveForwardStop();
    void Joy_MoveBackwardStop();
    void Joy_MoveLeft();
    void Joy_MoveRight();
    void Joy_MoveLeftStop();
    void Joy_MoveRightStop();

    /// JoyStick 的摇杆位置。
    void Joy_Position(int x, int y);
    /**
     * @brief Joy_ButtonPressed 当手柄上某个按键被按下时发出这个信号
     * @param i 用来标志是哪个按键被按下了。
     */
    void Joy_ButtonPressed(int i);
    /**
     * @brief Joy_ButtonReleased 当手柄上某个按键被释放时发出这个信号
     * @param i 用来标志是哪个按键被释放了。
     */
    void Joy_ButtonReleased(int i);

    /// 以下是视觉头盔的各种信号
    void Joy_POVForward();
    void Joy_POVBackward();
    void Joy_POVLeft();
    void Joy_POVRight();
    void Joy_POVForwardLeft();
    void Joy_POVForwardRight();
    void Joy_POVBackwardLeft();
    void Joy_POVBackwardRight();
    /**
     * @brief Joy_POVCentered 当视觉头盔从前8种状态恢复到默认状态时发出这个信号。
     */
    void Joy_POVCentered();

private:
    enum MODE m_mode;
    bool m_valid;
    JoyStickThread m_thread;
};

#endif // JOYSTICK_H

    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113

    下面是cpp 文件：

    #include "joystick.h"
#include <Windows.h>
#include <QDebug>

JoyStick::JoyStick(enum MODE mode, QObject *parent) : QObject(parent)
{
    m_mode = mode;
    m_valid = false;
    m_thread.setJoyStick(this);
    JOYINFO joyinfo;
    if( joyGetNumDevs() > 0 && joyGetPos(JOYSTICKID1, &joyinfo) != JOYERR_UNPLUGGED )
    {
        qDebug() << "JoyStick Init success!";
        m_valid = true;
    }
}

JoyStick::~JoyStick()
{
    m_thread.stop();
    m_thread.wait();
}

bool JoyStick::listen()
{
    m_thread.start();
    return true;
}
void JoyStick::stop()
{
    if(m_thread.isRunning())
    {
        m_thread.stop();
        m_thread.wait();
    }
}

JoyStickThread::JoyStickThread()
{
    m_run = 1;

    old_xPos = 32767;
    old_yPos = 32767;
    for(int i = 0; i < 16; i++)
    {
        m_button[i] = 0;
    }
    old_pov = JOY_POVCENTERED;
    pov_forward = false;
    pov_backward = false;
    pov_left = false;
    pov_right = false;
    pov_center = true;
}

void JoyStickThread::stop()
{
   m_run = 0;
}

void JoyStickThread::setJoyStick(JoyStick *joystick)
{
    m_joystick = joystick;
}

void JoyStickThread::run()
{
    //JOYINFO joyinfo;
    JOYINFOEX joyinfoex;
    joyinfoex.dwSize = sizeof(JOYINFOEX);
    joyinfoex.dwFlags = JOY_RETURNALL;
    while(m_run)
    {
//        if(joyGetPos(JOYSTICKID1, &joyinfo) == JOYERR_NOERROR)
//        {
//            //qDebug() << joyinfo.wXpos;
//            AxisX_StateMachine(joyinfo.wXpos);
//            AxisY_StateMachine(joyinfo.wYpos);
//            Button_StateMachine(joyinfo.wButtons);
//        }
        if(joyGetPosEx(JOYSTICKID1, &joyinfoex) == JOYERR_NOERROR)
        {
            if(m_joystick->mode() == JoyStick::SWITCH_MODE)
            {
                AxisX_StateMachine(joyinfoex.dwXpos);
                AxisY_StateMachine(joyinfoex.dwYpos);
            }
            else
            {
                Coordinate_StateMachine(joyinfoex.dwXpos, joyinfoex.dwYpos);
            }
            Button_StateMachine(joyinfoex.dwButtons);
            POV_StateMachine_Axis(joyinfoex.dwPOV);
        }
        msleep(50);
    }
}

void JoyStickThread::POV_StateMachine(int pov)
{
    if(pov != old_pov)
    {
        //qDebug() << pov;
        if( pov == JOY_POVFORWARD )
        {
            emit m_joystick->Joy_POVForward();
        }
        if( pov == JOY_POVFORWARD + 4500 )
        {
            emit m_joystick->Joy_POVForwardRight();
        }
        if( pov == JOY_POVRIGHT )
        {
            emit m_joystick->Joy_POVRight();
        }
        if( pov == JOY_POVRIGHT  + 4500 )
        {
            emit m_joystick->Joy_POVBackwardRight();
        }
        if( pov == JOY_POVBACKWARD )
        {
            emit m_joystick->Joy_POVBackward();
        }
        if( pov == JOY_POVBACKWARD + 4500 )
        {
            emit m_joystick->Joy_POVBackwardLeft();
        }
        if( pov == JOY_POVLEFT )
        {
            emit m_joystick->Joy_POVLeft();
        }
        if( pov == JOY_POVLEFT + 4500 )
        {
            emit m_joystick->Joy_POVForwardLeft();
        }
        if( pov == JOY_POVCENTERED )
        {
            emit m_joystick->Joy_POVCentered();
        }
        old_pov = pov;
    }
}

void JoyStickThread::POV_StateMachine_Axis(int pov)
{
    if(pov != old_pov)
    {
        //qDebug() << pov;
        if( pov == JOY_POVFORWARD )
        {
            if(pov_forward == false)
            {
                pov_forward = true;
                emit m_joystick->Joy_MoveForward();
                //qDebug() << "JOY_POVFORWARD";
            }
            if(pov_left == true)
            {
                emit m_joystick->Joy_MoveLeftStop();
                //qDebug() << "JOY_POVLEFT RETURN";
            }
            if(pov_right == true)
            {
                emit m_joystick->Joy_MoveRightStop();
                //qDebug() << "JOY_POVRIGHT RETURN";
            }
            pov_left = false;
            pov_right = false;
        }
        if( pov == JOY_POVFORWARD + 4500 )
        {
            if(pov_forward == false)
            {
                pov_forward = true;
                emit m_joystick->Joy_MoveForward();
                //qDebug() << "JOY_POVFORWARD";
            }
            if(pov_right == false)
            {
                pov_right = true;
                emit m_joystick->Joy_MoveRight();
                //qDebug() << "JOY_POVRIGHT";
            }
        }
        if( pov == JOY_POVRIGHT )
        {
            if(pov_right == false)
            {
                pov_right = true;
                emit m_joystick->Joy_MoveRight();
                //qDebug() << "JOY_POVRIGHT";
            }
            if(pov_forward == true)
            {
                emit m_joystick->Joy_MoveForwardStop();
                //qDebug() << "JOY_POVFORWARD RETURN";
            }
            if(pov_backward == true)
            {
                emit m_joystick->Joy_MoveBackwardStop();
                //qDebug() << "JOY_POVBACKWARD RETURN";
            }
            pov_forward = false;
            pov_backward = false;
        }
        if( pov == JOY_POVRIGHT  + 4500 )
        {
            if(pov_right == false)
            {
                pov_right = true;
                emit m_joystick->Joy_MoveRight();
               // qDebug() << "JOY_POVRIGHT";
            }
            if(pov_backward == false)
            {
                pov_backward = true;
                emit m_joystick->Joy_MoveBackward();
               // qDebug() << "JOY_POVBACKWARD";
            }
        }
        if( pov == JOY_POVBACKWARD )
        {
            if(pov_backward == false)
            {
                pov_backward = true;
                emit m_joystick->Joy_MoveBackward();
                //qDebug() << "JOY_POVBACKWARD";
            }
            if(pov_left == true)
            {
                emit m_joystick->Joy_MoveLeftStop();
                //qDebug() << "JOY_POVLEFT RETURN";
            }
            if(pov_right == true)
            {
                emit m_joystick->Joy_MoveRightStop();
                //qDebug() << "JOY_POVRIGHT RETURN";
            }
            pov_left = false;
            pov_right = false;
        }
        if( pov == JOY_POVBACKWARD + 4500 )
        {
            if(pov_backward == false)
            {
                pov_backward = true;
                emit m_joystick->Joy_MoveBackward();
                //qDebug() << "JOY_POVBACKWARD";
            }
            if(pov_left == false)
            {
                pov_left = true;
                emit m_joystick->Joy_MoveLeft();
               // qDebug() << "JOY_POVLEFT";
            }
        }
        if( pov == JOY_POVLEFT )
        {
            if(pov_left == false)
            {
                pov_left = true;
                emit m_joystick->Joy_MoveLeft();
                //qDebug() << "JOY_POVLEFT";
            }
            if(pov_forward == true)
            {
                emit m_joystick->Joy_MoveForwardStop();
                //qDebug() << "JOY_POVFORWARD RETURN";
            }
            if(pov_backward == true)
            {
                emit m_joystick->Joy_MoveBackwardStop();
                //qDebug() << "JOY_POVBACKWARD RETURN";
            }
            pov_backward = false;
            pov_forward = false;
        }
        if( pov == JOY_POVLEFT + 4500 )
        {
            if(pov_left == false)
            {
                pov_left = true;
                emit m_joystick->Joy_MoveLeft();
                //qDebug() << "JOY_POVLEFT";
            }
            if(pov_forward == false)
            {
                pov_forward = true;
                emit m_joystick->Joy_MoveForward();
                //qDebug() << "JOY_POVFORWARD";
            }
        }
        if( pov == JOY_POVCENTERED )
        {
            if(pov_forward == true)
            {
                emit m_joystick->Joy_MoveForwardStop();
                //qDebug() << "JOY_POVFORWARD RETURN";
            }
            if(pov_backward == true)
            {
                emit m_joystick->Joy_MoveBackwardStop();
                //qDebug() << "JOY_POVBACKWARD RETURN";
            }
            if(pov_left == true)
            {
                emit m_joystick->Joy_MoveLeftStop();
                //qDebug() << "JOY_POVLEFT RETURN";
            }
            if(pov_right == true)
            {
                emit m_joystick->Joy_MoveRightStop();
                //qDebug() << "JOY_POVRIGHT RETURN";
            }
            pov_forward = false;
            pov_right = false;
            pov_left = false;
            pov_backward = false;
            //qDebug() << "JOY_POVCENTERED";
        }
        old_pov = pov;
    }
}

void JoyStickThread::Button_StateMachine(int button)
{
    //if( button )
    //qDebug() << QString::number(button, 16);
    const int mask[16] = {1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768};
    for(int i = 0; i < 12; i++)
    {
        int n = button & mask[i];
        if(n ^ m_button[i])
        {
            m_button[i] = n;
            if( n )
            {
                emit m_joystick->Joy_ButtonPressed(i + 1);
                //qDebug() << "ButtonPressed(" << i + 1 << ")";
            }
            else
            {
                emit m_joystick->Joy_ButtonReleased(i + 1);
                //qDebug() << "ButtonReleased(" << i + 1 << ")";;
            }
        }
    }
}

void JoyStickThread::Coordinate_StateMachine(int xPos, int yPos)
{
    if(xPos == old_xPos && yPos == old_yPos)
    {
        return;
    }
    old_xPos = xPos;
    old_yPos = yPos;
    emit m_joystick->Joy_Position(xPos, yPos);
}

void JoyStickThread::AxisX_StateMachine(int xPos)
{
    if(xPos == old_xPos) return;
    switch(xPos)
    {
    case 0:
        emit m_joystick->Joy_MoveLeft();
        break;
    case 32767:
        if(old_xPos == 0)
        {
            emit m_joystick->Joy_MoveLeftStop();
        }
        else
        {
            emit m_joystick->Joy_MoveRightStop();
        }
        break;
    case 65535:
        emit m_joystick->Joy_MoveRight();
        break;
    }
    old_xPos = xPos;
}

void JoyStickThread::AxisY_StateMachine(int yPos)
{
    if(yPos == old_yPos) return;
    switch(yPos)
    {
    case 0:
        emit m_joystick->Joy_MoveForward();
        break;
    case 32767:
        if(old_xPos == 0)
        {
            emit m_joystick->Joy_MoveForwardStop();
        }
        else
        {
            emit m_joystick->Joy_MoveBackwardStop();
        }
        break;
    case 65535:
        emit m_joystick->Joy_MoveBackward();
        break;
    }
    old_yPos = yPos;
}
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134
    • 135
    • 136
    • 137
    • 138
    • 139
    • 140
    • 141
    • 142
    • 143
    • 144
    • 145
    • 146
    • 147
    • 148
    • 149
    • 150
    • 151
    • 152
    • 153
    • 154
    • 155
    • 156
    • 157
    • 158
    • 159
    • 160
    • 161
    • 162
    • 163
    • 164
    • 165
    • 166
    • 167
    • 168
    • 169
    • 170
    • 171
    • 172
    • 173
    • 174
    • 175
    • 176
    • 177
    • 178
    • 179
    • 180
    • 181
    • 182
    • 183
    • 184
    • 185
    • 186
    • 187
    • 188
    • 189
    • 190
    • 191
    • 192
    • 193
    • 194
    • 195
    • 196
    • 197
    • 198
    • 199
    • 200
    • 201
    • 202
    • 203
    • 204
    • 205
    • 206
    • 207
    • 208
    • 209
    • 210
    • 211
    • 212
    • 213
    • 214
    • 215
    • 216
    • 217
    • 218
    • 219
    • 220
    • 221
    • 222
    • 223
    • 224
    • 225
    • 226
    • 227
    • 228
    • 229
    • 230
    • 231
    • 232
    • 233
    • 234
    • 235
    • 236
    • 237
    • 238
    • 239
    • 240
    • 241
    • 242
    • 243
    • 244
    • 245
    • 246
    • 247
    • 248
    • 249
    • 250
    • 251
    • 252
    • 253
    • 254
    • 255
    • 256
    • 257
    • 258
    • 259
    • 260
    • 261
    • 262
    • 263
    • 264
    • 265
    • 266
    • 267
    • 268
    • 269
    • 270
    • 271
    • 272
    • 273
    • 274
    • 275
    • 276
    • 277
    • 278
    • 279
    • 280
    • 281
    • 282
    • 283
    • 284
    • 285
    • 286
    • 287
    • 288
    • 289
    • 290
    • 291
    • 292
    • 293
    • 294
    • 295
    • 296
    • 297
    • 298
    • 299
    • 300
    • 301
    • 302
    • 303
    • 304
    • 305
    • 306
    • 307
    • 308
    • 309
    • 310
    • 311
    • 312
    • 313
    • 314
    • 315
    • 316
    • 317
    • 318
    • 319
    • 320
    • 321
    • 322
    • 323
    • 324
    • 325
    • 326
    • 327
    • 328
    • 329
    • 330
    • 331
    • 332
    • 333
    • 334
    • 335
    • 336
    • 337
    • 338
    • 339
    • 340
    • 341
    • 342
    • 343
    • 344
    • 345
    • 346
    • 347
    • 348
    • 349
    • 350
    • 351
    • 352
    • 353
    • 354
    • 355
    • 356
    • 357
    • 358
    • 359
    • 360
    • 361
    • 362
    • 363
    • 364
    • 365
    • 366
    • 367
    • 368
    • 369
    • 370
    • 371
    • 372
    • 373
    • 374
    • 375
    • 376
    • 377
    • 378
    • 379
    • 380
    • 381
    • 382
    • 383
    • 384
    • 385
    • 386
    • 387
    • 388
    • 389
    • 390
    • 391
    • 392
    • 393
    • 394
    • 395
    • 396
    • 397
    • 398
    • 399
    • 400
    • 401
    • 402
    • 403
    • 404
    • 405
    • 406
    • 407
    • 408
    • 409

    具体的使用方法很简答，建立对象后，只要调用 listen() 函数开始监听就可以了。
    当然在监听之前，还要连接好需要的信号和槽。


      目标检测YOLO实战应用案例100讲-基于深度学习的无人机目标检测算法轻量化研究（下）
      qq_36130719的博客
      04-28 759
      本文结合ROS操作系统、软件仿真平台Gazebo、通信包MAVROS以及PX4来进 行无人机目标检测的仿真实验，如下图是PX4的软件在环(SITL)仿真的系统通信接口连接图如下图4-15所示：在仿真系统中，由Gazebo提供一个虚拟世界的仿真环境，并且提供无人机仿真模 型和虚拟的GPS、IMU等各种传感器的相关数据。
      VC++ MFC 游戏手柄Joystick 编程
      03-04
      一个简单的小例子，使用游戏手柄发出命令。用到winmm.lib和winmm.dll。包内里有
      游戏手柄（JoyStick）编程学习笔记（1）
      热门推荐
      Ivan 的专栏
      06-19 3万+
      游戏手柄（JoyStick）编程学习笔记（1）最近我开发的一个项目中需要用手柄控制一个二维移动平台的运动，找了些工业用的操作杆，感觉都挺丑的。后来想到打游戏时用的游戏手柄就挺漂亮，就决定试试用游戏手柄作为控制手柄来用。上网查了查，在 WINDOWS 下编程控制游戏手柄比较主流的技术是用 DirectInput。如果不需要复杂的控制功能，也可以直接使用 WIN API （multimedia joys
      游戏手柄joystick程序
      05-31
      基于MFC的游戏手柄开发程序，易操作，适用性强，可以直接使用，基于windows，directx 的开发平台
      树莓派小车深度学习自动驾驶实战教程
      此外，`joystick.py`和`car.py`文件分别用于实现手柄控制和小车控制功能，这使得可以通过手柄直接控制小车，同时收集小车的行驶数据。 #### 自动驾驶执行 训练好的模型将通过`python driver.py`命令来加载。在这个...
      Discord Quizbot：编程创建互动问答机器人
      - :joystick: - 游戏手柄，可能与游戏互动有关。 - :shooting_star: - 流星，可能表示某种快捷方式或速度。 - :left_speech_bubble: - 向左的对话泡泡，可能指与用户交互的方式。 - :reverse_button: - 反向播放按钮...
      ROS控制小车学习教程1
      rossuihan的博客
      06-08 2025
      4.安装依赖dependence（https:#f1tenth.readthedocs.io/en/foxy_test/going_forward/simulator/sim_install.html#dependencies）在文件夹tutorial_ws/src打开终端git clone https:#github.com/tianbot/tianbot_mini_description.git。rostopic pub -r 10 /turtle1/cmd_vel tab 发布内容。
      USB HID协议及参考代码
      05-24
      "21ic下载_STM32官方USB例程JoyStick详解.pdf"可能是基于STM32微控制器的USB HID游戏手柄实例教程。STM32是广泛应用的32位微控制器，支持USB通信。这份PDF可能详细讲解了如何配置STM32的USB控制器，实现HID设备功能...
      Qt实现的游戏手柄
      01-04
      QtGamepad游戏手柄‹ ，利用Qt qml实现的虚拟游戏手柄
      QT windows 游戏手柄例程
      01-11
      最近做个项目用到了QT开发游戏手柄，就参考新浪博客上一篇改了些，做出来了。 http://blog.sina.com.cn/s/blog_4567bb800100puqh.html 语言是C++，QT5.6.1版本，其他QT 5.XX版本也行。平台是windows7. 做个小界面，读取每个按键的动作并显示在界面上
      QT开发xbox游戏手柄实例
      08-14
      QT5.11.1+XBOX ONE，参考了QT自带的例子，有一个QGamemap类，直接使用就可以了
      基于QT开发的读取微软xbox手柄读写信息，并写入文件
      07-25
      通过qt软件读取微软手柄的按键消息，界面化显示，并写入文件txt，QT版本为QTcreator5.5，使用前请删除***.pro.user文件，写入的joy_keyinfo.txt文件位于编译生成的文件夹里面。该版本存在问题：手柄轴的零点漂移问题，不知道是实验室手柄问题还是代码问题，待解决。
      QtGamepad游戏手柄,手柄玩galgame,QT源码.zip.zip
      10-14
      QtGamepad游戏手柄,手柄玩galgame,QT源码.zip.zip
      QT的游戏手柄开发
      最新发布
      道亦无名
      08-12 1132
      在Qt中，游戏手柄的接入与交互主要通过Qt框架中的相关模块和类来实现，其中比较重要的是QGamepad类。Qt对游戏手柄的支持主要通过其输入处理模块中的QGamepad类实现。这个类使得开发者可以轻松地连接、配置和读取游戏手柄的输入信号，如按键、摇杆等。游戏手柄的接入步骤。
      游戏手柄（JoyStick）编程控制的一个简单代码（Qt）
      Ivan 的专栏
      03-25 2万+
      最近买到一种USB 接口的三轴 8 个按键的Joystick。下面这个样子。 用在最近做的一个工控项目上效果还不错。这里把代码公开了。 Joystick 的控制我以前写过两篇博客： http://blog.youkuaiyun.com/liyuanbhu/article/details/51714045 http://blog.youkuaiyun.com/liyuanbhu/article/details/5
      Qt之与游戏手柄的交互（一）
      画茧自缚
      09-29 1万+
      用途 通过手柄与Qt的通信，发送指令至远程设备，控制远程设备的运动。 手柄种类 市面上的游戏手柄也有多种种类，主流的是蓝牙手柄、2.4g手柄和usb手柄。无线手柄有的会识别出来是2.4g设备，有的识别出来是usb设备。 本文中的方法只支持Xbox手柄，使用其他手柄不会被Qt的手柄模块识别到，这里用的是淘宝销量第一的北通手柄，接收器接上电脑后会识别为Xbox360设备，如下图： 图片--------...
      Multimedia Joystick Functions
      02-01 1126
      游戏杆编程VC： 记下一个网址：http://msdn.microsoft.com/en-us/library/windows/desktop/dd743591(v=vs.85).aspx 游戏杆编程VB： http://www.ex-designz.net/apicat.asp?apicat=31 只能读取4个键，3轴 API Explanation  JOYINFO
      VC++使用MFC实现游戏手柄Joystick编程技巧
      本文将深入探讨在Windows平台下，如何使用VC++和MFC（Microsoft Foundation Classes）进行游戏手柄编程，特别是使用Joystick（游戏手柄）发出命令的技术细节。 ### 知识点概述 #### 1. MFC和VC++基础 MFC 是微软...
      评论
      添加红包

      请填写红包祝福语或标题

      个

      红包个数最小为10个

      元

      红包金额最低5元

      当前余额3.43元 前往充值 >
      需支付：10.00元
      成就一亿技术人!
      领取后你会自动成为博主和红包主的粉丝 规则
      hope_wisdom
      发出的红包
      实付元
      使用余额支付
      点击重新获取
      扫码支付
      钱包余额 0

      抵扣说明：

      1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
      2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

      余额充值