KeyLinkerUsbDllLib使用说明

版本号：V1.7

1.文档说明

1.请配合支持UsbDll功能的手柄进行相应的数据读写操作

2.该文档为pc端的usbDll文件使用说明，使用者通过调用dll中的相关函数，还需要将得到的数据再与设备进行相应的读写交互操作。

3.主要用于对设备feature数据，摇杆数据，扳机数据，马达数据，改键数据，连击数据，灯光数据，宏数据等进行相应的数据转换。

4.必须先调用获取设备feature数据接口之后才能正确获取其他数据。

5.不包括固件升级相关功能。

2.结构体说明

2.1 DeviceDataStruct

// 定义设备数据结构体
typedef struct
{
    unsigned char *data; // 数据（类型为unsigned char数组）
    int length;          // 长度
 
} DeviceDataStruct;

2.2 DeviceFeatureStruct

// 定义设备Feature结构体
typedef struct
{
    int rockArray[3];      // 摇杆
    int triggerArray[3];   // 扳机
    int motorArray[5];     // 马达
    int lamplightArray[5]; // 灯光
    int macroArray[9];     // 宏
    int isHasChangeKey;    // 改键
    int isHasSensor;       // Sensor
    int isHasOta;          // Ota
    int isHasTurbo;        // Turbo
} DeviceFeatureStruct;

2.3 RockerTriggerDataStruct

// 定义摇杆扳机数据结构体
typedef struct
{
    int MidpointDeadZone; // 中点死区(扳机代表最小死区)
    int EdgeDeadZone;     // 边点死区(扳机代表最大死区)
    int X1;               // X1
    int Y1;               // Y1
    int X2;               // X2
    int Y2;               // Y2
    int XReverse;         // X轴反向
    int YReverse;         // Y轴反向
    int Exchange;         // 左右互换
 
} RockerTriggerDataStruct;

2.4 DeviceRockerTriggerStruct

// 定义设备摇杆扳机结构体
typedef struct
{
    RockerTriggerDataStruct left;  // 左摇杆(扳机代表左扳机)
    RockerTriggerDataStruct right; // 右摇杆(扳机代表右扳机)
 
} DeviceRockerTriggerStruct;

2.5 DeviceMotorStruct

// 定义设备马达结构体
typedef struct
{
    int motor1;                    // 马达1（震动强度值范围0-255）
    int motor2;                    // 马达2
    int motor3;                    // 马达3
    int motor4;                    // 马达4
    int autoShutdownTime;          // 无操作关机时间min（1-357913）
 
} DeviceMotorStruct;

2.6 LampLightStruct

// 定义灯光结构体
typedef struct
{
    int R;            // 颜色R值(0-255)
    int G;            // 颜色G值(0-255)
    int B;            // 颜色B值(0-255)
    int breathSpeed;  // 呼吸时间(0-2048)
    int breathSwitch; // 呼吸功能(1-打开 0-关闭)
    int brightness;   // 亮度(0-255)
 
} LampLightStruct;

2.7 DeviceLampLightStruct

// 定义设备灯光数据结构体
typedef struct
{
    LampLightStruct lampLightArray[4]; // 灯光数组
    int lampLightNumber;               // 灯光个数
 
} DeviceLampLightStruct;

2.8 DeviceSupportTurboStruct

// 定义设备支持turbo结构体
typedef struct
{
    unsigned char *turboList;   // 支持手动连击功能的按键key列表
    int turboListLength;        // 支持手动连击功能的按键key列表长度
    unsigned char *autoList;    // 支持自动连击功能的按键key列表
    int autoListLength;         // 支持自动连击功能的按键key列表长度
 
} DeviceSupportTurboStruct;

2.9 DeviceTurboDataStruct

// 定义设备turbo结构体
typedef struct
{
    unsigned char *turboStateList; // 支持手动连击功能的按键状态列表
    int turboStateListLength;      //长度
    unsigned char *autoStateList;  // 支持自动连击功能的按键状态列表
    int autoStateListLength;       //长度
    int turboSpeed;                // 连击速度ms
 
} DeviceTurboDataStruct;

2.10 MacroStepDataStruct

// 定义每一步的宏数据结构体
typedef struct 
{
    unsigned char *stepStateList; // 当前一步的按键状态列表，与读取到支持宏的按键列表一一对应，摇杆按键18和19有九个状态(0-松开 1-正上 2-右上 3-正右 4-右下 5-正下 6-左下 7-正左 8-左上) ，其他按键只有两个状态(1-按下，0-松开)
    int stepStateListLength;      // 长度
    int stepTime;                 // 当前一步的持续时间(20-60000)ms
 
} MacroStepDataStruct;

2.11 DeviceMacroDataStruct

// 定义设备宏结构体
typedef struct
{
    MacroStepDataStruct *macroData;  // 宏步数数据
    int macroIndex;                  // 当前宏的序号（0-7）
    int cycleTime;                   // 宏循环间隔时间200ms(5-20475)
    int burstMode;                   // 宏循环触发方式（1-自动 0-手动）
    int stepNumber;                  // 宏步数(对应macroData数组长度)
 
} DeviceMacroDataStruct;

3.设备数据说明

3.1 手柄按键编号

3.2 获取设备feature数据

// 获取设备feature数据
DeviceDataStruct readDeviceFeature();

通过调用readDeviceFeature()函数将得到的data数据与设备进行数据交互

3.3 解析设备feature数据

// 解析设备feature数据
// - Parameters:
//   - datas: 获取到的设备feature数组
//   - length: datas的长度
DeviceFeatureStruct receiveDeviceFeature(unsigned char datas[], int length);

// DeviceFeatureStruct示例说明
{
"lamplightArray": [1, 1, 1, 1, 1],
"rockArray": [1, 1, 1],
"macroArray": [1, 0, 0, 0, 0, 0, 0, 1, 0],
"triggerArray": [1, 1, 1],
"isHasOta": 1,
"isHasChangeKey": 1,
"isHasSensor": 0,
"motorArray": [1, 1, 1, 0, 0],
"isHasTurbo": 1
}
///参数说明
"所有状态都用0和1表示，0表示无，1表示有"
        + "isHasOta 表示有无ota升级"
        + "isHasChangeKey 表示有无改键功能"
        + "rockArray 数组中的元素分别表示为是否有摇杆、是否有右摇杆、是否有左摇杆"
        + "triggerArray 数组中的元素分别表示为是否有扳机、是否有右扳机、是否有左扳机"
        + "motorArray 数组中的元素分别表示为是否有马达、是否有左马达、是否有右马达、是否有左上马达、是否有右上马达"
        + "isHasTurbo 表示有无连击功能"
        + "macroArray 数组中的元素分别表示为是否有宏、是否有宏M1、是否有宏M2、是否有宏M3、是否有宏M4、是否有宏M5、是否有宏M6、是否有宏ML、是否有宏MR"
        + "lamplightArray 数组中的元素分别表示为是否有灯光、是否有灯光1、是否有灯光2、是否有灯光3、是否有灯光4"
        + "isHasSensor 表示有无体感功能"
 

通过获取到的设备feature数据进行相应的配置操作

3.4 获取心跳包

// 获取心跳包
DeviceDataStruct readDeviceHeartbeat();

通过调用readDeviceHeartbeat()函数将得到的data数据与设备进行数据交互

3.5 获取设备电量

// 获取设备电量
DeviceDataStruct readDeviceBattery();

通过调用readDeviceBattery()函数将得到的data数据与设备进行数据交互

3.6 解析设备电量

// 解析设备电量(返回参数电量值1、2、3、4是充电状态，电量依次递增，5、6、7、8是放电状态，电量依次递增)
//  - Parameters:
//  - datas: 获取到的设备电量数组
//  - length: datas的长度
unsigned char receiveDeviceBattery(unsigned char datas[], int length);

unsigned char deviceBattery = 1； //表示充电状态下的一格电

3.7 恢复出厂设置

// 恢复出厂设置
DeviceDataStruct writeDeviceResetFactory();

通过调用writeDeviceResetFactory()函数将得到的data数据与设备进行数据交互

3.8 获取sensor校准key

// 获取sensor校准key
DeviceDataStruct readDeviceSensorCalibrationKey();

通过调用readDeviceSensorCalibrationKey()函数将得到的data数据与设备进行数据交互

3.9 解析设备sensor校准key

// 解析设备sensor校准key
//  - Parameters:
//  - datas: 获取到的sensor校准key数组
//  - length: datas的长度
unsigned char receiveDeviceSensorCalibrationKey(unsigned char datas[], int length);

unsigned char key = 1； //表示按下A键校准完成

3.10 进入传感器校准

// 进入传感器校准
DeviceDataStruct enterDeviceSensorCalibration();

通过调用enterDeviceSensorCalibration()函数将得到的data数据与设备进行数据交互

3.11 返回设备按键操作

// 需要先获取设备feature数据,并且保持500ms发送一次心跳包的状态,设备才会发送相关的按键操作数据

// 返回设备按键操作
//  - Parameters:
//  - datas: 获取到的设备按键操作数组
//  - length: datas的长度
DeviceDataStruct receiveDeviceIssuedKey(unsigned char datas[], int length);

/// DeviceDataStruct结构体中data数据实例说明
 
//1.扳机按键(键码值key对应7，8) 4个元素为1组扳机数据
[state,key,value1,value2]  // state = 按键状态（1-按下，0-松开） key = 按键编码值 value1 = 扳机按键校准值  value2 = 扳机按键原始值 注:按键测试时采用校准值，扳机操作功能时采用原始值
[1,7,255,0]   //按下扳机键7，校准值为255，原始值为0
[0,7,255,0]   //松开扳机键7，校准值为255，原始值为0
[1,8,255,0]   //按下扳机键8，校准值为255，原始值为0
[0,8,255,0]   //按下扳机键8，校准值为255，原始值为0
 
//2.摇杆按键(键码值key对应18,19) 6个元素为1组摇杆数据
[state,key,x1,y1,x2,y2]   // state = 按键状态（1-按下，0-松开） key = 按键编码值 x1 = 摇杆按键校准值坐标x  y1 = 摇杆按键校准值坐标y  x2 = 摇杆按键原始值坐标x   y2 = 摇杆按键原始值坐标y 注:按键测试时采用校准值坐标，摇杆操作功能时采用原始值坐标
[0, 18, 128, 128, 129, 126]  //松开摇杆键18，校准值坐标为（128, 128）原始值坐标为（129, 126）
[1, 19, 156, 128, 150, 129]  //按下摇杆键19，校准值坐标为（156, 128）原始值坐标为（150, 129）
 
//3.基础键(除去扳机按键，摇杆按键之外的其他按键) 2个元素为1组基础数据
[state,key]  // state = 按键状态（1-按下，0-松开） key = 按键编码值
[1,13]       // 按下基础键13
[0,13]       // 松开基础键13
[1,1,1,4]    // 同时按下基础键1和4
[0,1,0,4]    // 同时松开基础键1和4
 
//4.同时触发的多组按键数据可以组合在一起,按照上述规则解析即可
[1,7,255,0,1,13,0, 18, 128, 128, 129, 126] //按下扳机键7,校准值为255，原始值为0 ,按下基础键13,松开摇杆按键18，校准值坐标为（128, 128）原始值坐标为（129, 126）
 
//5.摇杆坐标点说明
x值从左往右由0-255递增，128为x轴中心点位置
y值从下往上由0-255递增，128为y轴中心点位置
(128,128)为摇杆中心点坐标

3.12 进入测试模式

// 进入测试模式 effectType = 1 生效后 0 = 生效前
DeviceDataStruct enterDeviceTestlevelMode(int effectType);

通过调用enterDeviceTestlevelMode()函数将得到的data数据与设备进行数据交互
 
// 生效前(接收的按键操作数据不受改键，连击，宏功能的影响,例将X(key=3)键改为Y(key=4)键，按X键收到的数据为[1,3])
DeviceDataStruct dataStruct = enterDeviceTestlevelMode(0);
 
// 生效后(接收的按键操作数据受改键，连击，宏功能的影响，例将X(key=3)键改为Y(key=4)键，按X键收到的数据为[1,4])
DeviceDataStruct dataStruct = enterDeviceTestlevelMode(1);

3.13 退出测试模式

// 退出测试模式
DeviceDataStruct exitDeviceTestMode();

通过调用exitDeviceTestMode()函数将得到的data数据与设备进行数据交互

3.14 按键测试⽣效前

// 按键测试⽣效前
DeviceDataStruct keyTestBeforeEffect();

//需要先调用一次3.13退出测试模式接口
通过调用keyTestBeforeEffect()函数将得到的data数据与设备进行数据交互

3.15 按键测试⽣效后

// 按键测试⽣效后
DeviceDataStruct keyTestAfterEffect();

通过调用keyTestAfterEffect()函数将得到的data数据与设备进行数据交互

3.16 读取设备支持的所有按键数据

// 读取设备支持的所有按键数据(index 表示读取第几包数据，从0开始递增)
DeviceDataStruct readDeviceAllKeyList(int index);

通过调用readDeviceAllKeyList()函数将得到的data数据与设备进行数据交互

3.17 解析设备支持的所有按键数据

// 解析设备支持的所有按键数据
// - Parameters:
//   - datas: 获取到的设备支持的所有按键数据数组
//   - length: datas的长度
DeviceDataStruct receiveDeviceAllKeyList(unsigned char datas[], int length);

//返回数据说明(DeviceDataStruct结构体中data数组中的元素为对应的按键key，如1代表按键A)
unsigned char *data = {1,2,3,4,5,6,7,13,14,15,11,93};

3.18 解析总包数据长度

// 解析总包数据长度
// - Parameters:
//   - datas: 获取到index = 0时的数据数组
//   - length: datas的长度
//   - type: 数据类型 1-宏数据  0-其他数据
int receiveDataLength(unsigned char datas[], int length, int type);

//解析总包数据长度说明
如通过调用readDeviceAllKeyList(0)函数与设备进行数据交互,然后将收到的设备数据放入receiveDataLength()函数进行解析,如果总长度大于20则需要进行分包读取,一个包最多获取20个长度的数据,其他接口类似.

3.19 解析设备数据类型

// 解析设备数据类型(返回值为2时代表心跳包数据,为1时代表设备按键操作数据,为0时代表其他数据)
// - Parameters:
//   - datas: 获取到的数据数组
//   - length: datas的长度
int receiveDeviceDataType(unsigned char datas[], int length);

//解析设备数据类型
int type = receiveDeviceDataType();
 
type = 2时,代表心跳包数据,可以按需求调用3.6,3.9接口解析实时电量值和按键校准key值
type = 1时,代表设备按键操作数据,调用3.11接口解析
type = 0时.代表其他数据,调用相关接口解析即可,类型根据自身调用的相关接口自行确认

3.20 读写数据操作说明

// 关于读取说明
读取接口中带参数index的表示可能需要获取多个包数据,index表示读取第几包数据，从0开始递增，每次+1，通过3.18解析总包数据长度接口获取总包长度dataLength,以20位为间隔.如: 
 dataLength = 20,则获取一次包既可,index为0
 dataLength = 35,则需要获取2次包,index为0-1
 dataLength = 42,则需要获取3次包,index为0-2
 其他类似
 
// 关于解析说明
如果获取到的数据只有一个数据包则直接调用相应的解析函数解析，如果有多个数据包则需要将所有的数据包获取完之后按照顺序拼接为一个datas数组,再调用相应的解析函数解析。否则会出现解析数据与实际数据不符.
 
// 关于写入数据
根据调用写入接口之后返回的DeviceDataStruct数据中的length长度去写入,以20位为间隔.如: 
length = 20,则写入一次即可
dataLength = 35,则需要写入2次包,每次都需要重新组装数据
dataLength = 42,则需要写入3次包,每次都需要重新组装数据
其他类似

4.配置操作函数说明

4.1 获取设备摇杆数据

// 读取设备摇杆数据
DeviceDataStruct readRockerData();

通过调用readRockerData()函数将得到的data数据与设备进行数据交互

4.2 解析设备摇杆数据

// 解析设备摇杆数据
// - Parameters:
//   - datas: 获取到的设备摇杆数据数组
//   - length: datas的长度
DeviceRockerTriggerStruct receiveRockerData(unsigned char datas[], int length);

//DeviceRockerTriggerStruct示例说明
{
     "MidpointDeadZone": 30, //摇杆中点死区(0-100)
     "EdgeDeadZone": 20,     //摇杆边点死区(0-100)
     "X1": 90,               //摇杆X1(0-255)
     "Y1": 90,               //摇杆Y1(0-255)
     "X2": 120,              //摇杆X2(0-255)
     "Y2": 120,              //摇杆Y2(0-255)
     "XReverse": 1,          //摇杆X轴反向(1-反向 0-正常)
     "YReverse": 1,          //摇杆Y轴反向(1-反向 0-正常)
     "Exchange": 1,          //摇杆左右互换(1-互换 0-正常)
}

4.3 写入设备摇杆数据

// 写入摇杆数据
// - Parameters:
//   - data: DeviceRockerTriggerStruct结构体
DeviceDataStruct writeRockerData(DeviceRockerTriggerStruct data);

/// 死区值规则说明，中点死区值为MidpointDeadZone，边点死区值为EdgeDeadZone
1.死区范围值为0-100
2.MidpointDeadZone的范围应限制为0-60
3.EdgeDeadZone的范围应限制为0-60
4.MidpointDeadZone与EdgeDeadZone的关系为：
(100-EdgeDeadZone)-MidpointDeadZone>=30
 
/// 摇杆灵敏度曲线说明，对应坐标点(X1,Y1),(X2,Y2)
灵敏度规则说明,左右摇杆同理:
 0<=X1<=X2<=255
 0<=Y1<=Y2<=255

通过调用writeRockerData()函数将得到的data数据与设备进行数据交互

4.4 获取设备扳机数据

// 读取设备扳机数据
DeviceDataStruct readTriggerData();

通过调用readTriggerData()函数将得到的data数据与设备进行数据交互

4.5 解析设备扳机数据

// 解析设备扳机数据
// - Parameters:
//   - datas: 获取到的设备扳机数据数组
//   - length: datas的长度
DeviceRockerTriggerStruct receiveTriggerData(unsigned char datas[], int length);

//DeviceRockerTriggerStruct示例说明
{
     "MidpointDeadZone": 30, //扳机最小死区(0-200)
     "EdgeDeadZone": 20,     //扳机最大死区(0-200)
     "X1": 90,               //扳机X1(0-255)
     "Y1": 90,               //扳机Y1(0-255)
     "X2": 120,              //摇杆X2(0-255)
     "Y2": 120,              //摇杆Y2(0-255)
     "Exchange": 1,          //扳机左右互换(1-互换 0-正常)
}

4.6 写入设备扳机数据

// 写入扳机数据
// - Parameters:
//   - data: DeviceRockerTriggerStruct结构体
DeviceDataStruct writeTriggerData(DeviceRockerTriggerStruct data);

/// 死区值规则说明，最小死区值为MidpointDeadZone，最大死区值为EdgeDeadZone
1.死区范围值为0-200
2.MidpointDeadZone的范围应限制为0-120
3.EdgeDeadZone的范围应限制为0-120
4.MidpointDeadZone与EdgeDeadZone的关系为：
(200-EdgeDeadZone)-MidpointDeadZone>=60
 
/// 扳机灵敏度曲线说明，对应坐标点(X1,Y1),(X2,Y2)
灵敏度规则说明,左右扳机同理:
 0<=X1<=X2<=255
 0<=Y1<=Y2<=255

通过调用writeTriggerData()函数将得到的data数据与设备进行数据交互

4.7 获取设备马达数据(无操作关机时间共用此接口)

// 读取设备马达数据(无操作关机时间共用此接口)
DeviceDataStruct readDeviceMotorData();

通过调用readDeviceMotorData()函数将得到的data数据与设备进行数据交互

4.8 解析设备马达数据(无操作关机时间共用此接口)

// 解析设备马达数据
// - Parameters:
//   - datas: 获取到的设备马达数据数组
//   - length: datas的长度
DeviceMotorStruct receiveDeviceMotorData(unsigned char datas[], int length);

//DeviceMotorStruct示例说明
{
     "motor1": 128,             //马达1（震动强度值范围0-255）
     "motor2": 255,             //马达2
     "motor3": 0,               //马达3
     "motor4": 0,               //马达4
     "autoShutdownTime": 5,     //无操作关机时间min（1-357913）
}

4.9 写入设备马达数据(无操作关机时间共用此接口)

// 写入马达数据
// - Parameters:
//   - data: DeviceMotorStruct结构体
DeviceDataStruct writeDeviceMotorData(DeviceMotorStruct data);

通过调用writeDeviceMotorData()函数将得到的data数据与设备进行数据交互

4.10 获取改键之前的数据

//读取改键之前的数据(index 表示读取第几包数据，从0开始递增)
DeviceDataStruct readDeviceBeforeKeyChangeList(int index);

通过调用readDeviceBeforeKeyChangeList()函数将得到的data数据与设备进行数据交互

4.11 解析改键之前的数据

// 解析改键之前的数据
// - Parameters:
//   - datas: 获取到的设备改键之前的数据数组
//   - length: datas的长度
DeviceDataStruct receiveDeviceBeforeKeyChangeList(unsigned char datas[], int length);

//返回数据说明(DeviceDataStruct结构体中data数组中的元素为对应的按键key，如1代表按键A)
unsigned char *data = {1,2,3,4,5,6,7,8,13,14,15,11,93,94};

4.12 获取改键之后的数据

//读取改键之后的数据(index 表示读取第几包数据，从0开始递增)
DeviceDataStruct readDeviceAfterKeyChangeList(int index);

通过调用readDeviceAfterKeyChangeList()函数将得到的data数据与设备进行数据交互

4.13 解析改键之后的数据

// 解析改键之后的数据
// - Parameters:
//   - datas: 获取到的设备改键之后的数据数组
//   - length: datas的长度
DeviceDataStruct receiveDeviceAfterKeyChangeList(unsigned char datas[], int length);

//返回数据说明(DeviceDataStruct结构体中data，与4.11中data数组一一对应,0代表未修改，非本身key表示修改为其他按键key，本身key值表示为禁用当前按键「⚠️如果不支持禁用按键功能,写入改键数据时不要写入本身键值」)
unsigned char *data = {0,0,0,3,0,0,0,0,2,0,11,0};
// 如果返回的DeviceDataStruct结构体中的length
int length = 0,则表示当前所有的按键未修改,为出厂设置状态

4.14 写入改键之后的数据

// 写入改键之后的数据
// - Parameters:
//   - datas: 修改后的设备改键之后的数据数组
//   - length: datas的长度
DeviceDataStruct writeDeviceKeyChangeData(unsigned char datas[], int length);

//datas数据参考解析改键之后返回的数据,0代表未修改，非本身key表示修改为其他按键key，本身key值表示为禁用当前按键「⚠️如果不支持禁用按键功能,写入改键数据时不要写入本身键值」
通过调用writeDeviceKeyChangeData()函数将得到的data数据与设备进行数据交互

4.15 读取灯光数据

// 读取灯光数据(index 表示读取第几包数据，从0开始递增)
DeviceDataStruct readDeviceLamplightData(int index);

通过调用readDeviceLamplightData()函数将得到的data数据与设备进行数据交互

4.16 解析灯光数据

// 解析灯光数据
// - Parameters:
//   - datas: 获取到的设备灯光数据数组
//   - length: datas的长度
DeviceLampLightStruct receiveDeviceLamplightData(unsigned char datas[], int length);

// DeviceLampLightStruct类型参考2.7说明
// LampLightStruct示例说明
{
     "R": 128;                //颜色R值
     "G": 255;                //颜色G值
     "B": 0;                  //颜色B值
     "breathSpeed": 100;      //呼吸时间100ms
     "breathSwitch": 1;       //打开呼吸功能
     "brightness": 100;     //亮度为100
}

4.17 写入灯光数据

// 写入灯光数据
//   - Parameters:
//   - data: DeviceLampLightStruct结构体
DeviceDataStruct writeDeviceLamplightData(DeviceLampLightStruct data);

通过调用writeDeviceLamplightData()函数将得到的data数据与设备进行数据交互

4.18 读取支持turbo功能的按键数据

// 读取支持turbo功能的按键数据(index 表示读取第几包数据，从0开始递增)
DeviceDataStruct readDeviceSupportTurboList(int index);

通过调用readDeviceSupportTurboList()函数将得到的data数据与设备进行数据交互

4.19 解析支持turbo功能的按键数据

// 解析支持turbo功能的按键数据
// - Parameters:
//   - datas: 获取到的支持turbo功能的按键数据数组
//   - length: datas的长度
DeviceSupportTurboStruct receiveDeviceSupportTurboList(unsigned char datas[], int length);

// DeviceSupportTurboStruct示例说明
DeviceSupportTurboStruct turboStruct = receiveDeviceSupportTurboList(datas,length);
 
turboStruct.turboList = {1,2,3,4,5,6,7,8} // 支持手动连击的按键可能不支持自动连击
 
turboStruct.turboListLength = 8; 
 
turboStruct.autoList = {1,2,3,4,5,6,7,8}; // 支持自动连击的按键必定支持手动连击
 
turboStruct.autoListLength = 8;
 

4.20 读取turbo功能数据

// 读取turbo功能数据(index 表示读取第几包数据，从0开始递增)
DeviceDataStruct readDeviceTurboData(int index);

通过调用readDeviceTurboData()函数将得到的data数据与设备进行数据交互

4.21 解析turbo功能数据

// 解析turbo功能数据
// - Parameters:
//   - datas: 获取到的turbo功能数据数组
//   - length: datas的长度
DeviceTurboDataStruct receiveDeviceTurboData(unsigned char datas[], int length);

// DeviceTurboDataStruct示例说明
DeviceTurboDataStruct turboDataStruct = receiveDeviceTurboData(datas,length);
 
turboDataStruct.turboStateList = {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0} // 与读取到的turboList列表从首位开始一一对应，1-打开 0-关闭
 
turboDataStruct.turboStateListLength = 24; 
 
turboDataStruct.autoStateList = {0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; // 与读取到的autoList列表从首位开始一一对应，1-打开 0-关闭
 
turboDataStruct.autoStateListLength = 24;
 
turboDataStruct.turboSpeed = 200                //连击速度为200ms
 

//手动连接与自动连接说明
如将A键设置为手动连击,则需要长按A键触发连击功能,松开A键则失效
如将A键设置为自动连击,则短按A键一下就触发连击功能,再次短按A键一下则失效

4.22 写入turbo功能数据

// 写入turbo功能数据
// - Parameters:
//   - data: DeviceTurboDataStruct结构体
DeviceDataStruct writeDeviceTurboData(DeviceTurboDataStruct data);

注意:一个按键的手动连击状态与自动连击状态不能同时打开，即不能同为状态1

通过调用writeDeviceTurboData()函数将得到的data数据与设备进行数据交互

//写入数据说明(以实际数据为准)
turboStateList = {1,0,0,0,0,0,0,0}; //turboStateList数据与读取到的turboList列表一一对应
turboStateListLength = 8；
autoStateList = {0,1,0,0,0,0,0,0}; //autoStateList数据与读取到autoList列表一一对应
autoStateListLength = 8；
turboSpeed = 100；

/// 速度ms与频率hz对照表(写入的连击速度需在对照表之中)
    速度(ms)                               频率(hz)
    1000ms                                  1hz
    500ms                                   2hz
    330ms                                   3hz
    250ms                                   4hz
    200ms                                   5hz
    160ms                                   6hz
    140ms                                   7hz
    120ms                                   8hz
    110ms                                   9hz
    100ms                                   10hz
    90ms                                    11hz
    80ms                                    12hz
    70ms                                    14hz
    60ms                                    17hz
    50ms                                    20hz
    40ms                                    25hz
    30ms                                    33hz
 

4.23 读取支持宏功能的按键数据

// 读取支持宏功能的按键数据
// - Parameters:
//   - index 表示读取第几包数据，从0开始递增
DeviceDataStruct readDeviceSupportMacroList(int index);

通过调用readDeviceSupportMacroList()函数将得到的data数据与设备进行数据交互

4.24 解析支持宏功能的按键数据

// 解析支持宏功能的按键数据
// - Parameters:
//   - datas: 获取到的支持宏功能的按键数据数组]
//   - length: datas的长度
DeviceDataStruct receiveDeviceSupportMacroList(unsigned char datas[], int length);

//返回数据说明(DeviceDataStruct结构体中data数组中的元素为对应的按键key，如1代表按键A)
unsigned char *data = {1,2,3,4,5,6,7,13,14,15,11,93};

4.25 读取设备支持的宏步数列表数据

// 读取设备支持的宏步数列表数据(每个宏最多支持录制的步数)
// - Parameters:
//   - index 表示读取第几包数据，从0开始递增
DeviceDataStruct readDeviceSupportStepList(int index)

通过调用readDeviceSupportMacroList()函数将得到的data数据与设备进行数据交互

4.26 解析设备支持的宏步数列表数据

/// 解析设备支持的宏步数列表数据
// - Parameters:
//   - datas: 获取到的支持的宏步数列表数据数组
//   - length: datas的长度
DeviceDataStruct receiveDeviceSupportStepList(unsigned char datas[], int length);

/// 数据说明
DeviceDataStruct dataStruct = receiveDeviceSupportStepList();
unsigned char* stepList = dataStruct.data;
///stepList示例数据说明
stepList = [42,42,42,42,42,42,42,42] //表示宏M1-MR支持的最大录制步数为42步，42步，42步，42步，42步，42步，42步，42步

4.27 读取宏功能数据

// 特别注意⚠️
// 设备开关机之后去读取宏数据,需要先读取readDeviceSupportStepList接口一次，否则读写宏数据会出现错误

// 读取宏功能数据(macroNumber表示宏序号值为0-7，index 表示读取当前宏的第几包数据，从0开始递增)
DeviceDataStruct readDeviceMacroData(int macroNumber, int index);

通过调用readDeviceMacroData()函数将得到的data数据与设备进行数据交互

4.28 解析宏功能数据

// 解析宏功能数据
// - Parameters:
//   - datas: 获取到的宏功能数据数组
//   - length: datas的长度
//   - macroKeyList: 4.24解析支持宏功能的按键数据 获取到的DeviceDataStruct
DeviceMacroDataStruct receiveDeviceMacroData(unsigned char datas[], int length, DeviceDataStruct macroKeyList);

// DeviceMacroDataStruct示例说明
DeviceMacroDataStruct macroDataStruct = receiveDeviceMacroData(datas,length,macroKeyList);
//具体数据格式参考2.10,2.11结构体说明
{
     "macroData"  ///宏步数数据列表，有多少步返回多少步的数据 :
      [{
             "stepStateList": [1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0],      //当前一步的按键状态列表，与读取到支持宏的macroList列表一一对应，摇杆按键18和19有九个状态(0-松开 1-正上 2-右上 3-正右 4-右下 5-正下 6-左下 7-正左 8-左上) ，其他按键只有两个状态(1-按下，0-松开)
             "stepTime": 20,   //当前一步的持续时间20ms(20-60000)
             "stepStateListLength": 12
       }, 
       {
             "stepStateList": [0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
             "stepTime": 20,
             "stepStateListLength": 12
       }, 
       {
             "stepStateList": [0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
             "stepTime": 20,
             "stepStateListLength": 12
       }, 
       {
             "stepStateList": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
             "stepTime": 20,
             "stepStateListLength": 12
        }, 
        {
             "stepStateList": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
             "stepTime": 20,
             "stepStateListLength": 12
         }],
      "macroIndex": 6,      //当前宏的序号（0-7）
      "cycleTime": 200,     //宏循环间隔时间200ms(5-20475),设置为0时表示不循环
      "burstMode": 0,       //宏循环触发方式（0-按下宏键不松开触发宏循环）
      "stepNumber": 5       //宏步数为5步，对应macroData中的数组长度,为0时表示当前宏未设置
 }
 

4.29 写入宏功能数据

// 写入宏功能数据
// - Parameters:
//   - data: DeviceTurboDataStruct结构体
//   - macroKeyList: 4.24解析支持宏功能的按键数据 获取到的DeviceDataStruct
DeviceDataStruct writeDeviceMacroData(DeviceMacroDataStruct data, DeviceDataStruct macroKeyList);

通过调用writeDeviceMacroData()函数将得到的data数据与设备进行数据交互

写入的数据结构参考4.28解析宏功能数据结构
//
如需清空当前宏数据,将stepNumber字段设置为0即可

4.30 获取改键后支持修改的按键列表数据

//读取改键之前的数据(index 表示读取第几包数据，从0开始递增)
DeviceDataStruct readDeviceBeforeKeyChangeList(int index);

通过调用readDeviceBeforeKeyChangeList()函数将得到的data数据与设备进行数据交互

4.31 解析改键后支持修改的按键列表数据

// 解析改键之前的数据
// - Parameters:
//   - datas: 获取到的设备改键之前的数据数组
//   - length: datas的长度
DeviceDataStruct receiveDeviceBeforeKeyChangeList(unsigned char datas[], int length);

//返回数据说明(DeviceDataStruct结构体中data数组中的元素为对应的按键key，如1代表按键A)
unsigned char *data = {1,2,3,4,5,6,7,8,13,14,15,11,93,94};

5.示例说明

// PC_APP 与手柄 OUT、IN 数据格式(具体说明参考PC_APP协议)
OUT：80 F9 AA BB CC data[1]~data[n]
IN： 81 F9 AA BB CC data[1]~data[n]
//
1：AA 表示序号，每发一次自动加 1，以此循环，其中相关 OUT 的数据应答手柄 IN_81的 AA 值为 PC_APP OUT_80 的 AA 值；
2：BB（bit0）=0，表示 PC_APP 的 data[1]~data[n]从 dll 获取的数据下发给手柄，或者从手柄获取的 data[1]~data[n]调用 dll 接口进行数据处理
   BB(bit1~bit7)目前预留 0 
3：CC 表示 data[1]~data[n]的长度；
 
// PC_APP 获取手柄或者设置对应配置信息
PC_APP OUT：80 F9 AA 00 CC data[1]~data[n]
//
获取手柄对应配置信息 IN：81 F9 AA 00 CC data[1]~data[n]
应答对应 PC_APP OUT IN：81 F9 AA 01 02 31 AD
PC_APP 连发多包 OUT 数据结构时，收到对应应答包表示当前数据已被正确收到可以
发送下一包数据

读写数据之前请先仔细阅读3.18,3.19,3.20说明

5.1 单包数据读写示例说明

// 以设备摇杆数据为例,相关数据仅供参考
第一步: 先调用readRockerData()函数
DeviceDataStruct s = readRockerData();
s.data = {0x42,0x3b,0xc0,0xf4,0x11,0x06};
 
第二步: 将获取到的s.data数据组装之后发送给手柄
byte[] out_data = {0x80,0xf9,0x01,0x00,0x06,0x42,0x3b,0xc0,0xf4,0x11,0x06};
 
第三步: 接收到手柄返回的摇杆数据
byte[] in_data = {0x81,0xf9,0x01,0x00,0x14,0x6a,0x3b,0xf8,0x32,0xa1,0x42,0xd4,0x2c,0xf6,0x23,0xc8,0x7b,0x75,0x3f,0xe7,0x75,0xdc,0x64,0xf7,0x7c};
z
第四步: 调用receiveRockerData()函数解析设备摇杆数据
byte[] datas = {0x6a,0x3b,0xf8,0x32,0xa1,0x42,0xd4,0x2c,0xf6,0x23,0xc8,0x7b,0x75,0x3f,0xe7,0x75,0xdc,0x64,0xf7,0x7c};
int length = 20;
DeviceRockerTriggerStruct s = receiveRockerData(datas,length);

5.2 多包数据读写示例说明

// 以设备灯光数据为例,相关数据仅供参考
 
1. 先调用readDeviceLamplightData(int index)函数 //index从0开始
DeviceDataStruct s = readDeviceLamplightData(0)；
 
2. 将获取到的s.data数据组装之后发送给手柄
byte[] out_data = {0x80,0xf9,0x01,0x00,0x06,145,242,137,203,122,14};
 
3. 接收到手柄返回的第一包数据
byte[] in_data = {0x81,0xf9,0x01,0x00,0x14,0xf6,0x4d,0xfc,0xcc,0x15,0x89,0xcf,0x87,0x82,0x34,0xfb,0x88,0x7d,0x91,0x03,0x98,0xf9,0x0d,0x97,0x6b};
 
4. 解析数据总包长度(index=0时，具体参考3.18接口说明)
byte[] datas = {0xf6,0x4d,0xfc,0xcc,0x15,0x89,0xcf,0x87,0x82,0x34,0xfb,0x88,0x7d,0x91,0x03,0x98,0xf9,0x0d,0x97,0x6b};
int length = 20;
int dataTotalLength = receiveDataLength(datas,length,0) = 35;
 
由于dataTotalLength = 35，需要获取2次数据包，具体参考3.20说明
 
5. 再次调用readDeviceLamplightData(int index)函数 //index+1
DeviceDataStruct s = readDeviceLamplightData(1)；
 
6. 将获取到的s.data数据组装之后发送给手柄
byte[] out_data = {0x80,0xf9,0x01,0x00,0x06,129,242,137,203,12,14};
 
7. 接收到手柄返回的第二包数据
byte[] in_data = {0x81,0xf9,0x01,0x00,0x0f,0x26,0x4d,0xfc,0xcc,0x25,0x89,0xcf,0x87,0x82,0x34,0xfb,0x88,0x7d,0x91,0x03};
 
8. 将获取到的所有数据组装之后调用receiveDeviceLamplightData()函数进行解析
byte[] datas = {0xf6,0x4d,0xfc,0xcc,0x15,0x89,0xcf,0x87,0x82,0x34,0xfb,0x88,0x7d,0x91,0x03,0x98,0xf9,0x0d,0x97,0x6b，0x26,0x4d,0xfc,0xcc,0x25,0x89,0xcf,0x87,0x82,0x34,0xfb,0x88,0x7d,0x91,0x03};
int length = 35;
DeviceLampLightStruct s = receiveDeviceLamplightData(datas,length);

其他数据读写操作参考上述数据示例,示例数据仅供参考，具体数据已实际数据为准