REALTOUCH_DECLSPEC int realtouch_open(struct realtouch* s, unsigned int device_index)
{
int count = 0;
struct hid_device_info* devices_new;
struct hid_device_info* device_cur;
if (!s->_is_inited)
{
return E_REALTOUCH_NOT_INITED;
}
devices_new = hid_enumerate(REALTOUCH_VID, REALTOUCH_PID);
device_cur = devices_new;
while(device_cur) {
if(count == device_index) {
s->_dev = hid_open_path(device_cur->path);
break;
}
++count;
device_cur = device_cur->next;
}
hid_free_enumeration(devices_new);
if(!s->_dev) {
return E_REALTOUCH_NOT_OPENED;
}
s->_is_open = 1;
return 0;
}
hid_device * hid_open(unsigned short vendor_id, unsigned short product_id, wchar_t *serial_number)
{
struct hid_device_info *devs, *cur_dev;
const char *path_to_open = NULL;
hid_device *handle = NULL;
devs = hid_enumerate(vendor_id, product_id);
cur_dev = devs;
while (cur_dev) {
if (cur_dev->vendor_id == vendor_id &&
cur_dev->product_id == product_id) {
if (serial_number) {
if (wcscmp(serial_number, cur_dev->serial_number) == 0) {
path_to_open = cur_dev->path;
break;
}
}
else {
path_to_open = cur_dev->path;
break;
}
}
cur_dev = cur_dev->next;
}
if (path_to_open) {
/* Open the device */
handle = hid_open_path(path_to_open);
}
hid_free_enumeration(devs);
return handle;
}
void open(unsigned int port)
{
const std::string devicePath = getDevicePath(port);
if (devicePath.empty())
{
throw IOException(Poco::format("Failed to open usb port (index: %u).\n"
"USB Interface not exist or already opened", port));
}
handle_ = hid_open_path(devicePath.c_str());
if (!handle_)
{
throw IOException(Poco::format("Failed to open usb port (index: %u).\n"
"USB Interface not exist or already opened", port));
}
port_ = port;
const UsbDeviceInfo& deviceInfo = getDeviceInfo(port);
vendorId_ = deviceInfo.getVendorId();
productId_ = deviceInfo.getProductId();
manufacturer_ = deviceInfo.getManufacturer();
product_ = deviceInfo.getProduct();
serialNumber_ = deviceInfo.getSerialNumber();
}
hid_device * HID_API_EXPORT hid_open(uint16_t vendor_id, uint16_t product_id)
{
/* This function is identical to the Linux version. Platform independent. */
struct hid_device_info *devs, *cur_dev;
const char *path_to_open = NULL;
hid_device * handle = NULL;
devs = hid_enumerate(vendor_id, product_id);
cur_dev = devs;
while (cur_dev)
{
if (cur_dev->vendor_id == vendor_id &&
cur_dev->product_id == product_id)
{
path_to_open = cur_dev->path;
break;
}
cur_dev = cur_dev->next;
}
if (path_to_open)
{
/* Open the device */
handle = hid_open_path(path_to_open);
}
hid_free_enumeration(devs);
return handle;
}
/**********************************************************
* Function set_relay_hidapi()
*
* Description: Set new relay state
*
* Parameters: portname (in) - communication port
* relay (in) - relay number
* relay_state (in) - current relay state
* serial (in) - serial number [not used]
*
* Return: o - success
* -1 - fail
*********************************************************/
int set_relay_hidapi(char* portname, uint8_t relay, relay_state_t relay_state, char* serial)
{
hid_device *hid_dev;
unsigned char buf[REPORT_LEN];
if (relay<FIRST_RELAY || relay>(FIRST_RELAY+g_num_relays-1))
{
fprintf(stderr, "ERROR: Relay number out of range\n");
return -1;
}
/* Open HID API device */
if ((hid_dev = hid_open_path(portname)) == NULL)
{
fprintf(stderr, "unable to open HID API device %s\n", portname);
return -2;
}
/* Write relay state by sending an output report to the device */
memset(buf, 0, sizeof(buf));
buf[REPORT_WRCMD_OFFSET] = (relay_state==ON) ? CMD_ON : CMD_OFF;
buf[REPORT_WRREL_OFFSET] = relay;
//printf("DBG: Write relay data %02X %02X\n", buf[REPORT_WRCMD_OFFSET], buf[REPORT_WRREL_OFFSET]);
if (hid_write(hid_dev, buf, sizeof(buf)) < 0)
{
fprintf(stderr, "unable to write output report to device %s (%ls)\n", portname, hid_error(hid_dev));
return -3;
}
hid_close(hid_dev);
return 0;
}
void vmarker::condisHandler(){
if(this->connected){
//CHECK IF DISCONNECTED
unsigned char *data;
if(hid_read_timeout(this->vmarkerdev,data,0,200)<0){
this->connected = false;
qDebug("Vmarker Disconnected");
emit(Disconnect());
hid_close(this->vmarkerdev);
}
}else{
//SEARCH FOR VMARKER
struct hid_device_info *devs,*cur_dev;
int i = 0;
for(i = 0; i<numPIDlist;i++){
devs = hid_enumerate(VID,PIDlist[i]);
cur_dev = devs;
while(cur_dev){
qDebug(cur_dev->path);
if(cur_dev->interface_number == MIlist[i]){
this->vmarkerdev = hid_open_path(cur_dev->path);
if(this->vmarkerdev){
this->productID = PIDlist[i];
this->connected = true;
qDebug("Vmarker Connected");
emit (Connected());
}
}
cur_dev = cur_dev->next;
}
hid_free_enumeration(devs);
}
}
}
/**********************************************************
* Function get_relay_hidapi()
*
* Description: Get the current relay state
*
* Parameters: portname (in) - communication port
* relay (in) - relay number
* relay_state (out) - current relay state
* serial (in) - serial number [not used]
*
* Return: 0 - success
* -1 - fail
*********************************************************/
int get_relay_hidapi(char* portname, uint8_t relay, relay_state_t* relay_state, char* serial)
{
hid_device *hid_dev;
unsigned char buf[REPORT_LEN];
if (relay<FIRST_RELAY || relay>(FIRST_RELAY+g_num_relays-1))
{
fprintf(stderr, "ERROR: Relay number out of range\n");
return -1;
}
/* Open HID API device */
if ((hid_dev = hid_open_path(portname)) == NULL)
{
fprintf(stderr, "unable to open HID API device %s\n", portname);
return -2;
}
/* Read relay states requesting a feature report with Id 0x01 */
buf[0] = 0x01;
if (hid_get_feature_report(hid_dev, buf, sizeof(buf)) != REPORT_LEN)
{
fprintf(stderr, "unable to read feature report from device %s (%ls)\n", portname, hid_error(hid_dev));
return -3;
}
//printf("DBG: Relay ID: %s\n", buf);
//printf("DBG: Read relay bits %02X\n", buf[REPORT_RDDAT_OFFSET]);
relay = relay-1;
*relay_state = (buf[REPORT_RDDAT_OFFSET] & (0x01<<relay)) ? ON : OFF;
hid_close(hid_dev);
return 0;
}
/*
PsychHIDGetDeviceRecordPtrFromIndex()
The inverse of PsychHIDGetIndexFromRecord()
Accept the index from the list of device records and return a pointer to the indicated record. Externally the list is one-indexed.
*/
pRecDevice PsychHIDGetDeviceRecordPtrFromIndex(int deviceIndex)
{
int i;
pRecDevice currentDevice=NULL;
PsychHIDVerifyInit();
i=1;
for(currentDevice=HIDGetFirstDevice(); currentDevice != NULL; currentDevice=HIDGetNextDevice(currentDevice)){
if(i==deviceIndex) {
#if PSYCH_SYSTEM != PSYCH_OSX
if (!currentDevice->interface) {
currentDevice->interface = (void*) hid_open_path(currentDevice->transport);
if (!currentDevice->interface) PsychErrorExitMsg(PsychError_system, "HIDLIB Failed to open USB device!");
// Set read ops on device to non-blocking:
hid_set_nonblocking((hid_device*) currentDevice->interface, 1);
}
#endif
return(currentDevice);
}
++i;
}
PsychErrorExitMsg(PsychError_user, "Invalid device index specified. Has a device been unplugged? Try rebuilding the device list");
return(NULL); //make the compiler happy.
}
int check_target_device(unsigned int vid, unsigned int pid)
{
assert((0xffff0000 & vid) == 0);
assert((0xffff0000 & pid) == 0);
dev = hid_enumerate((unsigned short)vid, (unsigned short)pid);
if (dev) {
target = hid_open_path(dev->path);
DBG_INFO("%s", dev->path);
if (target == NULL) {
perror("Error");
return -1;
}
printf("Device Info -\n");
printf("\tManufacturer: %ls\n", dev->manufacturer_string);
printf("\tProduct: %ls\n", dev->product_string);
printf("\tVendor ID: %x, Product ID: %x\n", dev->vendor_id, dev->product_id);
printf("\tSerial Number: %ls\n", dev->serial_number);
return 0;
}
return -1;
}
HID_API_EXPORT hid_device * HID_API_CALL hid_open(unsigned short vendor_id, unsigned short product_id, const wchar_t *serial_number)
{
/* TODO: Merge this functions with the Linux version. This function should be platform independent. */
struct hid_device_info *devs, *cur_dev;
const char *path_to_open = NULL;
hid_device *handle = NULL;
devs = hid_enumerate(vendor_id, product_id);
cur_dev = devs;
while (cur_dev) {
if (cur_dev->vendor_id == vendor_id &&
cur_dev->product_id == product_id) {
if (serial_number) {
if (wcscmp(serial_number, cur_dev->serial_number) == 0) {
path_to_open = cur_dev->path;
break;
}
}
else {
path_to_open = cur_dev->path;
break;
}
}
cur_dev = cur_dev->next;
}
if (path_to_open) {
/* Open the device */
handle = hid_open_path(path_to_open);
}
hid_free_enumeration(devs);
return handle;
}
JNIEXPORT jobject JNICALL Java_com_codeminders_hidapi_HIDDeviceInfo_open
(JNIEnv *env, jobject obj)
{
jclass thiscls = env->FindClass(DEVINFO_CLASS);
if (!thiscls)
return NULL;
jfieldID path_field_id = env->GetFieldID(thiscls, "path", "Ljava/lang/String;");
jstring jpathstr = (jstring) env->GetObjectField(obj, path_field_id);
const char *jpathbytes = env->GetStringUTFChars(jpathstr, NULL);
if(!jpathbytes)
return NULL;
hid_device *dev = hid_open_path(jpathbytes);
env->ReleaseStringUTFChars(jpathstr, jpathbytes);
if(!dev)
return NULL;
jlong peer = (jlong)dev;
// Construct and return object
jclass cls = env->FindClass(DEV_CLASS);
if (cls == NULL) {
return NULL; /* exception thrown */
}
jmethodID cid = env->GetMethodID(cls,
"<init>", "(J)V");
if (cid == NULL) {
return NULL; /* exception thrown */
}
return env->NewObject(cls, cid, peer);
}
void HidDevice::open()
{
devHandle = hid_open_path(devPath.c_str());
if(!devHandle)
{
throw HidDeviceError("Failed to open device");
}
}
int HidController::open() {
if (isOpen()) {
qDebug() << "HID device" << getName() << "already open";
return -1;
}
// Open device by path
if (debugging()) {
qDebug() << "Opening HID device"
<< getName() << "by HID path" << hid_path;
}
m_pHidDevice = hid_open_path(hid_path);
// If that fails, try to open device with vendor/product/serial #
if (m_pHidDevice == NULL) {
if (debugging())
qDebug() << "Failed. Trying to open with make, model & serial no:"
<< hid_vendor_id << hid_product_id << hid_serial;
m_pHidDevice = hid_open(hid_vendor_id, hid_product_id, hid_serial_raw);
}
// If it does fail, try without serial number WARNING: This will only open
// one of multiple identical devices
if (m_pHidDevice == NULL) {
qWarning() << "Unable to open specific HID device" << getName()
<< "Trying now with just make and model."
<< "(This may only open the first of multiple identical devices.)";
m_pHidDevice = hid_open(hid_vendor_id, hid_product_id, NULL);
}
// If that fails, we give up!
if (m_pHidDevice == NULL) {
qWarning() << "Unable to open HID device" << getName();
return -1;
}
setOpen(true);
startEngine();
if (m_pReader != NULL) {
qWarning() << "HidReader already present for" << getName();
} else {
m_pReader = new HidReader(m_pHidDevice);
m_pReader->setObjectName(QString("HidReader %1").arg(getName()));
connect(m_pReader, SIGNAL(incomingData(QByteArray)),
this, SLOT(receive(QByteArray)));
// Controller input needs to be prioritized since it can affect the
// audio directly, like when scratching
m_pReader->start(QThread::HighPriority);
}
return 0;
}
bool WiimoteHidapi::ConnectInternal()
{
if (m_handle != nullptr)
return true;
m_handle = hid_open_path(m_device_path.c_str());
if (m_handle == nullptr)
{
ERROR_LOG(WIIMOTE, "Could not connect to Wii Remote at \"%s\". "
"Do you have permission to access the device?",
m_device_path.c_str());
}
return m_handle != nullptr;
}
bool UsbHid::open(QString devicePath)
{
close();
bool res = false;
hid_device *h;
if ((h = hid_open_path(devicePath.toLatin1().data())) != 0)
{
hidDevice = h;
res = true;
}
return res;
}
int touchmouse_open(touchmouse_device **dev, touchmouse_device_info *dev_info)
{
touchmouse_device* t_dev = (touchmouse_device*)malloc(sizeof(touchmouse_device));
memset(t_dev, 0, sizeof(touchmouse_device));
char* path = ((struct hid_device_info**)dev_info->opaque)[0]->path;
t_dev->dev = hid_open_path(path);
if (!t_dev->dev) {
TM_ERROR("hid_open() failed for device with path %s\n", path);
free(t_dev);
return -1;
}
hid_set_nonblocking(t_dev->dev, 1); // Enable nonblocking reads
*dev = t_dev;
return 0;
}
void __fastcall TForm1::deviceConnect(TObject *Sender)
{
/* Метод поиска и подключения необходимого HID-устройства */
// Структура для поиска HID-устройств
struct hid_device_info *devs, *cur_dev;
// Установка отметки "Searching"
Button3->ImageIndex = 0;
// Вывод статуса
Label2->Text = "Поиск устройства...";
// Запуск поиска HID-устройства
devs = hid_enumerate(VID, PID);
// Помещение найденных устройств с указанными VID и PID в динамический массив
cur_dev = devs;
/* Поиск устройства по строке описания продукта 'Product Name' */
while (cur_dev) {
if ((cur_dev->product_string) == productString)
break;
cur_dev = cur_dev->next;
}
/* Если устройство найдено и успешно открыто... */
if (cur_dev && (handle_device = hid_open_path(cur_dev->path)))
{
// Остановка таймера, который вызывает данный метод
Timer1->Enabled = false;
// Установка отметки "Connected"
Button3->ImageIndex = 1;
// Вывод статуса
Label2->Text = "Устройство подключено";
}
else
{
// Установка отметки "Disconnected"
Button3->ImageIndex = 0;
//Button3->ImageIndex = 2;
// Вывод статуса
Label2->Text = "Поиск устройства...";
//Label2->Text = "Устройство не найдено";
}
// Удаление списка
hid_free_enumeration(devs);
}
void HIDDMXDevice::init()
{
/* Device name */
m_handle = hid_open_path(path().toUtf8().constData());
if (!m_handle)
{
QMessageBox::warning(NULL, (tr("HID DMX Interface Error")),
(tr("Unable to open %1. Make sure the udev rule is installed.").arg(name())),
QMessageBox::AcceptRole, QMessageBox::AcceptRole);
}
/** Reset channels when opening the interface: */
m_dmx_cmp.fill(0, 512);
m_dmx_in_cmp.fill(0, 512);
outputDMX(m_dmx_cmp, true);
}
int relay_get_state(const char * path) {
hid_device *dev;
unsigned char buf[RELAY_COMMAND_SIZE];
if((dev = hid_open_path(path)) == NULL) {
return -1;
}
buf[0] = 0x01; // get first page
if(hid_get_feature_report(dev, buf, sizeof(buf)) == -1) {
return -1;
}
/*
printf("buffer -> %d %d %d %d %d %d %d %d %d\n",
buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6], buf[7], buf[8]);
*/
return buf[7] & 1;
}
int USB_Open(int id)
{
// Open the device using the VID, PID,
// and optionally the Serial number.
struct hid_device_info *devs, *cur_dev;
devs = hid_enumerate(MY_VID, MY_PID);
cur_dev = devs;
int i = 0;
while (cur_dev) {
if (wcscmp(cur_dev->product_string, L"DDP442X") == 0)
{
if (i == id)
DeviceHandle = hid_open_path(cur_dev->path);
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(" Release: %hx\n", cur_dev->release_number);
printf(" Interface: %d\n", cur_dev->interface_number);
printf("\n");
i++;
}
cur_dev = cur_dev->next;
}
hid_free_enumeration(devs);
//DeviceHandle = hid_open(MY_VID, MY_PID, NULL);
if(DeviceHandle == NULL)
{
USBConnected = false;
return -1;
}
USBConnected = true;
return 0;
}
HID_API_EXPORT hid_device * HID_API_CALL hid_open(unsigned short vendor_id, unsigned short product_id, const wchar_t *serial_number)
{
// TODO: Merge this functions with the Linux version. This function should be platform independent.
struct hid_device_info *devs, *cur_dev;
const char *path_to_open = NULL;
hid_device *handle = NULL;
#ifdef STICK20_DEBUG
{ // For debugging
char text[1000];
sprintf(text,"hid_open: VID %04x PID %04x\n", vendor_id,product_id);
DebugAppendText (text);
}
#endif
devs = hid_enumerate(vendor_id, product_id);
cur_dev = devs;
while (cur_dev) {
if (cur_dev->vendor_id == vendor_id &&
cur_dev->product_id == product_id) {
if (serial_number) {
if (wcscmp(serial_number, cur_dev->serial_number) == 0) {
path_to_open = cur_dev->path;
break;
}
}
else {
path_to_open = cur_dev->path;
break;
}
}
cur_dev = cur_dev->next;
}
if (path_to_open) {
/* Open the device */
handle = hid_open_path(path_to_open);
}
hid_free_enumeration(devs);
return handle;
}
void init_pid(unsigned short vid, unsigned short pid) {
#ifdef OSX
hid_init();
dev = hid_open(vid, pid, NULL);
#else
struct hid_device_info *info = NULL, *ptr = NULL;
hid_init();
info = hid_enumerate(vid, pid);
ptr = info;
while (ptr != NULL) {
if (ptr->interface_number == 1) {
dev = hid_open_path(ptr->path);
break;
}
ptr = ptr->next;
}
hid_free_enumeration(info);
#endif
}
/**
* constructor
*/
boca_hid_printer_t *boca_hid_new(const char *device_path) {
boca_hid_printer_t *self = (boca_hid_printer_t *) calloc(1, sizeof(boca_hid_printer_t));
if (!self) return NULL;
self->device_path = strdup(device_path);
#ifdef __WIN32__
HANDLE handle;
handle = CreateFile(device_path,
0,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL);
if (handle != INVALID_HANDLE_VALUE) {
PHIDP_PREPARSED_DATA preparsed_data;
if (HidD_GetPreparsedData(handle, &preparsed_data)) {
HIDP_CAPS capabilities;
NTSTATUS ret = HidP_GetCaps(preparsed_data, &capabilities);
if (ret == HIDP_STATUS_SUCCESS) {
self->input_length = capabilities.InputReportByteLength;
self->output_length = capabilities.OutputReportByteLength;
self->feature_length = capabilities.FeatureReportByteLength;
zsys_info("hid printer: input length %d output length %d feature length %d", self->input_length,
self->output_length, self->feature_length);
} else {
zsys_warning("hid printer: can not get hid printer capabilities.");
}
} else {
zsys_warning("hid printer: can not get hid prepared data");
}
CloseHandle(handle);
} else {
zsys_warning("hid printer: can not open hid device code %d", GetLastError());
}
#endif
self->device = hid_open_path(self->device_path);
if (self->device == NULL) {
zsys_error("hid printer: could not create device from path %s", device_path);
boca_hid_destroy(&self);
return NULL;
}
return self;
}
int initializeDevice() {
struct hid_device_info *devs, *cur_dev;
const wchar_t targetManufacturer[] = L"Wincor Nixdorf";
hid_init();
/* Auto-detection du périphérique */
//Wincor Nixdorf
devs = hid_enumerate(0x0, 0x0);
cur_dev = devs;
while (cur_dev) {
if (DEBUG) fprintf(stdout, "<Debug> Périphérique trouvé: %04hx %04hx - %ls - %s\n", cur_dev->vendor_id, cur_dev->product_id, cur_dev->manufacturer_string ,cur_dev->path);
#if defined(__APPLE__)
if (!wcscmp(targetManufacturer, cur_dev->manufacturer_string) ) {
fprintf(stdout, "<Pilote> Afficheur USB %04hx %04hx en cours d\'ouverture sur %s..\n", cur_dev->vendor_id, cur_dev->product_id, cur_dev->path);
display = hid_open(cur_dev->vendor_id, cur_dev->product_id, NULL);
break;
}
#elif defined(linux)
if (!wcscmp(targetManufacturer, cur_dev->manufacturer_string) && !strcmp(cur_dev->path+(strlen(cur_dev->path)-2), "01")) {
fprintf(stdout, "<Pilote> Afficheur USB %04hx %04hx en cours d\'ouverture sur %s..\n", cur_dev->vendor_id, cur_dev->product_id, cur_dev->path);
display = hid_open_path(cur_dev->path);
break;
}
#else
fprintf(stderr, "<Fatal> Ce système n'est pas (encore) supporté pour l'instant!\n");
exit(-1);
#endif
cur_dev = cur_dev->next;
}
hid_free_enumeration(devs);
if (!display) return 0;
hid_get_product_string(display, moduleName, MAX_STR);
if (DEBUG) fprintf(stdout, "<Info> Connected to \"%ls\" display.\n", moduleName);
return display!=NULL;
}
int DAPLUGCALL Daplug_getDongleById(Dongle_info* di,DaplugDongle *dpd){
if(di->type == HID_DEVICE){
if((di->handle = (hid_device *)hid_open_path(di->path)) == NULL){
fprintf(stderr,"\ngetDongleById(): Cannot open hid dongle !\n");
return 0;
}
}
if(di->type == WINUSB_DEVICE){
if(initWinusbDevice(di->handle) == 0){
fprintf(stderr,"\ngetDongleById(): Cannot open winusb dongle !\n");
return 0;
}
}
initDongle(dpd);
dpd->di = (Dongle_info) *di;
return 1;
}
ambit_object_t * libambit_new(const ambit_device_info_t *device)
{
ambit_object_t *object = NULL;
const ambit_known_device_t *known_device = NULL;
const char *path = NULL;
if (!device || !device->path) {
LOG_ERROR("%s", strerror(EINVAL));
return NULL;
}
path = strdup (device->path);
if (!path) return NULL;
if (0 == device->access_status && device->is_supported) {
// Note, this should never fail if device was properly received with libambit_enumerate
known_device = libambit_device_support_find(device->vendor_id, device->product_id, device->model, device->fw_version);
if (known_device != NULL) {
object = calloc(1, sizeof(*object));
if (object) {
object->handle = hid_open_path(path);
memcpy(&object->device_info, device, sizeof(*device));
object->device_info.path = path;
object->driver = known_device->driver;
if (object->handle) {
hid_set_nonblocking(object->handle, true);
}
// Initialize driver
object->driver->init(object, known_device->driver_param);
}
}
}
if (!object) {
free((char *) path);
}
return object;
}
static bool IsDeviceUsable(const std::string& device_path)
{
hid_device* handle = hid_open_path(device_path.c_str());
if (handle == nullptr)
{
ERROR_LOG(WIIMOTE, "Could not connect to Wii Remote at \"%s\". "
"Do you have permission to access the device?",
device_path.c_str());
return false;
}
// Some third-party adapters (DolphinBar) always expose all four Wii Remotes as HIDs
// even when they are not connected, which causes an endless error loop when we try to use them.
// Try to write a report to the device to see if this Wii Remote is really usable.
static const u8 report[] = {WR_SET_REPORT | BT_OUTPUT, RT_REQUEST_STATUS, 0};
const int result = hid_write(handle, report, sizeof(report));
// The DolphinBar uses EPIPE to signal the absence of a Wii Remote connected to this HID.
if (result == -1 && errno != EPIPE)
ERROR_LOG(WIIMOTE, "Couldn't write to Wii Remote at \"%s\".", device_path.c_str());
hid_close(handle);
return result != -1;
}
LPCUSBSIO_API LPC_HANDLE I2C_Open(uint32_t index)
{
hid_device *pHid = NULL;
LPCUSBSIO_I2C_Ctrl_t *dev = NULL;
struct hid_device_info *cur_dev;
cur_dev = GetDevAtIndex(index);
if (cur_dev)
{
pHid = hid_open_path(cur_dev->path);
if (pHid)
{
dev = framework_AllocMem(sizeof(LPCUSBSIO_I2C_Ctrl_t));
memset(dev, 0, sizeof(LPCUSBSIO_I2C_Ctrl_t));
dev->hidDev = pHid;
dev->hidInfo = cur_dev;
dev->sesionId = rand();
map_create(&dev->request_map);
memcpy(&dev->fwVersion[0], g_fwInitVer, strlen(g_fwInitVer));
/* insert at top */
dev->next = g_Ctrl.devList;
g_Ctrl.devList = dev;
/* Set all calls to this hid device as blocking. */
// hid_set_nonblocking(dev->hidDev, 0);
framework_CreateMutex(&dev->SendLock);
framework_CreateMutex(&dev->RequestMapLock);
framework_CreateMutex(&dev->NotifierContainerLock);
dev->thread_exit = 0x00;
framework_CreateThread(&dev->ResponsethreadHandle , WaitRequestResponse, dev);
}
}
return (LPC_HANDLE) dev;
}
bool tempered_type_hid_open( tempered_device* device )
{
struct tempered_type_hid_device_data *device_data = malloc(
sizeof( struct tempered_type_hid_device_data )
);
if ( device_data == NULL )
{
tempered_set_error(
device, strdup( "Failed to allocate memory for the device data." )
);
return false;
}
device_data->group_data = NULL;
device_data->hid_dev = hid_open_path( device->path );
if ( device_data->hid_dev == NULL )
{
free( device_data );
tempered_set_error( device, strdup( "Failed to open HID device." ) );
return false;
}
device->data = device_data;
return true;
}
//-----------------------------------------------------------------------------
bool HIDDevice::openDevice(const char* device_path)
{
// First fill out the device descriptor
if (!HIDManager->GetDescriptorFromPath(device_path, &DevDesc))
{
return false;
}
DeviceHandle = hid_open_path(device_path);
if(!DeviceHandle)
{
LogError("Could not open %s error: %s", device_path, strerror(errno));
return false;
}
hid_set_nonblocking(DeviceHandle,0);
HIDManager->DevManager->pThread->AddSelectFd(this, -1); //set this up to be polled
return true;
}
