mirror of
https://github.com/hyperion-project/hyperion.ng.git
synced 2023-10-10 13:36:59 +02:00
153 lines
3.6 KiB
C++
153 lines
3.6 KiB
C++
|
|
// STL includes
|
|
#include <cstring>
|
|
#include <iostream>
|
|
|
|
// Qt includes
|
|
#include <QTimer>
|
|
|
|
// Local Hyperion includes
|
|
#include "LedHIDDevice.h"
|
|
|
|
LedHIDDevice::LedHIDDevice(const unsigned short VendorId, const unsigned short ProductId, int delayAfterConnect_ms, const bool useFeature) :
|
|
_VendorId(VendorId),
|
|
_ProductId(ProductId),
|
|
_useFeature(useFeature),
|
|
_deviceHandle(nullptr),
|
|
_delayAfterConnect_ms(delayAfterConnect_ms),
|
|
_blockedForDelay(false)
|
|
{
|
|
// empty
|
|
}
|
|
|
|
LedHIDDevice::~LedHIDDevice()
|
|
{
|
|
if (_deviceHandle != nullptr)
|
|
{
|
|
hid_close(_deviceHandle);
|
|
_deviceHandle = nullptr;
|
|
}
|
|
|
|
hid_exit();
|
|
}
|
|
|
|
int LedHIDDevice::open()
|
|
{
|
|
// Initialize the usb context
|
|
int error = hid_init();
|
|
if (error != 0)
|
|
{
|
|
std::cerr << "Error while initializing the hidapi context" << std::endl;
|
|
return -1;
|
|
}
|
|
std::cout << "Hidapi initialized" << std::endl;
|
|
|
|
// Open the device
|
|
printf("Opening device: VID %04hx PID %04hx\n", _VendorId, _ProductId);
|
|
_deviceHandle = hid_open(_VendorId, _ProductId, nullptr);
|
|
|
|
if (_deviceHandle == nullptr)
|
|
{
|
|
// Failed to open the device
|
|
std::cerr << "Failed to open HID device. Maybe your PID/VID setting is wrong?" << std::endl;
|
|
|
|
// http://www.signal11.us/oss/hidapi/
|
|
/*
|
|
std::cout << "Showing a list of all available HID devices:" << std::endl;
|
|
auto devs = hid_enumerate(0x00, 0x00);
|
|
auto cur_dev = devs;
|
|
while (cur_dev) {
|
|
printf("Device Found\n type: %04hx %04hx\n path: %s\n serial_number: %ls",
|
|
cur_dev->vendor_id, cur_dev->product_id, cur_dev->path, cur_dev->serial_number);
|
|
printf("\n");
|
|
printf(" Manufacturer: %ls\n", cur_dev->manufacturer_string);
|
|
printf(" Product: %ls\n", cur_dev->product_string);
|
|
printf("\n");
|
|
cur_dev = cur_dev->next;
|
|
}
|
|
hid_free_enumeration(devs);
|
|
*/
|
|
|
|
return -1;
|
|
}
|
|
else{
|
|
std::cout << "Opened HID device successful" << std::endl;
|
|
}
|
|
|
|
// Wait after device got opened if enabled
|
|
if (_delayAfterConnect_ms > 0)
|
|
{
|
|
_blockedForDelay = true;
|
|
QTimer::singleShot(_delayAfterConnect_ms, this, SLOT(unblockAfterDelay()));
|
|
std::cout << "Device blocked for " << _delayAfterConnect_ms << " ms" << std::endl;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int LedHIDDevice::writeBytes(const unsigned size, const uint8_t * data)
|
|
{
|
|
if (_blockedForDelay) {
|
|
return 0;
|
|
}
|
|
|
|
if (_deviceHandle == nullptr)
|
|
{
|
|
// try to reopen
|
|
auto status = open();
|
|
if(status < 0){
|
|
// Try again in 3 seconds
|
|
int seconds = 3000;
|
|
_blockedForDelay = true;
|
|
QTimer::singleShot(seconds, this, SLOT(unblockAfterDelay()));
|
|
std::cout << "Device blocked for " << seconds << " ms" << std::endl;
|
|
}
|
|
// Return here, to not write led data if the device should be blocked after connect
|
|
return status;
|
|
}
|
|
|
|
// Prepend report ID to the buffer
|
|
uint8_t ledData[size + 1];
|
|
ledData[0] = 0; // Report ID
|
|
memcpy(ledData + 1, data, size_t(size));
|
|
|
|
// Send data via feature or out report
|
|
int ret;
|
|
if(_useFeature){
|
|
ret = hid_send_feature_report(_deviceHandle, ledData, size + 1);
|
|
}
|
|
else{
|
|
ret = hid_write(_deviceHandle, ledData, size + 1);
|
|
}
|
|
|
|
// Handle first error
|
|
if(ret < 0){
|
|
std::cerr << "Failed to write to HID device." << std::endl;
|
|
|
|
// Try again
|
|
if(_useFeature){
|
|
ret = hid_send_feature_report(_deviceHandle, ledData, size + 1);
|
|
}
|
|
else{
|
|
ret = hid_write(_deviceHandle, ledData, size + 1);
|
|
}
|
|
|
|
// Writing failed again, device might have disconnected
|
|
if(ret < 0){
|
|
std::cerr << "Failed to write to HID device." << std::endl;
|
|
|
|
hid_close(_deviceHandle);
|
|
_deviceHandle = nullptr;
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
void LedHIDDevice::unblockAfterDelay()
|
|
{
|
|
std::cout << "Device unblocked" << std::endl;
|
|
_blockedForDelay = false;
|
|
}
|