='0' and c<='9')
{
s2+=c;
}
}
s2=s2.left(10);
return s2.toDouble();
}
/** \brief Eanble/disable controls depending on FCD mode.
*
* This function reads the FCD mode and enables or disables the UI controls accordingly.
* In case a mode change is detected to FCD_MODE_APP, readDevice() is called to read the
* settings fromt he FCD.
* \todo Combo boxes.
*/
void MainWindow::enableControls()
{
FCD_MODE_ENUM fme = FCD_MODE_NONE;
char fwVerStr[6];
bool convOk = false;
float fwVer = 0.0;
fme = fcdGetMode();
switch (fme)
{
case FCD_MODE_APP:
fcdGetFwVerStr(fwVerStr);
fcdStatus->setText(tr("FCD is active (%1)").arg(QString(fwVerStr)));
/* convert version string to float */
fwVer = QString(fwVerStr).toFloat(&convOk);
break;
case FCD_MODE_BL:
fcdStatus->setText(tr("FCD bootloader"));
break;
case FCD_MODE_NONE:
fcdStatus->setText(tr("No FCD detected"));
break;
}
ui->freqCtrl->setEnabled(fme==FCD_MODE_APP);
/** Bias T functionality available since FW 18h for FCD Pro and 20.01 for Pro+ */
ui->biasTeeButton->setEnabled((fme == FCD_MODE_APP) && (fwVer > 18.07));
ui->lnaButton->setEnabled(fme == FCD_MODE_APP);
ui->mixerButton->setEnabled(fme == FCD_MODE_APP);
ui->ifGainSpinBox->setEnabled(fme == FCD_MODE_APP);
ui->spinBoxLnb->setEnabled(fme == FCD_MODE_APP);
ui->spinBoxCorr->setEnabled(fme == FCD_MODE_APP);
ui->actionDefault->setEnabled(fme==FCD_MODE_APP);
/* manage FCD mode transitions */
if (fme != prevMode) {
qDebug() << "FCD mode change:" << prevMode << "->" << fme;
ui->statusBar->showMessage(tr("FCD mode change detected"), 3000);
if (fme == FCD_MODE_APP) {
/* if previous mode was different read settings from device */
readDevice(DEV_SET_ALL);
/* Set frequency since FCD does not remember anything */
setNewFrequency(ui->freqCtrl->GetFrequency());
}
}
prevMode = fme;
}
/*! \brief Slot for receiving frequency change signals.
* \param[in] freq The new frequency.
*
* This slot is connected to the CFreqCtrl::NewFrequency() signal and is used
* to set new RF frequency.
*/
void MainWindow::setNewFrequency(qint64 freq)
{
FCD_MODE_ENUM fme;
unsigned int uFreq, rFreq;
double d = (double) (freq-lnbOffset);
d *= 1.0 + ui->spinBoxCorr->value()/1000000.0;
uFreq = (unsigned int) d;
fme = fcdAppSetFreq(uFreq, &rFreq);
qDebug() << "Set new frequency";
qDebug() << " Display:" << freq << "Hz";
qDebug() << " LNB offset:" << lnbOffset << "Hz";
qDebug() << " FCD set:" << uFreq << "Hz";
qDebug() << " FCD get:" << rFreq << "Hz";
if ((fme != FCD_MODE_APP) || (uFreq != rFreq))
{
ui->statusBar->showMessage(tr("Failed to set frequency"), 2000);
qDebug() << "Error in" << __func__ << "set:" << uFreq << "read:" << rFreq;
}
readDevice(DEV_SET_RFF);
}
/** \brief Bias T button ON/OFF
*
* This slot is called when the user licks on the Bias T button. It is used
* to switch the bias tee power ON and OFF.
* isChecked() = true => power ON
* isChecked() = false => power OFF
*/
void MainWindow::on_biasTeeButton_clicked()
{
char enabled = ui->biasTeeButton->isChecked();
FCD_MODE_ENUM fme = fcdAppSetBiasTee(enabled);
if (fme != FCD_MODE_APP)
{
qDebug() << __func__ << ": Failed to set bias T to" << enabled;
ui->statusBar->showMessage(tr("Failed to set bias T"), 5000);
}
}
/** \brief LNA button ON/OFF
*
* This slot is called when the user clicks on the LNA button. It is used
* to switch the LNA ON and OFF.
* isChecked() = true => power ON
* isChecked() = false => power OFF
*/
void MainWindow::on_lnaButton_clicked()
{
char enabled = ui->lnaButton->isChecked();
FCD_MODE_ENUM fme = fcdAppSetLna(enabled);
if (fme != FCD_MODE_APP)
{
qDebug() << __func__ << ": Failed to set LNA to" << enabled;
ui->statusBar->showMessage(tr("Failed to set LNA"), 5000);
}
}
/** \brief Mixer gain button ON/OFF
*
* This slot is called when the user clicks on the Mixer gain button. It is used
* to switch the mixer gain ON and OFF.
* isChecked() = true => power ON
* isChecked() = false => power OFF
*/
void MainWindow::on_mixerButton_clicked()
{
char enabled = ui->mixerButton->isChecked();
FCD_MODE_ENUM fme = fcdAppSetMixerGain(enabled);
if (fme != FCD_MODE_APP)
{
qDebug() << __func__ << ": Failed to set mixer gain to" << enabled;
ui->statusBar->showMessage(tr("Failed to set mixer gain"), 5000);
}
}
/** \brief IF gain changed
* \param gain The new IF gain between 0 and 59 dB.
*/
void MainWindow::on_ifGainSpinBox_valueChanged(int gain)
{
if ((gain <= 59) && (gain >= 0))
{
unsigned char gc = (unsigned char) gain;
FCD_MODE_ENUM fme = fcdAppSetIfGain(gc);
if (fme != FCD_MODE_APP)
{
qDebug() << __func__ << ": Failed to set IF gain to" << gc << "dB.";
ui->statusBar->showMessage(tr("Failed to set IF gain"), 5000);
}
}
}
/** \brief Frequency correction changed.
* \param n New correction value in ppm.
*
* This slot is called when the value of the frequency correction spin button
* is changed.
*/
void MainWindow::on_spinBoxCorr_valueChanged(int n)
{
FCD_MODE_ENUM fme;
unsigned int uFreq, rFreq;
double d = (double) (ui->freqCtrl->GetFrequency()-lnbOffset);
d *= 1.0 + n/1000000.0;
uFreq = (unsigned int) d;
fme = fcdAppSetFreq(uFreq, &rFreq);
if ((fme != FCD_MODE_APP) || (uFreq != rFreq))
{
ui->statusBar->showMessage(tr("Failed to set frequency"), 2000);
qDebug() << "Error in" << __func__ << "set:" << uFreq << "read:" << rFreq;
}
}
/** \brief LNB LO frequency changed.
* \param freq_mhz The new frequency in MHz.
*
* This slot is called when the user changes the LNB LO frequency. Only the
* display frequency is adjusted; the FCD frequency will stay unchanged.
*/
void MainWindow::on_spinBoxLnb_valueChanged(double freq_mhz)
{
/* calculate current RF frequency */
qint64 rf_freq = ui->freqCtrl->GetFrequency() - lnbOffset;
lnbOffset = qint64(freq_mhz*1e6);
qDebug() << "New LNB LO:" << lnbOffset << "Hz";
/* Show updated frequency in display */
ui->freqCtrl->SetFrequency(lnbOffset + rf_freq);
}
/** \brief Action: Load FCD settigns from file. */
void MainWindow::on_actionLoad_triggered()
{
qDebug() << "MainWindow::on_actionLoad_triggered() not implemented";
}
/** \brief Action: Save FCD settings to file. */
void MainWindow::on_actionSave_triggered()
{
qDebug() << "MainWindow::on_actionSave_triggered() not implemented";
}
/** \brief Action: Open firmware tools. */
void MainWindow::on_actionFirmware_triggered()
{
//fwDialog = new CFirmware(this);
//connect(fwDialog, SIGNAL(finished(int)), this, SLOT(fwDialogFinished(int)));
/* set FCD in bootloader mode */
timer->stop();
fcdAppReset();
timer->start(1000);
fwDialog->show();
}
/*! \brief Slot: Firmware dialog finished. */
void MainWindow::fwDialogFinished(int result)
{
Q_UNUSED(result);
qDebug() << "FIXME: Implement" << __func__;
#if 0
qDebug() << "FW dialog finished. Result:" << result;
//disconnect(fwDialog, SIGNAL(finished(int)), this, SLOT(fwDialogFinished(int)));
//delete fwDialog;
fwDialog->hide();
/* set FCD back to application mode */
timer->stop();
fcdBlReset();
timer->start(1000);
#endif
}
/*! \brief Action: Reset to defaulrts. */
void MainWindow::on_actionDefault_triggered()
{
QMessageBox::StandardButton but = QMessageBox::question(this,
tr("Reset FCD"),
tr("Reset FCD to default settings?"),
QMessageBox::Yes | QMessageBox::No,
QMessageBox::No);
if (but == QMessageBox::No)
return;
qDebug() << "FIXME: Implement" << __func__;
//readDevice();
//ui->statusBar->showMessage(tr("FCD has been reset"), 5000);
}
/** \brief Action: About Qthid
*
* This slot is called when the user activates the
* Help|About menu item (or Qthid|About on Mac)
*/
void MainWindow::on_actionAbout_triggered()
{
QMessageBox::about(this, tr("About Qthid"),
tr("This is qthid %1
"
"Qthid is a simple controller application for the Funcube Dongle Pro+"
"
"
"Qthid can be used to set and read the various such as frequency, bias T, "
"LNA, and whatever else is supported by the firmware.
"
"Qthid is written using the Qt toolkit (see About Qt) and is available "
"for Linux, Mac and Windows. You can download the latest version from the "
"Qthid website."
"
"
""
"Funcube Dongle website
"
"Information about Funcube"
"
").arg(VERSION));
}
/** \brief Action: About Qt
*
* This slot is called when the user activates the
* Help|About Qt menu item (or Qthid|About Qt on Mac)
*/
void MainWindow::on_actionAboutQt_triggered()
{
QMessageBox::aboutQt(this, tr("About Qt"));
}
qthid-4.1-source/hidraw.c 0000644 0001750 0001750 00000045534 12051012677 013503 0 ustar alc alc /*******************************************************
HIDAPI - Multi-Platform library for
communication with HID devices.
Alan Ott
Signal 11 Software
8/22/2009
Linux Version - 6/2/2009
Copyright 2009, All Rights Reserved.
At the discretion of the user of this library,
this software may be licensed under the terms of the
GNU Public License v3, a BSD-Style license, or the
original HIDAPI license as outlined in the LICENSE.txt,
LICENSE-gpl3.txt, LICENSE-bsd.txt, and LICENSE-orig.txt
files located at the root of the source distribution.
These files may also be found in the public source
code repository located at:
http://github.com/signal11/hidapi .
********************************************************/
/* C */
#include
#include
#include
#include
#include
/* Unix */
#include
#include
#include
#include
#include
#include
#include
/* Linux */
#include
#include
#include
#include
#include "hidapi.h"
/* Definitions from linux/hidraw.h. Since these are new, some distros
may not have header files which contain them. */
#ifndef HIDIOCSFEATURE
#define HIDIOCSFEATURE(len) _IOC(_IOC_WRITE|_IOC_READ, 'H', 0x06, len)
#endif
#ifndef HIDIOCGFEATURE
#define HIDIOCGFEATURE(len) _IOC(_IOC_WRITE|_IOC_READ, 'H', 0x07, len)
#endif
/* USB HID device property names */
const char *device_string_names[] = {
"manufacturer",
"product",
"serial",
};
/* Symbolic names for the properties above */
enum device_string_id {
DEVICE_STRING_MANUFACTURER,
DEVICE_STRING_PRODUCT,
DEVICE_STRING_SERIAL,
DEVICE_STRING_COUNT,
};
struct hid_device_ {
int device_handle;
int blocking;
int uses_numbered_reports;
};
static __u32 kernel_version = 0;
static hid_device *new_hid_device(void)
{
hid_device *dev = calloc(1, sizeof(hid_device));
dev->device_handle = -1;
dev->blocking = 1;
dev->uses_numbered_reports = 0;
return dev;
}
/* The caller must free the returned string with free(). */
static wchar_t *utf8_to_wchar_t(const char *utf8)
{
wchar_t *ret = NULL;
if (utf8) {
size_t wlen = mbstowcs(NULL, utf8, 0);
if ((size_t) -1 == wlen) {
return wcsdup(L"");
}
ret = calloc(wlen+1, sizeof(wchar_t));
mbstowcs(ret, utf8, wlen+1);
ret[wlen] = 0x0000;
}
return ret;
}
/* Get an attribute value from a udev_device and return it as a whar_t
string. The returned string must be freed with free() when done.*/
static wchar_t *copy_udev_string(struct udev_device *dev, const char *udev_name)
{
return utf8_to_wchar_t(udev_device_get_sysattr_value(dev, udev_name));
}
/* uses_numbered_reports() returns 1 if report_descriptor describes a device
which contains numbered reports. */
static int uses_numbered_reports(__u8 *report_descriptor, __u32 size) {
int i = 0;
int size_code;
int data_len, key_size;
while (i < size) {
int key = report_descriptor[i];
/* Check for the Report ID key */
if (key == 0x85/*Report ID*/) {
/* This device has a Report ID, which means it uses
numbered reports. */
return 1;
}
//printf("key: %02hhx\n", key);
if ((key & 0xf0) == 0xf0) {
/* This is a Long Item. The next byte contains the
length of the data section (value) for this key.
See the HID specification, version 1.11, section
6.2.2.3, titled "Long Items." */
if (i+1 < size)
data_len = report_descriptor[i+1];
else
data_len = 0; /* malformed report */
key_size = 3;
}
else {
/* This is a Short Item. The bottom two bits of the
key contain the size code for the data section
(value) for this key. Refer to the HID
specification, version 1.11, section 6.2.2.2,
titled "Short Items." */
size_code = key & 0x3;
switch (size_code) {
case 0:
case 1:
case 2:
data_len = size_code;
break;
case 3:
data_len = 4;
break;
default:
/* Can't ever happen since size_code is & 0x3 */
data_len = 0;
break;
};
key_size = 1;
}
/* Skip over this key and it's associated data */
i += data_len + key_size;
}
/* Didn't find a Report ID key. Device doesn't use numbered reports. */
return 0;
}
/*
* The caller is responsible for free()ing the (newly-allocated) character
* strings pointed to by serial_number_utf8 and product_name_utf8 after use.
*/
static int
parse_uevent_info(const char *uevent, int *bus_type,
unsigned short *vendor_id, unsigned short *product_id,
char **serial_number_utf8, char **product_name_utf8)
{
char *tmp = strdup(uevent);
char *saveptr = NULL;
char *line;
char *key;
char *value;
int found_id = 0;
int found_serial = 0;
int found_name = 0;
line = strtok_r(tmp, "\n", &saveptr);
while (line != NULL) {
/* line: "KEY=value" */
key = line;
value = strchr(line, '=');
if (!value) {
goto next_line;
}
*value = '\0';
value++;
if (strcmp(key, "HID_ID") == 0) {
/**
* type vendor product
* HID_ID=0003:000005AC:00008242
**/
int ret = sscanf(value, "%x:%hx:%hx", bus_type, vendor_id, product_id);
if (ret == 3) {
found_id = 1;
}
} else if (strcmp(key, "HID_NAME") == 0) {
/* The caller has to free the product name */
*product_name_utf8 = strdup(value);
found_name = 1;
} else if (strcmp(key, "HID_UNIQ") == 0) {
/* The caller has to free the serial number */
*serial_number_utf8 = strdup(value);
found_serial = 1;
}
next_line:
line = strtok_r(NULL, "\n", &saveptr);
}
free(tmp);
return (found_id && found_name && found_serial);
}
static int get_device_string(hid_device *dev, enum device_string_id key, wchar_t *string, size_t maxlen)
{
struct udev *udev;
struct udev_device *udev_dev, *parent, *hid_dev;
struct stat s;
int ret = -1;
/* Create the udev object */
udev = udev_new();
if (!udev) {
printf("Can't create udev\n");
return -1;
}
/* Get the dev_t (major/minor numbers) from the file handle. */
fstat(dev->device_handle, &s);
/* Open a udev device from the dev_t. 'c' means character device. */
udev_dev = udev_device_new_from_devnum(udev, 'c', s.st_rdev);
if (udev_dev) {
hid_dev = udev_device_get_parent_with_subsystem_devtype(
udev_dev,
"hid",
NULL);
if (hid_dev) {
unsigned short dev_vid;
unsigned short dev_pid;
char *serial_number_utf8 = NULL;
char *product_name_utf8 = NULL;
int bus_type;
size_t retm;
ret = parse_uevent_info(
udev_device_get_sysattr_value(hid_dev, "uevent"),
&bus_type,
&dev_vid,
&dev_pid,
&serial_number_utf8,
&product_name_utf8);
if (bus_type == BUS_BLUETOOTH) {
switch (key) {
case DEVICE_STRING_MANUFACTURER:
wcsncpy(string, L"", maxlen);
ret = 0;
break;
case DEVICE_STRING_PRODUCT:
retm = mbstowcs(string, product_name_utf8, maxlen);
ret = (retm == (size_t)-1)? -1: 0;
break;
case DEVICE_STRING_SERIAL:
retm = mbstowcs(string, serial_number_utf8, maxlen);
ret = (retm == (size_t)-1)? -1: 0;
break;
case DEVICE_STRING_COUNT:
default:
ret = -1;
break;
}
}
else {
/* This is a USB device. Find its parent USB Device node. */
parent = udev_device_get_parent_with_subsystem_devtype(
udev_dev,
"usb",
"usb_device");
if (parent) {
const char *str;
const char *key_str = NULL;
if (key >= 0 && key < DEVICE_STRING_COUNT) {
key_str = device_string_names[key];
} else {
ret = -1;
goto end;
}
str = udev_device_get_sysattr_value(parent, key_str);
if (str) {
/* Convert the string from UTF-8 to wchar_t */
retm = mbstowcs(string, str, maxlen);
ret = (retm == (size_t)-1)? -1: 0;
goto end;
}
}
}
free(serial_number_utf8);
free(product_name_utf8);
}
}
end:
udev_device_unref(udev_dev);
// parent and hid_dev don't need to be (and can't be) unref'd.
// I'm not sure why, but they'll throw double-free() errors.
udev_unref(udev);
return ret;
}
int HID_API_EXPORT hid_init(void)
{
const char *locale;
/* Set the locale if it's not set. */
locale = setlocale(LC_CTYPE, NULL);
if (!locale)
setlocale(LC_CTYPE, "");
return 0;
}
int HID_API_EXPORT hid_exit(void)
{
/* Nothing to do for this in the Linux/hidraw implementation. */
return 0;
}
struct hid_device_info HID_API_EXPORT *hid_enumerate(unsigned short vendor_id, unsigned short product_id)
{
struct udev *udev;
struct udev_enumerate *enumerate;
struct udev_list_entry *devices, *dev_list_entry;
struct hid_device_info *root = NULL; // return object
struct hid_device_info *cur_dev = NULL;
struct hid_device_info *prev_dev = NULL; // previous device
hid_init();
/* Create the udev object */
udev = udev_new();
if (!udev) {
printf("Can't create udev\n");
return NULL;
}
/* Create a list of the devices in the 'hidraw' subsystem. */
enumerate = udev_enumerate_new(udev);
udev_enumerate_add_match_subsystem(enumerate, "hidraw");
udev_enumerate_scan_devices(enumerate);
devices = udev_enumerate_get_list_entry(enumerate);
/* For each item, see if it matches the vid/pid, and if so
create a udev_device record for it */
udev_list_entry_foreach(dev_list_entry, devices) {
const char *sysfs_path;
const char *dev_path;
const char *str;
struct udev_device *raw_dev; // The device's hidraw udev node.
struct udev_device *hid_dev; // The device's HID udev node.
struct udev_device *usb_dev; // The device's USB udev node.
struct udev_device *intf_dev; // The device's interface (in the USB sense).
unsigned short dev_vid;
unsigned short dev_pid;
char *serial_number_utf8 = NULL;
char *product_name_utf8 = NULL;
int bus_type;
int result;
/* Get the filename of the /sys entry for the device
and create a udev_device object (dev) representing it */
sysfs_path = udev_list_entry_get_name(dev_list_entry);
raw_dev = udev_device_new_from_syspath(udev, sysfs_path);
dev_path = udev_device_get_devnode(raw_dev);
hid_dev = udev_device_get_parent_with_subsystem_devtype(
raw_dev,
"hid",
NULL);
if (!hid_dev) {
/* Unable to find parent hid device. */
goto next;
}
result = parse_uevent_info(
udev_device_get_sysattr_value(hid_dev, "uevent"),
&bus_type,
&dev_vid,
&dev_pid,
&serial_number_utf8,
&product_name_utf8);
if (!result) {
/* parse_uevent_info() failed for at least one field. */
goto next;
}
if (bus_type != BUS_USB && bus_type != BUS_BLUETOOTH) {
/* We only know how to handle USB and BT devices. */
goto next;
}
/* Check the VID/PID against the arguments */
if ((vendor_id == 0x0 && product_id == 0x0) ||
(vendor_id == dev_vid && product_id == dev_pid)) {
struct hid_device_info *tmp;
/* VID/PID match. Create the record. */
tmp = malloc(sizeof(struct hid_device_info));
if (cur_dev) {
cur_dev->next = tmp;
}
else {
root = tmp;
}
prev_dev = cur_dev;
cur_dev = tmp;
/* Fill out the record */
cur_dev->next = NULL;
cur_dev->path = dev_path? strdup(dev_path): NULL;
/* VID/PID */
cur_dev->vendor_id = dev_vid;
cur_dev->product_id = dev_pid;
/* Serial Number */
cur_dev->serial_number = utf8_to_wchar_t(serial_number_utf8);
/* Release Number */
cur_dev->release_number = 0x0;
/* Interface Number */
cur_dev->interface_number = -1;
switch (bus_type) {
case BUS_USB:
/* The device pointed to by raw_dev contains information about
the hidraw device. In order to get information about the
USB device, get the parent device with the
subsystem/devtype pair of "usb"/"usb_device". This will
be several levels up the tree, but the function will find
it. */
usb_dev = udev_device_get_parent_with_subsystem_devtype(
raw_dev,
"usb",
"usb_device");
if (!usb_dev) {
/* Free this device */
free(cur_dev->serial_number);
free(cur_dev->path);
free(cur_dev);
/* Take it off the device list. */
if (prev_dev) {
prev_dev->next = NULL;
cur_dev = prev_dev;
}
else {
cur_dev = root = NULL;
}
goto next;
}
/* Manufacturer and Product strings */
cur_dev->manufacturer_string = copy_udev_string(usb_dev, device_string_names[DEVICE_STRING_MANUFACTURER]);
cur_dev->product_string = copy_udev_string(usb_dev, device_string_names[DEVICE_STRING_PRODUCT]);
/* Release Number */
str = udev_device_get_sysattr_value(usb_dev, "bcdDevice");
cur_dev->release_number = (str)? strtol(str, NULL, 16): 0x0;
/* Get a handle to the interface's udev node. */
intf_dev = udev_device_get_parent_with_subsystem_devtype(
raw_dev,
"usb",
"usb_interface");
if (intf_dev) {
str = udev_device_get_sysattr_value(intf_dev, "bInterfaceNumber");
cur_dev->interface_number = (str)? strtol(str, NULL, 16): -1;
}
break;
case BUS_BLUETOOTH:
/* Manufacturer and Product strings */
cur_dev->manufacturer_string = wcsdup(L"");
cur_dev->product_string = utf8_to_wchar_t(product_name_utf8);
break;
default:
/* Unknown device type - this should never happen, as we
* check for USB and Bluetooth devices above */
break;
}
}
next:
free(serial_number_utf8);
free(product_name_utf8);
udev_device_unref(raw_dev);
/* hid_dev, usb_dev and intf_dev don't need to be (and can't be)
unref()d. It will cause a double-free() error. I'm not
sure why. */
}
/* Free the enumerator and udev objects. */
udev_enumerate_unref(enumerate);
udev_unref(udev);
return root;
}
void HID_API_EXPORT hid_free_enumeration(struct hid_device_info *devs)
{
struct hid_device_info *d = devs;
while (d) {
struct hid_device_info *next = d->next;
free(d->path);
free(d->serial_number);
free(d->manufacturer_string);
free(d->product_string);
free(d);
d = next;
}
}
hid_device * hid_open(unsigned short vendor_id, unsigned short product_id, const 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;
}
hid_device * HID_API_EXPORT hid_open_path(const char *path)
{
hid_device *dev = NULL;
hid_init();
dev = new_hid_device();
if (kernel_version == 0) {
struct utsname name;
int major, minor, release;
int ret;
uname(&name);
ret = sscanf(name.release, "%d.%d.%d", &major, &minor, &release);
if (ret == 3) {
kernel_version = major << 16 | minor << 8 | release;
//printf("Kernel Version: %d\n", kernel_version);
}
else {
printf("Couldn't sscanf() version string %s\n", name.release);
}
}
// OPEN HERE //
dev->device_handle = open(path, O_RDWR);
// If we have a good handle, return it.
if (dev->device_handle > 0) {
/* Get the report descriptor */
int res, desc_size = 0;
struct hidraw_report_descriptor rpt_desc;
memset(&rpt_desc, 0x0, sizeof(rpt_desc));
/* Get Report Descriptor Size */
res = ioctl(dev->device_handle, HIDIOCGRDESCSIZE, &desc_size);
if (res < 0)
perror("HIDIOCGRDESCSIZE");
/* Get Report Descriptor */
rpt_desc.size = desc_size;
res = ioctl(dev->device_handle, HIDIOCGRDESC, &rpt_desc);
if (res < 0) {
perror("HIDIOCGRDESC");
} else {
/* Determine if this device uses numbered reports. */
dev->uses_numbered_reports =
uses_numbered_reports(rpt_desc.value,
rpt_desc.size);
}
return dev;
}
else {
// Unable to open any devices.
free(dev);
return NULL;
}
}
int HID_API_EXPORT hid_write(hid_device *dev, const unsigned char *data, size_t length)
{
int bytes_written;
bytes_written = write(dev->device_handle, data, length);
return bytes_written;
}
int HID_API_EXPORT hid_read_timeout(hid_device *dev, unsigned char *data, size_t length, int milliseconds)
{
int bytes_read;
if (milliseconds != 0) {
/* milliseconds is -1 or > 0. In both cases, we want to
call poll() and wait for data to arrive. -1 means
INFINITE. */
int ret;
struct pollfd fds;
fds.fd = dev->device_handle;
fds.events = POLLIN;
fds.revents = 0;
ret = poll(&fds, 1, milliseconds);
if (ret == -1 || ret == 0)
/* Error or timeout */
return ret;
}
bytes_read = read(dev->device_handle, data, length);
if (bytes_read < 0 && errno == EAGAIN)
bytes_read = 0;
if (bytes_read >= 0 &&
kernel_version < KERNEL_VERSION(2,6,34) &&
dev->uses_numbered_reports) {
/* Work around a kernel bug. Chop off the first byte. */
memmove(data, data+1, bytes_read);
bytes_read--;
}
return bytes_read;
}
int HID_API_EXPORT hid_read(hid_device *dev, unsigned char *data, size_t length)
{
return hid_read_timeout(dev, data, length, (dev->blocking)? -1: 0);
}
int HID_API_EXPORT hid_set_nonblocking(hid_device *dev, int nonblock)
{
int flags, res;
flags = fcntl(dev->device_handle, F_GETFL, 0);
if (flags >= 0) {
if (nonblock)
res = fcntl(dev->device_handle, F_SETFL, flags | O_NONBLOCK);
else
res = fcntl(dev->device_handle, F_SETFL, flags & ~O_NONBLOCK);
}
else
return -1;
if (res < 0) {
return -1;
}
else {
dev->blocking = !nonblock;
return 0; /* Success */
}
}
int HID_API_EXPORT hid_send_feature_report(hid_device *dev, const unsigned char *data, size_t length)
{
int res;
res = ioctl(dev->device_handle, HIDIOCSFEATURE(length), data);
if (res < 0)
perror("ioctl (SFEATURE)");
return res;
}
int HID_API_EXPORT hid_get_feature_report(hid_device *dev, unsigned char *data, size_t length)
{
int res;
res = ioctl(dev->device_handle, HIDIOCGFEATURE(length), data);
if (res < 0)
perror("ioctl (GFEATURE)");
return res;
}
void HID_API_EXPORT hid_close(hid_device *dev)
{
if (!dev)
return;
close(dev->device_handle);
free(dev);
}
int HID_API_EXPORT_CALL hid_get_manufacturer_string(hid_device *dev, wchar_t *string, size_t maxlen)
{
return get_device_string(dev, DEVICE_STRING_MANUFACTURER, string, maxlen);
}
int HID_API_EXPORT_CALL hid_get_product_string(hid_device *dev, wchar_t *string, size_t maxlen)
{
return get_device_string(dev, DEVICE_STRING_PRODUCT, string, maxlen);
}
int HID_API_EXPORT_CALL hid_get_serial_number_string(hid_device *dev, wchar_t *string, size_t maxlen)
{
return get_device_string(dev, DEVICE_STRING_SERIAL, string, maxlen);
}
int HID_API_EXPORT_CALL hid_get_indexed_string(hid_device *dev, int string_index, wchar_t *string, size_t maxlen)
{
return -1;
}
HID_API_EXPORT const wchar_t * HID_API_CALL hid_error(hid_device *dev)
{
return NULL;
}
qthid-4.1-source/firmware.ui 0000644 0001750 0001750 00000006664 12051012642 014225 0 ustar alc alc
CFirmware
Qt::NonModal
0
0
287
122
Firmware Tools
:/qthid/images/fw.png:/qthid/images/fw.png
false
-
Ready...
-
0
0
0
-
Currently selected firmware.
0
0
-
0
-
QLayout::SetDefaultConstraint
-
Select a firmware file on disk
&Select
-
Upload the selected firmware to the FCD
&Upload
-
Compare the selected firmware with the firmware in the FCD
&Verify
-
Qt::Vertical
20
40
qthid-4.1-source/hid-libusb.c 0000644 0001750 0001750 00000113437 12051012677 014245 0 ustar alc alc /*******************************************************
HIDAPI - Multi-Platform library for
communication with HID devices.
Alan Ott
Signal 11 Software
8/22/2009
Linux Version - 6/2/2010
Libusb Version - 8/13/2010
FreeBSD Version - 11/1/2011
Copyright 2009, All Rights Reserved.
At the discretion of the user of this library,
this software may be licensed under the terms of the
GNU Public License v3, a BSD-Style license, or the
original HIDAPI license as outlined in the LICENSE.txt,
LICENSE-gpl3.txt, LICENSE-bsd.txt, and LICENSE-orig.txt
files located at the root of the source distribution.
These files may also be found in the public source
code repository located at:
http://github.com/signal11/hidapi .
********************************************************/
#define _GNU_SOURCE // needed for wcsdup() before glibc 2.10
/* C */
#include
#include
#include
#include
#include
#include
/* Unix */
#include
#include
#include
#include
#include
#include
#include
#include
/* GNU / LibUSB */
#include "libusb.h"
#include "iconv.h"
#include "hidapi.h"
#ifdef __cplusplus
extern "C" {
#endif
#ifdef DEBUG_PRINTF
#define LOG(...) fprintf(stderr, __VA_ARGS__)
#else
#define LOG(...) do {} while (0)
#endif
#ifndef __FreeBSD__
#define DETACH_KERNEL_DRIVER
#endif
/* Uncomment to enable the retrieval of Usage and Usage Page in
hid_enumerate(). Warning, on platforms different from FreeBSD
this is very invasive as it requires the detach
and re-attach of the kernel driver. See comments inside hid_enumerate().
libusb HIDAPI programs are encouraged to use the interface number
instead to differentiate between interfaces on a composite HID device. */
/*#define INVASIVE_GET_USAGE*/
/* Linked List of input reports received from the device. */
struct input_report {
uint8_t *data;
size_t len;
struct input_report *next;
};
struct hid_device_ {
/* Handle to the actual device. */
libusb_device_handle *device_handle;
/* Endpoint information */
int input_endpoint;
int output_endpoint;
int input_ep_max_packet_size;
/* The interface number of the HID */
int interface;
/* Indexes of Strings */
int manufacturer_index;
int product_index;
int serial_index;
/* Whether blocking reads are used */
int blocking; /* boolean */
/* Read thread objects */
pthread_t thread;
pthread_mutex_t mutex; /* Protects input_reports */
pthread_cond_t condition;
pthread_barrier_t barrier; /* Ensures correct startup sequence */
int shutdown_thread;
struct libusb_transfer *transfer;
/* List of received input reports. */
struct input_report *input_reports;
};
static libusb_context *usb_context = NULL;
uint16_t get_usb_code_for_current_locale(void);
static int return_data(hid_device *dev, unsigned char *data, size_t length);
static hid_device *new_hid_device(void)
{
hid_device *dev = calloc(1, sizeof(hid_device));
dev->blocking = 1;
pthread_mutex_init(&dev->mutex, NULL);
pthread_cond_init(&dev->condition, NULL);
pthread_barrier_init(&dev->barrier, NULL, 2);
return dev;
}
static void free_hid_device(hid_device *dev)
{
/* Clean up the thread objects */
pthread_barrier_destroy(&dev->barrier);
pthread_cond_destroy(&dev->condition);
pthread_mutex_destroy(&dev->mutex);
/* Free the device itself */
free(dev);
}
#if 0
//TODO: Implement this funciton on hidapi/libusb..
static void register_error(hid_device *device, const char *op)
{
}
#endif
#ifdef INVASIVE_GET_USAGE
/* Get bytes from a HID Report Descriptor.
Only call with a num_bytes of 0, 1, 2, or 4. */
static uint32_t get_bytes(uint8_t *rpt, size_t len, size_t num_bytes, size_t cur)
{
/* Return if there aren't enough bytes. */
if (cur + num_bytes >= len)
return 0;
if (num_bytes == 0)
return 0;
else if (num_bytes == 1) {
return rpt[cur+1];
}
else if (num_bytes == 2) {
return (rpt[cur+2] * 256 + rpt[cur+1]);
}
else if (num_bytes == 4) {
return (rpt[cur+4] * 0x01000000 +
rpt[cur+3] * 0x00010000 +
rpt[cur+2] * 0x00000100 +
rpt[cur+1] * 0x00000001);
}
else
return 0;
}
/* Retrieves the device's Usage Page and Usage from the report
descriptor. The algorithm is simple, as it just returns the first
Usage and Usage Page that it finds in the descriptor.
The return value is 0 on success and -1 on failure. */
static int get_usage(uint8_t *report_descriptor, size_t size,
unsigned short *usage_page, unsigned short *usage)
{
int i = 0;
int size_code;
int data_len, key_size;
int usage_found = 0, usage_page_found = 0;
while (i < size) {
int key = report_descriptor[i];
int key_cmd = key & 0xfc;
//printf("key: %02hhx\n", key);
if ((key & 0xf0) == 0xf0) {
/* This is a Long Item. The next byte contains the
length of the data section (value) for this key.
See the HID specification, version 1.11, section
6.2.2.3, titled "Long Items." */
if (i+1 < size)
data_len = report_descriptor[i+1];
else
data_len = 0; /* malformed report */
key_size = 3;
}
else {
/* This is a Short Item. The bottom two bits of the
key contain the size code for the data section
(value) for this key. Refer to the HID
specification, version 1.11, section 6.2.2.2,
titled "Short Items." */
size_code = key & 0x3;
switch (size_code) {
case 0:
case 1:
case 2:
data_len = size_code;
break;
case 3:
data_len = 4;
break;
default:
/* Can't ever happen since size_code is & 0x3 */
data_len = 0;
break;
};
key_size = 1;
}
if (key_cmd == 0x4) {
*usage_page = get_bytes(report_descriptor, size, data_len, i);
usage_page_found = 1;
//printf("Usage Page: %x\n", (uint32_t)*usage_page);
}
if (key_cmd == 0x8) {
*usage = get_bytes(report_descriptor, size, data_len, i);
usage_found = 1;
//printf("Usage: %x\n", (uint32_t)*usage);
}
if (usage_page_found && usage_found)
return 0; /* success */
/* Skip over this key and it's associated data */
i += data_len + key_size;
}
return -1; /* failure */
}
#endif // INVASIVE_GET_USAGE
#ifdef __FreeBSD__
/* The FreeBSD version of libusb doesn't have this funciton. In mainline
libusb, it's inlined in libusb.h. This function will bear a striking
resemblence to that one, because there's about one way to code it.
Note that the data parameter is Unicode in UTF-16LE encoding.
Return value is the number of bytes in data, or LIBUSB_ERROR_*.
*/
static inline int libusb_get_string_descriptor(libusb_device_handle *dev,
uint8_t descriptor_index, uint16_t lang_id,
unsigned char *data, int length)
{
return libusb_control_transfer(dev,
LIBUSB_ENDPOINT_IN | 0x0, /* Endpoint 0 IN */
LIBUSB_REQUEST_GET_DESCRIPTOR,
(LIBUSB_DT_STRING << 8) | descriptor_index,
lang_id, data, (uint16_t) length, 1000);
}
#endif
/* Get the first language the device says it reports. This comes from
USB string #0. */
static uint16_t get_first_language(libusb_device_handle *dev)
{
uint16_t buf[32];
int len;
/* Get the string from libusb. */
len = libusb_get_string_descriptor(dev,
0x0, /* String ID */
0x0, /* Language */
(unsigned char*)buf,
sizeof(buf));
if (len < 4)
return 0x0;
return buf[1]; // First two bytes are len and descriptor type.
}
static int is_language_supported(libusb_device_handle *dev, uint16_t lang)
{
uint16_t buf[32];
int len;
int i;
/* Get the string from libusb. */
len = libusb_get_string_descriptor(dev,
0x0, /* String ID */
0x0, /* Language */
(unsigned char*)buf,
sizeof(buf));
if (len < 4)
return 0x0;
len /= 2; /* language IDs are two-bytes each. */
/* Start at index 1 because there are two bytes of protocol data. */
for (i = 1; i < len; i++) {
if (buf[i] == lang)
return 1;
}
return 0;
}
/* This function returns a newly allocated wide string containing the USB
device string numbered by the index. The returned string must be freed
by using free(). */
static wchar_t *get_usb_string(libusb_device_handle *dev, uint8_t idx)
{
char buf[512];
int len;
wchar_t *str = NULL;
wchar_t wbuf[256];
/* iconv variables */
iconv_t ic;
size_t inbytes;
size_t outbytes;
size_t res;
#ifdef __FreeBSD__
const char *inptr;
#else
char *inptr;
#endif
char *outptr;
/* Determine which language to use. */
uint16_t lang;
lang = get_usb_code_for_current_locale();
if (!is_language_supported(dev, lang))
lang = get_first_language(dev);
/* Get the string from libusb. */
len = libusb_get_string_descriptor(dev,
idx,
lang,
(unsigned char*)buf,
sizeof(buf));
if (len < 0)
return NULL;
/* buf does not need to be explicitly NULL-terminated because
it is only passed into iconv() which does not need it. */
/* Initialize iconv. */
ic = iconv_open("WCHAR_T", "UTF-16LE");
if (ic == (iconv_t)-1) {
LOG("iconv_open() failed\n");
return NULL;
}
/* Convert to native wchar_t (UTF-32 on glibc/BSD systems).
Skip the first character (2-bytes). */
inptr = buf+2;
inbytes = len-2;
outptr = (char*) wbuf;
outbytes = sizeof(wbuf);
res = iconv(ic, &inptr, &inbytes, &outptr, &outbytes);
if (res == (size_t)-1) {
LOG("iconv() failed\n");
goto err;
}
/* Write the terminating NULL. */
wbuf[sizeof(wbuf)/sizeof(wbuf[0])-1] = 0x00000000;
if (outbytes >= sizeof(wbuf[0]))
*((wchar_t*)outptr) = 0x00000000;
/* Allocate and copy the string. */
str = wcsdup(wbuf);
err:
iconv_close(ic);
return str;
}
static char *make_path(libusb_device *dev, int interface_number)
{
char str[64];
snprintf(str, sizeof(str), "%04x:%04x:%02x",
libusb_get_bus_number(dev),
libusb_get_device_address(dev),
interface_number);
str[sizeof(str)-1] = '\0';
return strdup(str);
}
int HID_API_EXPORT hid_init(void)
{
if (!usb_context) {
const char *locale;
/* Init Libusb */
if (libusb_init(&usb_context))
return -1;
/* Set the locale if it's not set. */
locale = setlocale(LC_CTYPE, NULL);
if (!locale)
setlocale(LC_CTYPE, "");
}
return 0;
}
int HID_API_EXPORT hid_exit(void)
{
if (usb_context) {
libusb_exit(usb_context);
usb_context = NULL;
}
return 0;
}
struct hid_device_info HID_API_EXPORT *hid_enumerate(unsigned short vendor_id, unsigned short product_id)
{
libusb_device **devs;
libusb_device *dev;
libusb_device_handle *handle;
ssize_t num_devs;
int i = 0;
struct hid_device_info *root = NULL; // return object
struct hid_device_info *cur_dev = NULL;
hid_init();
num_devs = libusb_get_device_list(usb_context, &devs);
if (num_devs < 0)
return NULL;
while ((dev = devs[i++]) != NULL) {
struct libusb_device_descriptor desc;
struct libusb_config_descriptor *conf_desc = NULL;
int j, k;
int interface_num = 0;
int res = libusb_get_device_descriptor(dev, &desc);
unsigned short dev_vid = desc.idVendor;
unsigned short dev_pid = desc.idProduct;
/* HID's are defined at the interface level. */
if (desc.bDeviceClass != LIBUSB_CLASS_PER_INTERFACE)
continue;
res = libusb_get_active_config_descriptor(dev, &conf_desc);
if (res < 0)
libusb_get_config_descriptor(dev, 0, &conf_desc);
if (conf_desc) {
for (j = 0; j < conf_desc->bNumInterfaces; j++) {
const struct libusb_interface *intf = &conf_desc->interface[j];
for (k = 0; k < intf->num_altsetting; k++) {
const struct libusb_interface_descriptor *intf_desc;
intf_desc = &intf->altsetting[k];
if (intf_desc->bInterfaceClass == LIBUSB_CLASS_HID) {
interface_num = intf_desc->bInterfaceNumber;
/* Check the VID/PID against the arguments */
if ((vendor_id == 0x0 && product_id == 0x0) ||
(vendor_id == dev_vid && product_id == dev_pid)) {
struct hid_device_info *tmp;
/* VID/PID match. Create the record. */
tmp = calloc(1, sizeof(struct hid_device_info));
if (cur_dev) {
cur_dev->next = tmp;
}
else {
root = tmp;
}
cur_dev = tmp;
/* Fill out the record */
cur_dev->next = NULL;
cur_dev->path = make_path(dev, interface_num);
res = libusb_open(dev, &handle);
if (res >= 0) {
/* Serial Number */
if (desc.iSerialNumber > 0)
cur_dev->serial_number =
get_usb_string(handle, desc.iSerialNumber);
/* Manufacturer and Product strings */
if (desc.iManufacturer > 0)
cur_dev->manufacturer_string =
get_usb_string(handle, desc.iManufacturer);
if (desc.iProduct > 0)
cur_dev->product_string =
get_usb_string(handle, desc.iProduct);
#ifdef INVASIVE_GET_USAGE
/*
This section is removed because it is too
invasive on the system. Getting a Usage Page
and Usage requires parsing the HID Report
descriptor. Getting a HID Report descriptor
involves claiming the interface. Claiming the
interface involves detaching the kernel driver.
Detaching the kernel driver is hard on the system
because it will unclaim interfaces (if another
app has them claimed) and the re-attachment of
the driver will sometimes change /dev entry names.
It is for these reasons that this section is
#if 0. For composite devices, use the interface
field in the hid_device_info struct to distinguish
between interfaces. */
unsigned char data[256];
#ifdef DETACH_KERNEL_DRIVER
int detached = 0;
/* Usage Page and Usage */
res = libusb_kernel_driver_active(handle, interface_num);
if (res == 1) {
res = libusb_detach_kernel_driver(handle, interface_num);
if (res < 0)
LOG("Couldn't detach kernel driver, even though a kernel driver was attached.");
else
detached = 1;
}
#endif
res = libusb_claim_interface(handle, interface_num);
if (res >= 0) {
/* Get the HID Report Descriptor. */
res = libusb_control_transfer(handle, LIBUSB_ENDPOINT_IN|LIBUSB_RECIPIENT_INTERFACE, LIBUSB_REQUEST_GET_DESCRIPTOR, (LIBUSB_DT_REPORT << 8)|interface_num, 0, data, sizeof(data), 5000);
if (res >= 0) {
unsigned short page=0, usage=0;
/* Parse the usage and usage page
out of the report descriptor. */
get_usage(data, res, &page, &usage);
cur_dev->usage_page = page;
cur_dev->usage = usage;
}
else
LOG("libusb_control_transfer() for getting the HID report failed with %d\n", res);
/* Release the interface */
res = libusb_release_interface(handle, interface_num);
if (res < 0)
LOG("Can't release the interface.\n");
}
else
LOG("Can't claim interface %d\n", res);
#ifdef DETACH_KERNEL_DRIVER
/* Re-attach kernel driver if necessary. */
if (detached) {
res = libusb_attach_kernel_driver(handle, interface_num);
if (res < 0)
LOG("Couldn't re-attach kernel driver.\n");
}
#endif
#endif // INVASIVE_GET_USAGE
libusb_close(handle);
}
/* VID/PID */
cur_dev->vendor_id = dev_vid;
cur_dev->product_id = dev_pid;
/* Release Number */
cur_dev->release_number = desc.bcdDevice;
/* Interface Number */
cur_dev->interface_number = interface_num;
}
}
} /* altsettings */
} /* interfaces */
libusb_free_config_descriptor(conf_desc);
}
}
libusb_free_device_list(devs, 1);
return root;
}
void HID_API_EXPORT hid_free_enumeration(struct hid_device_info *devs)
{
struct hid_device_info *d = devs;
while (d) {
struct hid_device_info *next = d->next;
free(d->path);
free(d->serial_number);
free(d->manufacturer_string);
free(d->product_string);
free(d);
d = next;
}
}
hid_device * hid_open(unsigned short vendor_id, unsigned short product_id, const 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;
}
static void read_callback(struct libusb_transfer *transfer)
{
hid_device *dev = transfer->user_data;
int res;
if (transfer->status == LIBUSB_TRANSFER_COMPLETED) {
struct input_report *rpt = malloc(sizeof(*rpt));
rpt->data = malloc(transfer->actual_length);
memcpy(rpt->data, transfer->buffer, transfer->actual_length);
rpt->len = transfer->actual_length;
rpt->next = NULL;
pthread_mutex_lock(&dev->mutex);
/* Attach the new report object to the end of the list. */
if (dev->input_reports == NULL) {
/* The list is empty. Put it at the root. */
dev->input_reports = rpt;
pthread_cond_signal(&dev->condition);
}
else {
/* Find the end of the list and attach. */
struct input_report *cur = dev->input_reports;
int num_queued = 0;
while (cur->next != NULL) {
cur = cur->next;
num_queued++;
}
cur->next = rpt;
/* Pop one off if we've reached 30 in the queue. This
way we don't grow forever if the user never reads
anything from the device. */
if (num_queued > 30) {
return_data(dev, NULL, 0);
}
}
pthread_mutex_unlock(&dev->mutex);
}
else if (transfer->status == LIBUSB_TRANSFER_CANCELLED) {
dev->shutdown_thread = 1;
return;
}
else if (transfer->status == LIBUSB_TRANSFER_NO_DEVICE) {
dev->shutdown_thread = 1;
return;
}
else if (transfer->status == LIBUSB_TRANSFER_TIMED_OUT) {
//LOG("Timeout (normal)\n");
}
else {
LOG("Unknown transfer code: %d\n", transfer->status);
}
/* Re-submit the transfer object. */
res = libusb_submit_transfer(transfer);
if (res != 0) {
LOG("Unable to submit URB. libusb error code: %d\n", res);
dev->shutdown_thread = 1;
}
}
static void *read_thread(void *param)
{
hid_device *dev = param;
unsigned char *buf;
const size_t length = dev->input_ep_max_packet_size;
/* Set up the transfer object. */
buf = malloc(length);
dev->transfer = libusb_alloc_transfer(0);
libusb_fill_interrupt_transfer(dev->transfer,
dev->device_handle,
dev->input_endpoint,
buf,
length,
read_callback,
dev,
5000/*timeout*/);
/* Make the first submission. Further submissions are made
from inside read_callback() */
libusb_submit_transfer(dev->transfer);
// Notify the main thread that the read thread is up and running.
pthread_barrier_wait(&dev->barrier);
/* Handle all the events. */
while (!dev->shutdown_thread) {
int res;
res = libusb_handle_events(usb_context);
if (res < 0) {
/* There was an error. */
LOG("read_thread(): libusb reports error # %d\n", res);
/* Break out of this loop only on fatal error.*/
if (res != LIBUSB_ERROR_BUSY &&
res != LIBUSB_ERROR_TIMEOUT &&
res != LIBUSB_ERROR_OVERFLOW &&
res != LIBUSB_ERROR_INTERRUPTED) {
break;
}
}
}
/* Cancel any transfer that may be pending. This call will fail
if no transfers are pending, but that's OK. */
if (libusb_cancel_transfer(dev->transfer) == 0) {
/* The transfer was cancelled, so wait for its completion. */
libusb_handle_events(usb_context);
}
/* Now that the read thread is stopping, Wake any threads which are
waiting on data (in hid_read_timeout()). Do this under a mutex to
make sure that a thread which is about to go to sleep waiting on
the condition acutally will go to sleep before the condition is
signaled. */
pthread_mutex_lock(&dev->mutex);
pthread_cond_broadcast(&dev->condition);
pthread_mutex_unlock(&dev->mutex);
/* The dev->transfer->buffer and dev->transfer objects are cleaned up
in hid_close(). They are not cleaned up here because this thread
could end either due to a disconnect or due to a user
call to hid_close(). In both cases the objects can be safely
cleaned up after the call to pthread_join() (in hid_close()), but
since hid_close() calls libusb_cancel_transfer(), on these objects,
they can not be cleaned up here. */
return NULL;
}
hid_device * HID_API_EXPORT hid_open_path(const char *path)
{
hid_device *dev = NULL;
dev = new_hid_device();
libusb_device **devs;
libusb_device *usb_dev;
ssize_t num_devs;
int res;
int d = 0;
int good_open = 0;
hid_init();
num_devs = libusb_get_device_list(usb_context, &devs);
while ((usb_dev = devs[d++]) != NULL) {
struct libusb_device_descriptor desc;
struct libusb_config_descriptor *conf_desc = NULL;
int i,j,k;
libusb_get_device_descriptor(usb_dev, &desc);
if (libusb_get_active_config_descriptor(usb_dev, &conf_desc) < 0)
continue;
for (j = 0; j < conf_desc->bNumInterfaces; j++) {
const struct libusb_interface *intf = &conf_desc->interface[j];
for (k = 0; k < intf->num_altsetting; k++) {
const struct libusb_interface_descriptor *intf_desc;
intf_desc = &intf->altsetting[k];
if (intf_desc->bInterfaceClass == LIBUSB_CLASS_HID) {
char *dev_path = make_path(usb_dev, intf_desc->bInterfaceNumber);
if (!strcmp(dev_path, path)) {
/* Matched Paths. Open this device */
// OPEN HERE //
res = libusb_open(usb_dev, &dev->device_handle);
if (res < 0) {
LOG("can't open device\n");
free(dev_path);
break;
}
good_open = 1;
#ifdef DETACH_KERNEL_DRIVER
/* Detach the kernel driver, but only if the
device is managed by the kernel */
if (libusb_kernel_driver_active(dev->device_handle, intf_desc->bInterfaceNumber) == 1) {
res = libusb_detach_kernel_driver(dev->device_handle, intf_desc->bInterfaceNumber);
if (res < 0) {
libusb_close(dev->device_handle);
LOG("Unable to detach Kernel Driver\n");
free(dev_path);
good_open = 0;
break;
}
}
#endif
res = libusb_claim_interface(dev->device_handle, intf_desc->bInterfaceNumber);
if (res < 0) {
LOG("can't claim interface %d: %d\n", intf_desc->bInterfaceNumber, res);
free(dev_path);
libusb_close(dev->device_handle);
good_open = 0;
break;
}
/* Store off the string descriptor indexes */
dev->manufacturer_index = desc.iManufacturer;
dev->product_index = desc.iProduct;
dev->serial_index = desc.iSerialNumber;
/* Store off the interface number */
dev->interface = intf_desc->bInterfaceNumber;
/* Find the INPUT and OUTPUT endpoints. An
OUTPUT endpoint is not required. */
for (i = 0; i < intf_desc->bNumEndpoints; i++) {
const struct libusb_endpoint_descriptor *ep
= &intf_desc->endpoint[i];
/* Determine the type and direction of this
endpoint. */
int is_interrupt =
(ep->bmAttributes & LIBUSB_TRANSFER_TYPE_MASK)
== LIBUSB_TRANSFER_TYPE_INTERRUPT;
int is_output =
(ep->bEndpointAddress & LIBUSB_ENDPOINT_DIR_MASK)
== LIBUSB_ENDPOINT_OUT;
int is_input =
(ep->bEndpointAddress & LIBUSB_ENDPOINT_DIR_MASK)
== LIBUSB_ENDPOINT_IN;
/* Decide whether to use it for intput or output. */
if (dev->input_endpoint == 0 &&
is_interrupt && is_input) {
/* Use this endpoint for INPUT */
dev->input_endpoint = ep->bEndpointAddress;
dev->input_ep_max_packet_size = ep->wMaxPacketSize;
}
if (dev->output_endpoint == 0 &&
is_interrupt && is_output) {
/* Use this endpoint for OUTPUT */
dev->output_endpoint = ep->bEndpointAddress;
}
}
pthread_create(&dev->thread, NULL, read_thread, dev);
// Wait here for the read thread to be initialized.
pthread_barrier_wait(&dev->barrier);
}
free(dev_path);
}
}
}
libusb_free_config_descriptor(conf_desc);
}
libusb_free_device_list(devs, 1);
// If we have a good handle, return it.
if (good_open) {
return dev;
}
else {
// Unable to open any devices.
free_hid_device(dev);
return NULL;
}
}
int HID_API_EXPORT hid_write(hid_device *dev, const unsigned char *data, size_t length)
{
int res;
int report_number = data[0];
int skipped_report_id = 0;
if (report_number == 0x0) {
data++;
length--;
skipped_report_id = 1;
}
if (dev->output_endpoint <= 0) {
/* No interrput out endpoint. Use the Control Endpoint */
res = libusb_control_transfer(dev->device_handle,
LIBUSB_REQUEST_TYPE_CLASS|LIBUSB_RECIPIENT_INTERFACE|LIBUSB_ENDPOINT_OUT,
0x09/*HID Set_Report*/,
(2/*HID output*/ << 8) | report_number,
dev->interface,
(unsigned char *)data, length,
1000/*timeout millis*/);
if (res < 0)
return -1;
if (skipped_report_id)
length++;
return length;
}
else {
/* Use the interrupt out endpoint */
int actual_length;
res = libusb_interrupt_transfer(dev->device_handle,
dev->output_endpoint,
(unsigned char*)data,
length,
&actual_length, 1000);
if (res < 0)
return -1;
if (skipped_report_id)
actual_length++;
return actual_length;
}
}
/* Helper function, to simplify hid_read().
This should be called with dev->mutex locked. */
static int return_data(hid_device *dev, unsigned char *data, size_t length)
{
/* Copy the data out of the linked list item (rpt) into the
return buffer (data), and delete the liked list item. */
struct input_report *rpt = dev->input_reports;
size_t len = (length < rpt->len)? length: rpt->len;
if (len > 0)
memcpy(data, rpt->data, len);
dev->input_reports = rpt->next;
free(rpt->data);
free(rpt);
return len;
}
static void cleanup_mutex(void *param)
{
hid_device *dev = param;
pthread_mutex_unlock(&dev->mutex);
}
int HID_API_EXPORT hid_read_timeout(hid_device *dev, unsigned char *data, size_t length, int milliseconds)
{
int bytes_read = -1;
#if 0
int transferred;
int res = libusb_interrupt_transfer(dev->device_handle, dev->input_endpoint, data, length, &transferred, 5000);
LOG("transferred: %d\n", transferred);
return transferred;
#endif
pthread_mutex_lock(&dev->mutex);
pthread_cleanup_push(&cleanup_mutex, dev);
/* There's an input report queued up. Return it. */
if (dev->input_reports) {
/* Return the first one */
bytes_read = return_data(dev, data, length);
goto ret;
}
if (dev->shutdown_thread) {
/* This means the device has been disconnected.
An error code of -1 should be returned. */
bytes_read = -1;
goto ret;
}
if (milliseconds == -1) {
/* Blocking */
while (!dev->input_reports && !dev->shutdown_thread) {
pthread_cond_wait(&dev->condition, &dev->mutex);
}
if (dev->input_reports) {
bytes_read = return_data(dev, data, length);
}
}
else if (milliseconds > 0) {
/* Non-blocking, but called with timeout. */
int res;
struct timespec ts;
clock_gettime(CLOCK_REALTIME, &ts);
ts.tv_sec += milliseconds / 1000;
ts.tv_nsec += (milliseconds % 1000) * 1000000;
if (ts.tv_nsec >= 1000000000L) {
ts.tv_sec++;
ts.tv_nsec -= 1000000000L;
}
while (!dev->input_reports && !dev->shutdown_thread) {
res = pthread_cond_timedwait(&dev->condition, &dev->mutex, &ts);
if (res == 0) {
if (dev->input_reports) {
bytes_read = return_data(dev, data, length);
break;
}
/* If we're here, there was a spurious wake up
or the read thread was shutdown. Run the
loop again (ie: don't break). */
}
else if (res == ETIMEDOUT) {
/* Timed out. */
bytes_read = 0;
break;
}
else {
/* Error. */
bytes_read = -1;
break;
}
}
}
else {
/* Purely non-blocking */
bytes_read = 0;
}
ret:
pthread_mutex_unlock(&dev->mutex);
pthread_cleanup_pop(0);
return bytes_read;
}
int HID_API_EXPORT hid_read(hid_device *dev, unsigned char *data, size_t length)
{
return hid_read_timeout(dev, data, length, dev->blocking ? -1 : 0);
}
int HID_API_EXPORT hid_set_nonblocking(hid_device *dev, int nonblock)
{
dev->blocking = !nonblock;
return 0;
}
int HID_API_EXPORT hid_send_feature_report(hid_device *dev, const unsigned char *data, size_t length)
{
int res = -1;
int skipped_report_id = 0;
int report_number = data[0];
if (report_number == 0x0) {
data++;
length--;
skipped_report_id = 1;
}
res = libusb_control_transfer(dev->device_handle,
LIBUSB_REQUEST_TYPE_CLASS|LIBUSB_RECIPIENT_INTERFACE|LIBUSB_ENDPOINT_OUT,
0x09/*HID set_report*/,
(3/*HID feature*/ << 8) | report_number,
dev->interface,
(unsigned char *)data, length,
1000/*timeout millis*/);
if (res < 0)
return -1;
/* Account for the report ID */
if (skipped_report_id)
length++;
return length;
}
int HID_API_EXPORT hid_get_feature_report(hid_device *dev, unsigned char *data, size_t length)
{
int res = -1;
int skipped_report_id = 0;
int report_number = data[0];
if (report_number == 0x0) {
/* Offset the return buffer by 1, so that the report ID
will remain in byte 0. */
data++;
length--;
skipped_report_id = 1;
}
res = libusb_control_transfer(dev->device_handle,
LIBUSB_REQUEST_TYPE_CLASS|LIBUSB_RECIPIENT_INTERFACE|LIBUSB_ENDPOINT_IN,
0x01/*HID get_report*/,
(3/*HID feature*/ << 8) | report_number,
dev->interface,
(unsigned char *)data, length,
1000/*timeout millis*/);
if (res < 0)
return -1;
if (skipped_report_id)
res++;
return res;
}
void HID_API_EXPORT hid_close(hid_device *dev)
{
if (!dev)
return;
/* Cause read_thread() to stop. */
dev->shutdown_thread = 1;
libusb_cancel_transfer(dev->transfer);
/* Wait for read_thread() to end. */
pthread_join(dev->thread, NULL);
/* Clean up the Transfer objects allocated in read_thread(). */
free(dev->transfer->buffer);
libusb_free_transfer(dev->transfer);
/* release the interface */
libusb_release_interface(dev->device_handle, dev->interface);
/* Close the handle */
libusb_close(dev->device_handle);
/* Clear out the queue of received reports. */
pthread_mutex_lock(&dev->mutex);
while (dev->input_reports) {
return_data(dev, NULL, 0);
}
pthread_mutex_unlock(&dev->mutex);
free_hid_device(dev);
}
int HID_API_EXPORT_CALL hid_get_manufacturer_string(hid_device *dev, wchar_t *string, size_t maxlen)
{
return hid_get_indexed_string(dev, dev->manufacturer_index, string, maxlen);
}
int HID_API_EXPORT_CALL hid_get_product_string(hid_device *dev, wchar_t *string, size_t maxlen)
{
return hid_get_indexed_string(dev, dev->product_index, string, maxlen);
}
int HID_API_EXPORT_CALL hid_get_serial_number_string(hid_device *dev, wchar_t *string, size_t maxlen)
{
return hid_get_indexed_string(dev, dev->serial_index, string, maxlen);
}
int HID_API_EXPORT_CALL hid_get_indexed_string(hid_device *dev, int string_index, wchar_t *string, size_t maxlen)
{
wchar_t *str;
str = get_usb_string(dev->device_handle, string_index);
if (str) {
wcsncpy(string, str, maxlen);
string[maxlen-1] = L'\0';
free(str);
return 0;
}
else
return -1;
}
HID_API_EXPORT const wchar_t * HID_API_CALL hid_error(hid_device *dev)
{
return NULL;
}
struct lang_map_entry {
const char *name;
const char *string_code;
uint16_t usb_code;
};
#define LANG(name,code,usb_code) { name, code, usb_code }
static struct lang_map_entry lang_map[] = {
LANG("Afrikaans", "af", 0x0436),
LANG("Albanian", "sq", 0x041C),
LANG("Arabic - United Arab Emirates", "ar_ae", 0x3801),
LANG("Arabic - Bahrain", "ar_bh", 0x3C01),
LANG("Arabic - Algeria", "ar_dz", 0x1401),
LANG("Arabic - Egypt", "ar_eg", 0x0C01),
LANG("Arabic - Iraq", "ar_iq", 0x0801),
LANG("Arabic - Jordan", "ar_jo", 0x2C01),
LANG("Arabic - Kuwait", "ar_kw", 0x3401),
LANG("Arabic - Lebanon", "ar_lb", 0x3001),
LANG("Arabic - Libya", "ar_ly", 0x1001),
LANG("Arabic - Morocco", "ar_ma", 0x1801),
LANG("Arabic - Oman", "ar_om", 0x2001),
LANG("Arabic - Qatar", "ar_qa", 0x4001),
LANG("Arabic - Saudi Arabia", "ar_sa", 0x0401),
LANG("Arabic - Syria", "ar_sy", 0x2801),
LANG("Arabic - Tunisia", "ar_tn", 0x1C01),
LANG("Arabic - Yemen", "ar_ye", 0x2401),
LANG("Armenian", "hy", 0x042B),
LANG("Azeri - Latin", "az_az", 0x042C),
LANG("Azeri - Cyrillic", "az_az", 0x082C),
LANG("Basque", "eu", 0x042D),
LANG("Belarusian", "be", 0x0423),
LANG("Bulgarian", "bg", 0x0402),
LANG("Catalan", "ca", 0x0403),
LANG("Chinese - China", "zh_cn", 0x0804),
LANG("Chinese - Hong Kong SAR", "zh_hk", 0x0C04),
LANG("Chinese - Macau SAR", "zh_mo", 0x1404),
LANG("Chinese - Singapore", "zh_sg", 0x1004),
LANG("Chinese - Taiwan", "zh_tw", 0x0404),
LANG("Croatian", "hr", 0x041A),
LANG("Czech", "cs", 0x0405),
LANG("Danish", "da", 0x0406),
LANG("Dutch - Netherlands", "nl_nl", 0x0413),
LANG("Dutch - Belgium", "nl_be", 0x0813),
LANG("English - Australia", "en_au", 0x0C09),
LANG("English - Belize", "en_bz", 0x2809),
LANG("English - Canada", "en_ca", 0x1009),
LANG("English - Caribbean", "en_cb", 0x2409),
LANG("English - Ireland", "en_ie", 0x1809),
LANG("English - Jamaica", "en_jm", 0x2009),
LANG("English - New Zealand", "en_nz", 0x1409),
LANG("English - Phillippines", "en_ph", 0x3409),
LANG("English - Southern Africa", "en_za", 0x1C09),
LANG("English - Trinidad", "en_tt", 0x2C09),
LANG("English - Great Britain", "en_gb", 0x0809),
LANG("English - United States", "en_us", 0x0409),
LANG("Estonian", "et", 0x0425),
LANG("Farsi", "fa", 0x0429),
LANG("Finnish", "fi", 0x040B),
LANG("Faroese", "fo", 0x0438),
LANG("French - France", "fr_fr", 0x040C),
LANG("French - Belgium", "fr_be", 0x080C),
LANG("French - Canada", "fr_ca", 0x0C0C),
LANG("French - Luxembourg", "fr_lu", 0x140C),
LANG("French - Switzerland", "fr_ch", 0x100C),
LANG("Gaelic - Ireland", "gd_ie", 0x083C),
LANG("Gaelic - Scotland", "gd", 0x043C),
LANG("German - Germany", "de_de", 0x0407),
LANG("German - Austria", "de_at", 0x0C07),
LANG("German - Liechtenstein", "de_li", 0x1407),
LANG("German - Luxembourg", "de_lu", 0x1007),
LANG("German - Switzerland", "de_ch", 0x0807),
LANG("Greek", "el", 0x0408),
LANG("Hebrew", "he", 0x040D),
LANG("Hindi", "hi", 0x0439),
LANG("Hungarian", "hu", 0x040E),
LANG("Icelandic", "is", 0x040F),
LANG("Indonesian", "id", 0x0421),
LANG("Italian - Italy", "it_it", 0x0410),
LANG("Italian - Switzerland", "it_ch", 0x0810),
LANG("Japanese", "ja", 0x0411),
LANG("Korean", "ko", 0x0412),
LANG("Latvian", "lv", 0x0426),
LANG("Lithuanian", "lt", 0x0427),
LANG("F.Y.R.O. Macedonia", "mk", 0x042F),
LANG("Malay - Malaysia", "ms_my", 0x043E),
LANG("Malay – Brunei", "ms_bn", 0x083E),
LANG("Maltese", "mt", 0x043A),
LANG("Marathi", "mr", 0x044E),
LANG("Norwegian - Bokml", "no_no", 0x0414),
LANG("Norwegian - Nynorsk", "no_no", 0x0814),
LANG("Polish", "pl", 0x0415),
LANG("Portuguese - Portugal", "pt_pt", 0x0816),
LANG("Portuguese - Brazil", "pt_br", 0x0416),
LANG("Raeto-Romance", "rm", 0x0417),
LANG("Romanian - Romania", "ro", 0x0418),
LANG("Romanian - Republic of Moldova", "ro_mo", 0x0818),
LANG("Russian", "ru", 0x0419),
LANG("Russian - Republic of Moldova", "ru_mo", 0x0819),
LANG("Sanskrit", "sa", 0x044F),
LANG("Serbian - Cyrillic", "sr_sp", 0x0C1A),
LANG("Serbian - Latin", "sr_sp", 0x081A),
LANG("Setsuana", "tn", 0x0432),
LANG("Slovenian", "sl", 0x0424),
LANG("Slovak", "sk", 0x041B),
LANG("Sorbian", "sb", 0x042E),
LANG("Spanish - Spain (Traditional)", "es_es", 0x040A),
LANG("Spanish - Argentina", "es_ar", 0x2C0A),
LANG("Spanish - Bolivia", "es_bo", 0x400A),
LANG("Spanish - Chile", "es_cl", 0x340A),
LANG("Spanish - Colombia", "es_co", 0x240A),
LANG("Spanish - Costa Rica", "es_cr", 0x140A),
LANG("Spanish - Dominican Republic", "es_do", 0x1C0A),
LANG("Spanish - Ecuador", "es_ec", 0x300A),
LANG("Spanish - Guatemala", "es_gt", 0x100A),
LANG("Spanish - Honduras", "es_hn", 0x480A),
LANG("Spanish - Mexico", "es_mx", 0x080A),
LANG("Spanish - Nicaragua", "es_ni", 0x4C0A),
LANG("Spanish - Panama", "es_pa", 0x180A),
LANG("Spanish - Peru", "es_pe", 0x280A),
LANG("Spanish - Puerto Rico", "es_pr", 0x500A),
LANG("Spanish - Paraguay", "es_py", 0x3C0A),
LANG("Spanish - El Salvador", "es_sv", 0x440A),
LANG("Spanish - Uruguay", "es_uy", 0x380A),
LANG("Spanish - Venezuela", "es_ve", 0x200A),
LANG("Southern Sotho", "st", 0x0430),
LANG("Swahili", "sw", 0x0441),
LANG("Swedish - Sweden", "sv_se", 0x041D),
LANG("Swedish - Finland", "sv_fi", 0x081D),
LANG("Tamil", "ta", 0x0449),
LANG("Tatar", "tt", 0X0444),
LANG("Thai", "th", 0x041E),
LANG("Turkish", "tr", 0x041F),
LANG("Tsonga", "ts", 0x0431),
LANG("Ukrainian", "uk", 0x0422),
LANG("Urdu", "ur", 0x0420),
LANG("Uzbek - Cyrillic", "uz_uz", 0x0843),
LANG("Uzbek – Latin", "uz_uz", 0x0443),
LANG("Vietnamese", "vi", 0x042A),
LANG("Xhosa", "xh", 0x0434),
LANG("Yiddish", "yi", 0x043D),
LANG("Zulu", "zu", 0x0435),
LANG(NULL, NULL, 0x0),
};
uint16_t get_usb_code_for_current_locale(void)
{
char *locale;
char search_string[64];
char *ptr;
/* Get the current locale. */
locale = setlocale(0, NULL);
if (!locale)
return 0x0;
/* Make a copy of the current locale string. */
strncpy(search_string, locale, sizeof(search_string));
search_string[sizeof(search_string)-1] = '\0';
/* Chop off the encoding part, and make it lower case. */
ptr = search_string;
while (*ptr) {
*ptr = tolower(*ptr);
if (*ptr == '.') {
*ptr = '\0';
break;
}
ptr++;
}
/* Find the entry which matches the string code of our locale. */
struct lang_map_entry *lang = lang_map;
while (lang->string_code) {
if (!strcmp(lang->string_code, search_string)) {
return lang->usb_code;
}
lang++;
}
/* There was no match. Find with just the language only. */
/* Chop off the variant. Chop it off at the '_'. */
ptr = search_string;
while (*ptr) {
*ptr = tolower(*ptr);
if (*ptr == '_') {
*ptr = '\0';
break;
}
ptr++;
}
#if 0 // TODO: Do we need this?
/* Find the entry which matches the string code of our language. */
lang = lang_map;
while (lang->string_code) {
if (!strcmp(lang->string_code, search_string)) {
return lang->usb_code;
}
lang++;
}
#endif
/* Found nothing. */
return 0x0;
}
#ifdef __cplusplus
}
#endif
qthid-4.1-source/firmware.cpp 0000644 0001750 0001750 00000015207 12051012677 014373 0 ustar alc alc /***************************************************************************
* This file is part of Qthid.
*
* Copyright (C) 2011-2012 Alexandru Csete, OZ9AEC
*
* Qthid is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Qthid is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Qthid. If not, see .
*
***************************************************************************/
#include
#include
#include
#include
#include
#include
#include
#include "fcd.h"
#include "firmware.h"
#include "ui_firmware.h"
CFirmware::CFirmware(QWidget *parent) :
QDialog(parent),
ui(new Ui::CFirmware)
{
ui->setupUi(this);
// disable buttons if lineEdit is empty
checkFirmwareSelection(ui->lineEdit->text());
}
CFirmware::~CFirmware()
{
qDebug() << "Firmware dialog destroyed";
delete ui;
}
void CFirmware::closeEvent(QCloseEvent *event)
{
qDebug() << "fwDialog closeEvent detected";
event->ignore();
finished(42);
}
/*! \brief Select a firmware file on disk. */
void CFirmware::on_selectButton_clicked()
{
// retrieve last used folder
QSettings settings;
QString path = settings.value("LastFwFolder", QDir::currentPath()).toString();
// execute modal file selector and get FW file name
QString fileName = QFileDialog::getOpenFileName(this,
tr("Open FCD firmware"),
path,
tr("FCD firmware files (*.bin)"));
if (!fileName.isNull())
{
// store selected folder
QFileInfo fileInfo(fileName);
qDebug() << "FW folder:" << fileInfo.absolutePath();
settings.setValue("LastFwFolder", fileInfo.absolutePath());
// show firmware file path
ui->lineEdit->setText(fileName);
}
}
void CFirmware::on_uploadButton_clicked()
{
qDebug() << "FIXME:" << __func__;
#if 0
QFile qf(ui->lineEdit->text());
qint64 qn64size = qf.size();
char *buf=new char[qn64size];
if (buf==NULL)
{
QMessageBox::critical(this, tr("FCD"), tr("Unable to allocate memory for firmware image"));
return;
}
if (!qf.open(QIODevice::ReadOnly))
{
QMessageBox::critical(this, tr("FCD"), tr("Unable to open firmware file:\n").arg(ui->lineEdit->text()));
delete buf;
return;
}
else
{
if (qf.read(buf,qn64size) != qn64size)
{
QMessageBox::critical(this, tr("FCD"), tr("Unable to read firmware file:\n").arg(ui->lineEdit->text()));
delete buf;
qf.close();
return;
}
}
qf.close();
ui->statusLabel->setText(tr("Erasing FCD flash..."));
ui->lineEdit->setEnabled(false);
ui->selectButton->setEnabled(false);
ui->uploadButton->setEnabled(false);
ui->verifyButton->setEnabled(false);
// process pending GUI events before we commit the block loop
//qApp->processEvents();
QCoreApplication::processEvents(); // FIXME: neither works
// FIXME: progress bar
// Erase old firmware then write the new one
if (fcdBlErase() != FCD_MODE_BL)
{
ui->statusLabel->setText(tr("Flash erase failed"));
}
else
{
ui->statusLabel->setText(tr("Uploading new firmware..."));
if (fcdBlWriteFirmware(buf,(int64_t)qn64size) != FCD_MODE_BL)
{
ui->statusLabel->setText(tr("Write firmware failed"));
}
else {
ui->statusLabel->setText(tr("Firmware upload successful"));
}
}
ui->lineEdit->setEnabled(true);
ui->selectButton->setEnabled(true);
checkFirmwareSelection(ui->lineEdit->text());
delete buf;
#endif
}
/*! \brief Verify firmware in FCD. */
void CFirmware::on_verifyButton_clicked()
{
qDebug() << "FIXME:" << __func__;
#if 0
QFile qf(ui->lineEdit->text());
qint64 qn64size = qf.size();
char *buf=new char[qn64size];
if (buf==NULL)
{
QMessageBox::critical(this, tr("FCD"), tr("Unable to allocate memory for firmware image"));
return;
}
if (!qf.open(QIODevice::ReadOnly))
{
QMessageBox::critical(this, tr("FCD"), tr("Unable to open firmware file:\n").arg(ui->lineEdit->text()));
delete buf;
return;
}
else
{
if (qf.read(buf,qn64size) != qn64size)
{
QMessageBox::critical(this, tr("FCD"), tr("Unable to read firmware file:\n").arg(ui->lineEdit->text()));
delete buf;
qf.close();
return;
}
}
qf.close();
ui->statusLabel->setText(tr("Verifying firmware in FCD..."));
ui->lineEdit->setEnabled(false);
ui->selectButton->setEnabled(false);
ui->uploadButton->setEnabled(false);
ui->verifyButton->setEnabled(false);
// process pending GUI events before we commit the block loop
//qApp->processEvents();
QCoreApplication::processEvents(); // FIXME: neither works
// execute verification
// FIXME: progress bar
if (fcdBlVerifyFirmware(buf,(int64_t)qn64size) != FCD_MODE_BL)
{
ui->statusLabel->setText(tr("Firmware verification failed"));
}
else
{
ui->statusLabel->setText(tr("Firmware successfully verified"));
}
ui->lineEdit->setEnabled(true);
ui->selectButton->setEnabled(true);
checkFirmwareSelection(ui->lineEdit->text());
delete buf;
#endif
}
/*! \brief The text in the lineEdit has changed (via setText). */
void CFirmware::on_lineEdit_textChanged(const QString & text)
{
checkFirmwareSelection(text);
}
/*! \brief The text in the lineEdit has been edited by the user. */
void CFirmware::on_lineEdit_textEdited(const QString & text)
{
checkFirmwareSelection(text);
}
/*! \brief Check whether fwFile exists and enable/disable Upload and
* Verify buttons accordingly. */
void CFirmware::checkFirmwareSelection(const QString &fwFile)
{
if (QFile::exists(fwFile))
{
ui->uploadButton->setEnabled(true);
ui->verifyButton->setEnabled(true);
}
else
{
ui->uploadButton->setEnabled(false);
ui->verifyButton->setEnabled(false);
}
}
qthid-4.1-source/fcd.c 0000644 0001750 0001750 00000052744 12051012677 012762 0 ustar alc alc /***************************************************************************
* This file is part of Qthid.
*
* Copyright (C) 2010 Howard Long, G6LVB
* Copyright (C) 2011 Mario Lorenz, DL5MLO
* Copyright (C) 2011-2012 Alexandru Csete, OZ9AEC
*
* Qthid is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Qthid is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Qthid. If not, see .
*
***************************************************************************/
#define FCD
#include
#ifdef WIN32
#include
#else
#include
#endif
#include
#include "hidapi.h"
#include "fcdhidcmd.h"
#include "fcd.h"
#define FALSE 0
#define TRUE 1
typedef int BOOL;
const unsigned short _usVID=0x04D8; /*!< USB vendor ID. */
const unsigned short _usPID=0xFB31; /*!< USB product ID. */
/** \brief Open FCD device.
* \return Pointer to the FCD HID device or NULL if none found
*
* This function looks for FCD devices connected to the computer and
* opens the first one found.
*/
static hid_device *fcdOpen(void)
{
struct hid_device_info *phdi=NULL;
hid_device *phd=NULL;
char *pszPath=NULL;
phdi=hid_enumerate(_usVID,_usPID);
if (phdi==NULL)
{
return NULL; // No FCD device found
}
pszPath=strdup(phdi->path);
if (pszPath==NULL)
{
return NULL;
}
hid_free_enumeration(phdi);
phdi=NULL;
if ((phd=hid_open_path(pszPath)) == NULL)
{
free(pszPath);
pszPath=NULL;
return NULL;
}
free(pszPath);
pszPath=NULL;
return phd;
}
/** \brief Close FCD HID device. */
static void fcdClose(hid_device *phd)
{
hid_close(phd);
}
/** \brief Get FCD mode.
* \return The current FCD mode.
* \sa FCD_MODE_ENUM
*/
EXTERN FCD_API_EXPORT FCD_API_CALL FCD_MODE_ENUM fcdGetMode(void)
{
hid_device *phd=NULL;
unsigned char aucBufIn[65];
unsigned char aucBufOut[65];
FCD_MODE_ENUM fcd_mode = FCD_MODE_NONE;
phd = fcdOpen();
if (phd == NULL)
{
return FCD_MODE_NONE;
}
/* Send a BL Query Command */
aucBufOut[0] = 0; // Report ID. Ignored by HID Class firmware as only config'd for one report
aucBufOut[1] = FCD_CMD_BL_QUERY;
hid_write(phd, aucBufOut, 65);
memset(aucBufIn, 0xCC, 65); // Clear out the response buffer
hid_read(phd, aucBufIn, 65);
fcdClose(phd);
phd = NULL;
/* first check status bytes then check which mode */
if (aucBufIn[0]==FCD_CMD_BL_QUERY && aucBufIn[1]==1) {
/* In bootloader mode we have the string "FCDBL" starting at acBufIn[2] **/
if (strncmp((char *)(aucBufIn+2), "FCDBL", 5) == 0) {
fcd_mode = FCD_MODE_BL;
}
/* In application mode we have "FCDAPP_18.06" where the number is the FW version */
else if (strncmp((char *)(aucBufIn+2), "FCDAPP", 6) == 0) {
fcd_mode = FCD_MODE_APP;
}
/* either no FCD or firmware less than 18f */
else {
fcd_mode = FCD_MODE_NONE;
}
}
return fcd_mode;
}
/** \brief Get FCD firmware version as string.
* \param str The returned vesion number as a 0 terminated string (must be pre-allocated)
* \return The current FCD mode.
* \sa FCD_MODE_ENUM
*/
EXTERN FCD_API_EXPORT FCD_API_CALL FCD_MODE_ENUM fcdGetFwVerStr(char *str)
{
hid_device *phd=NULL;
unsigned char aucBufIn[65];
unsigned char aucBufOut[65];
FCD_MODE_ENUM fcd_mode = FCD_MODE_NONE;
phd = fcdOpen();
if (phd == NULL)
{
return FCD_MODE_NONE;
}
/* Send a BL Query Command */
aucBufOut[0] = 0; // Report ID. Ignored by HID Class firmware as only config'd for one report
aucBufOut[1] = FCD_CMD_BL_QUERY;
hid_write(phd, aucBufOut, 65);
memset(aucBufIn, 0xCC, 65); // Clear out the response buffer
hid_read(phd, aucBufIn, 65);
fcdClose(phd);
phd = NULL;
/* first check status bytes then check which mode */
if (aucBufIn[0]==FCD_CMD_BL_QUERY && aucBufIn[1]==1) {
/* In bootloader mode we have the string "FCDBL" starting at acBufIn[2] **/
if (strncmp((char *)(aucBufIn+2), "FCDBL", 5) == 0) {
fcd_mode = FCD_MODE_BL;
}
/* In application mode we have "FCDAPP_18.06" where the number is the FW version */
else if (strncmp((char *)(aucBufIn+2), "FCDAPP", 6) == 0) {
strncpy(str, (char *)(aucBufIn+9), 5);
str[5] = 0;
fcd_mode = FCD_MODE_APP;
}
/* either no FCD or firmware less than 18f */
else {
fcd_mode = FCD_MODE_NONE;
}
}
return fcd_mode;
}
/** \brief Reset FCD to bootloader mode.
* \return FCD_MODE_NONE
*
* This function is used to switch the FCD into bootloader mode in which
* various firmware operations can be performed.
*/
EXTERN FCD_API_EXPORT FCD_API_CALL FCD_MODE_ENUM fcdAppReset(void)
{
hid_device *phd=NULL;
//unsigned char aucBufIn[65];
unsigned char aucBufOut[65];
phd = fcdOpen();
if (phd == NULL)
{
return FCD_MODE_NONE;
}
// Send an App reset command
aucBufOut[0] = 0; // Report ID. Ignored by HID Class firmware as only config'd for one report
aucBufOut[1] = FCD_CMD_APP_RESET;
hid_write(phd, aucBufOut, 65);
/** FIXME: hid_read() will occasionally hang due to a pthread_cond_wait() never returning.
It seems that the read_callback() in hid-libusb.c will never receive any
data during the reconfiguration. Since the same logic works in the native
windows application, it could be a libusb thing. Anyhow, since the value
returned by this function is not used, we may as well just skip the hid_read()
and return FME_NONE.
Correct switch from APP to BL mode can be observed in /var/log/messages (linux)
(when in bootloader mode the device version includes 'BL')
*/
/*
memset(aucBufIn,0xCC,65); // Clear out the response buffer
hid_read(phd,aucBufIn,65);
if (aucBufIn[0]==FCDCMDAPPRESET && aucBufIn[1]==1)
{
FCDClose(phd);
phd=NULL;
return FME_APP;
}
FCDClose(phd);
phd=NULL;
return FME_BL;
*/
fcdClose(phd);
phd = NULL;
return FCD_MODE_NONE;
}
/** \brief Set FCD frequency with kHz resolution.
* \param nFreq The new frequency in kHz.
* \return The FCD mode.
*
* This function sets the frequency of the FCD with 1 kHz resolution. The parameter
* nFreq must already contain any necessary frequency corrention.
*
* \sa fcdAppSetFreq
*/
EXTERN FCD_API_EXPORT FCD_API_CALL FCD_MODE_ENUM fcdAppSetFreqKhz(int nFreq)
{
hid_device *phd=NULL;
unsigned char aucBufIn[65];
unsigned char aucBufOut[65];
phd = fcdOpen();
if (phd == NULL)
{
return FCD_MODE_NONE;
}
// Send an App reset command
aucBufOut[0] = 0; // Report ID. Ignored by HID Class firmware as only config'd for one report
aucBufOut[1] = FCD_CMD_APP_SET_FREQ_KHZ;
aucBufOut[2] = (unsigned char)nFreq;
aucBufOut[3] = (unsigned char)(nFreq>>8);
aucBufOut[4] = (unsigned char)(nFreq>>16);
hid_write(phd, aucBufOut, 65);
memset(aucBufIn, 0xCC, 65); // Clear out the response buffer
hid_read(phd, aucBufIn, 65);
fcdClose(phd);
phd = NULL;
if (aucBufIn[0]==FCD_CMD_APP_SET_FREQ_KHZ && aucBufIn[1]==1)
{
return FCD_MODE_APP;
}
return FCD_MODE_BL;
}
/** \brief Set FCD frequency with Hz resolution.
* \param nFreq The new frequency in Hz.
* \param rFreq The actual frequency in Hz returned by the FCD (can be NULL).
* \return The FCD mode.
*
* This function sets the frequency of the FCD with 1 Hz resolution. The parameter
* nFreq must already contain any necessary frequency corrention. If rFreq is not NULL
* it will contain the actual frequency as returned by the API call.
*
* \sa fcdAppSetFreqKhz
*/
EXTERN FCD_API_EXPORT FCD_API_CALL FCD_MODE_ENUM fcdAppSetFreq(unsigned int uFreq, unsigned int *rFreq)
{
hid_device *phd=NULL;
unsigned char aucBufIn[65];
unsigned char aucBufOut[65];
phd = fcdOpen();
if (phd == NULL)
{
return FCD_MODE_NONE;
}
// Send an App reset command
aucBufOut[0] = 0; // Report ID. Ignored by HID Class firmware as only config'd for one report
aucBufOut[1] = FCD_CMD_APP_SET_FREQ_HZ;
aucBufOut[2] = (unsigned char) uFreq;
aucBufOut[3] = (unsigned char) (uFreq >> 8);
aucBufOut[4] = (unsigned char) (uFreq >> 16);
aucBufOut[5] = (unsigned char) (uFreq >> 24);
hid_write(phd, aucBufOut, 65);
memset(aucBufIn, 0xCC, 65); // Clear out the response buffer
hid_read(phd, aucBufIn, 65);
fcdClose(phd);
phd = NULL;
if (aucBufIn[0]==FCD_CMD_APP_SET_FREQ_HZ && aucBufIn[1]==1)
{
if (rFreq != NULL)
{
*rFreq = 0;
*rFreq = (unsigned int) aucBufIn[2];
*rFreq += (unsigned int) (aucBufIn[3] << 8);
*rFreq += (unsigned int) (aucBufIn[4] << 16);
*rFreq += (unsigned int) (aucBufIn[5] << 24);
}
return FCD_MODE_APP;
}
return FCD_MODE_BL;
}
/** \brief Get current FCD frequency with Hz resolution.
* \param rFreq The current frequency in Hz returned by the FCD.
* \return The FCD mode.
*
* This function reads the frequency of the FCD with 1 Hz resolution. The parameter
* nFreq must already contain any necessary frequency corrention.
*
* \sa fcdAppSetFreq
*/
EXTERN FCD_API_EXPORT FCD_API_CALL FCD_MODE_ENUM fcdAppGetFreq(unsigned int *rFreq)
{
hid_device *phd=NULL;
unsigned char aucBufIn[65];
unsigned char aucBufOut[65];
if (rFreq == NULL)
{
return FCD_MODE_NONE;
}
phd = fcdOpen();
if (phd == NULL)
{
return FCD_MODE_NONE;
}
aucBufOut[0] = 0; // Report ID. Ignored by HID Class firmware as only config'd for one report
aucBufOut[1] = FCD_CMD_APP_GET_FREQ_HZ;
hid_write(phd, aucBufOut, 65);
memset(aucBufIn, 0xCC, 65); // Clear out the response buffer
hid_read(phd, aucBufIn, 65);
fcdClose(phd);
phd = NULL;
if (aucBufIn[0]==FCD_CMD_APP_GET_FREQ_HZ && aucBufIn[1]==1)
{
*rFreq = 0;
*rFreq = (unsigned int) aucBufIn[2];
*rFreq += (unsigned int) (aucBufIn[3] << 8);
*rFreq += (unsigned int) (aucBufIn[4] << 16);
*rFreq += (unsigned int) (aucBufIn[5] << 24);
return FCD_MODE_APP;
}
return FCD_MODE_BL;
}
/** \brief Enable/disable LNA.
* \param enabled Whether to enable or disable the LNA (1=ON 0=OFF).
* \return The FCD mode.
*/
EXTERN FCD_API_EXPORT FCD_API_CALL FCD_MODE_ENUM fcdAppSetLna(char enabled)
{
hid_device *phd=NULL;
unsigned char aucBufIn[65];
unsigned char aucBufOut[65];
phd = fcdOpen();
if (phd == NULL)
{
return FCD_MODE_NONE;
}
aucBufOut[0] = 0; // Report ID. Ignored by HID Class firmware as only config'd for one report
aucBufOut[1] = FCD_CMD_APP_SET_LNA_GAIN;
aucBufOut[2] = (unsigned char) enabled;
hid_write(phd, aucBufOut, 65);
memset(aucBufIn, 0xCC, 65); // Clear out the response buffer
hid_read(phd, aucBufIn, 65);
fcdClose(phd);
phd = NULL;
return (aucBufIn[0] == FCD_CMD_APP_SET_LNA_GAIN) ? FCD_MODE_APP : FCD_MODE_BL;
}
/** \brief Get LNA status
* \param enabled The current staus of the LNA (1=ON 0=OFF).
* \return The FCD mode.
*/
EXTERN FCD_API_EXPORT FCD_API_CALL FCD_MODE_ENUM fcdAppGetLna(char *enabled)
{
hid_device *phd=NULL;
unsigned char aucBufIn[65];
unsigned char aucBufOut[65];
if (enabled == NULL)
return FCD_MODE_NONE;
phd = fcdOpen();
if (phd == NULL)
return FCD_MODE_NONE;
aucBufOut[0] = 0; // Report ID. Ignored by HID Class firmware as only config'd for one report
aucBufOut[1] = FCD_CMD_APP_GET_LNA_GAIN;
hid_write(phd, aucBufOut, 65);
memset(aucBufIn, 0xCC, 65); // Clear out the response buffer
hid_read(phd, aucBufIn, 65);
fcdClose(phd);
phd = NULL;
if (aucBufIn[0]==FCD_CMD_APP_GET_LNA_GAIN && aucBufIn[1]==1)
{
*enabled = aucBufIn[2];
return FCD_MODE_APP;
}
return FCD_MODE_BL;
}
/** \brief Select RF filter.
* \param filter The new RF filter.
* \return The FCD mode.
*
* \note RF filter is selected by the FCD; using this function may not be very useful, except when
* firmware selects wrong filter.
*/
EXTERN FCD_API_EXPORT FCD_API_CALL FCD_MODE_ENUM fcdAppSetRfFilter(tuner_rf_filter_t filter)
{
hid_device *phd=NULL;
unsigned char aucBufIn[65];
unsigned char aucBufOut[65];
if (filter > TRFE_875_2000)
{
return FCD_MODE_NONE;
}
phd = fcdOpen();
if (phd == NULL)
{
return FCD_MODE_NONE;
}
aucBufOut[0] = 0; // Report ID. Ignored by HID Class firmware as only config'd for one report
aucBufOut[1] = FCD_CMD_APP_SET_RF_FILTER;
aucBufOut[2] = (unsigned char) filter;
hid_write(phd, aucBufOut, 65);
memset(aucBufIn, 0xCC, 65); // Clear out the response buffer
hid_read(phd, aucBufIn, 65);
fcdClose(phd);
phd = NULL;
return (aucBufIn[0] == FCD_CMD_APP_SET_RF_FILTER) ? FCD_MODE_APP : FCD_MODE_BL;
}
/** \brief Get RF filter selection.
* \param filter The current RF filter selection.
* \return The FCD mode.
*/
EXTERN FCD_API_EXPORT FCD_API_CALL FCD_MODE_ENUM fcdAppGetRfFilter(tuner_rf_filter_t *filter)
{
hid_device *phd=NULL;
unsigned char aucBufIn[65];
unsigned char aucBufOut[65];
if (filter == NULL)
return FCD_MODE_NONE;
phd = fcdOpen();
if (phd == NULL)
return FCD_MODE_NONE;
aucBufOut[0] = 0; // Report ID. Ignored by HID Class firmware as only config'd for one report
aucBufOut[1] = FCD_CMD_APP_GET_RF_FILTER;
hid_write(phd, aucBufOut, 65);
memset(aucBufIn, 0xCC, 65); // Clear out the response buffer
hid_read(phd, aucBufIn, 65);
fcdClose(phd);
phd = NULL;
if (aucBufIn[0]==FCD_CMD_APP_GET_RF_FILTER && aucBufIn[1]==1)
{
*filter = (tuner_rf_filter_t) aucBufIn[2];
return FCD_MODE_APP;
}
return FCD_MODE_BL;
}
/** \brief Enable/disable Mixer gain.
* \param enabled Whether to enable or disable the mixer gain (1=ON 0=OFF).
* \return The FCD mode.
*/
EXTERN FCD_API_EXPORT FCD_API_CALL FCD_MODE_ENUM fcdAppSetMixerGain(char enabled)
{
hid_device *phd=NULL;
unsigned char aucBufIn[65];
unsigned char aucBufOut[65];
phd = fcdOpen();
if (phd == NULL)
{
return FCD_MODE_NONE;
}
aucBufOut[0] = 0; // Report ID. Ignored by HID Class firmware as only config'd for one report
aucBufOut[1] = FCD_CMD_APP_SET_MIXER_GAIN;
aucBufOut[2] = (unsigned char) enabled;
hid_write(phd, aucBufOut, 65);
memset(aucBufIn, 0xCC, 65); // Clear out the response buffer
hid_read(phd, aucBufIn, 65);
fcdClose(phd);
phd = NULL;
return (aucBufIn[0] == FCD_CMD_APP_SET_MIXER_GAIN) ? FCD_MODE_APP : FCD_MODE_BL;
}
/** \brief Get mixer gain status
* \param enabled The current staus of the mixer gain (1=ON 0=OFF).
* \return The FCD mode.
*/
EXTERN FCD_API_EXPORT FCD_API_CALL FCD_MODE_ENUM fcdAppGetMixerGain(char *enabled)
{
hid_device *phd=NULL;
unsigned char aucBufIn[65];
unsigned char aucBufOut[65];
if (enabled == NULL)
return FCD_MODE_NONE;
phd = fcdOpen();
if (phd == NULL)
return FCD_MODE_NONE;
aucBufOut[0] = 0; // Report ID. Ignored by HID Class firmware as only config'd for one report
aucBufOut[1] = FCD_CMD_APP_GET_MIXER_GAIN;
hid_write(phd, aucBufOut, 65);
memset(aucBufIn, 0xCC, 65); // Clear out the response buffer
hid_read(phd, aucBufIn, 65);
fcdClose(phd);
phd = NULL;
if (aucBufIn[0]==FCD_CMD_APP_GET_MIXER_GAIN && aucBufIn[1]==1)
{
*enabled = aucBufIn[2];
return FCD_MODE_APP;
}
return FCD_MODE_BL;
}
/** \brief Set IF gain.
* \param gain The new IF gain between 0 and 59 dB.
* \return The FCD mode.
*/
EXTERN FCD_API_EXPORT FCD_API_CALL FCD_MODE_ENUM fcdAppSetIfGain(unsigned char gain)
{
hid_device *phd=NULL;
unsigned char aucBufIn[65];
unsigned char aucBufOut[65];
if (gain > 59)
{
return FCD_MODE_NONE;
}
phd = fcdOpen();
if (phd == NULL)
{
return FCD_MODE_NONE;
}
aucBufOut[0] = 0; // Report ID. Ignored by HID Class firmware as only config'd for one report
aucBufOut[1] = FCD_CMD_APP_SET_IF_GAIN;
aucBufOut[2] = gain;
hid_write(phd, aucBufOut, 65);
memset(aucBufIn, 0xCC, 65); // Clear out the response buffer
hid_read(phd, aucBufIn, 65);
fcdClose(phd);
phd = NULL;
return (aucBufIn[0] == FCD_CMD_APP_SET_IF_GAIN) ? FCD_MODE_APP : FCD_MODE_BL;
}
/** \brief Get IF gain.
* \param filter The current IF gain between 0 and 59 dB.
* \return The FCD mode.
*/
EXTERN FCD_API_EXPORT FCD_API_CALL FCD_MODE_ENUM fcdAppGetIfGain(unsigned char *gain)
{
hid_device *phd=NULL;
unsigned char aucBufIn[65];
unsigned char aucBufOut[65];
if (gain == NULL)
return FCD_MODE_NONE;
phd = fcdOpen();
if (phd == NULL)
return FCD_MODE_NONE;
aucBufOut[0] = 0; // Report ID. Ignored by HID Class firmware as only config'd for one report
aucBufOut[1] = FCD_CMD_APP_GET_IF_GAIN;
hid_write(phd, aucBufOut, 65);
memset(aucBufIn, 0xCC, 65); // Clear out the response buffer
hid_read(phd, aucBufIn, 65);
fcdClose(phd);
phd = NULL;
if (aucBufIn[0]==FCD_CMD_APP_GET_IF_GAIN && aucBufIn[1]==1)
{
*gain = aucBufIn[2];
return FCD_MODE_APP;
}
return FCD_MODE_BL;
}
/** \brief Select IF filter.
* \param filter The new IF filter.
* \return The FCD mode.
*
* \note IF filter is selected by the FCD; using this function may not be very useful, except when
* firmware selects the wrong filter.
*/
EXTERN FCD_API_EXPORT FCD_API_CALL FCD_MODE_ENUM fcdAppSetIfFilter(tuner_if_filter_t filter)
{
hid_device *phd=NULL;
unsigned char aucBufIn[65];
unsigned char aucBufOut[65];
if (filter > TIFE_8MHZ)
{
return FCD_MODE_NONE;
}
phd = fcdOpen();
if (phd == NULL)
{
return FCD_MODE_NONE;
}
aucBufOut[0] = 0; // Report ID. Ignored by HID Class firmware as only config'd for one report
aucBufOut[1] = FCD_CMD_APP_SET_IF_FILTER;
aucBufOut[2] = (unsigned char) filter;
hid_write(phd, aucBufOut, 65);
memset(aucBufIn, 0xCC, 65); // Clear out the response buffer
hid_read(phd, aucBufIn, 65);
fcdClose(phd);
phd = NULL;
return (aucBufIn[0] == FCD_CMD_APP_SET_IF_FILTER) ? FCD_MODE_APP : FCD_MODE_BL;
}
/** \brief Get IF filter selection.
* \param filter The current IF filter selection.
* \return The FCD mode.
*/
EXTERN FCD_API_EXPORT FCD_API_CALL FCD_MODE_ENUM fcdAppGetIfFilter(tuner_if_filter_t *filter)
{
hid_device *phd=NULL;
unsigned char aucBufIn[65];
unsigned char aucBufOut[65];
if (filter == NULL)
return FCD_MODE_NONE;
phd = fcdOpen();
if (phd == NULL)
return FCD_MODE_NONE;
aucBufOut[0] = 0; // Report ID. Ignored by HID Class firmware as only config'd for one report
aucBufOut[1] = FCD_CMD_APP_GET_IF_FILTER;
hid_write(phd, aucBufOut, 65);
memset(aucBufIn, 0xCC, 65); // Clear out the response buffer
hid_read(phd, aucBufIn, 65);
fcdClose(phd);
phd = NULL;
if (aucBufIn[0]==FCD_CMD_APP_GET_IF_FILTER && aucBufIn[1]==1)
{
*filter = (tuner_if_filter_t) aucBufIn[2];
return FCD_MODE_APP;
}
return FCD_MODE_BL;
}
/** \brief Enable/disable Bias T.
* \param enabled Whether to enable or disable the Bias T (1=ON 0=OFF).
* \return The FCD mode.
*/
EXTERN FCD_API_EXPORT FCD_API_CALL FCD_MODE_ENUM fcdAppSetBiasTee(char enabled)
{
hid_device *phd=NULL;
unsigned char aucBufIn[65];
unsigned char aucBufOut[65];
phd = fcdOpen();
if (phd == NULL)
{
return FCD_MODE_NONE;
}
aucBufOut[0] = 0; // Report ID. Ignored by HID Class firmware as only config'd for one report
aucBufOut[1] = FCD_CMD_APP_SET_BIAS_TEE;
aucBufOut[2] = (unsigned char) enabled;
hid_write(phd, aucBufOut, 65);
memset(aucBufIn, 0xCC, 65); // Clear out the response buffer
hid_read(phd, aucBufIn, 65);
fcdClose(phd);
phd = NULL;
return (aucBufIn[0] == FCD_CMD_APP_SET_BIAS_TEE) ? FCD_MODE_APP : FCD_MODE_BL;
}
/** \brief Get Bias T status
* \param enabled The current staus of the Bias T (1=ON 0=OFF).
* \return The FCD mode.
*/
EXTERN FCD_API_EXPORT FCD_API_CALL FCD_MODE_ENUM fcdAppGetBiasTee(char *enabled)
{
hid_device *phd=NULL;
unsigned char aucBufIn[65];
unsigned char aucBufOut[65];
if (enabled == NULL)
return FCD_MODE_NONE;
phd = fcdOpen();
if (phd == NULL)
return FCD_MODE_NONE;
aucBufOut[0] = 0; // Report ID. Ignored by HID Class firmware as only config'd for one report
aucBufOut[1] = FCD_CMD_APP_GET_BIAS_TEE;
hid_write(phd, aucBufOut, 65);
memset(aucBufIn, 0xCC, 65); // Clear out the response buffer
hid_read(phd, aucBufIn, 65);
fcdClose(phd);
phd = NULL;
if (aucBufIn[0]==FCD_CMD_APP_GET_BIAS_TEE && aucBufIn[1]==1)
{
*enabled = aucBufIn[2];
return FCD_MODE_APP;
}
return FCD_MODE_BL;
}
qthid-4.1-source/qthid.qrc 0000644 0001750 0001750 00000000613 12051012642 013656 0 ustar alc alc
images/qthid.png
images/rfchain.png
images/help.png
images/save.png
images/open.png
images/fw.png
images/iq.png
images/quit.png
images/info.png
qthid-4.1-source/fcd.h 0000644 0001750 0001750 00000006307 12051012677 012761 0 ustar alc alc /***************************************************************************
* This file is part of Qthid.
*
* Copyright (C) 2010 Howard Long, G6LVB
* Copyright (C) 2011 Mario Lorenz, DL5MLO
* Copyright (C) 2011-2012 Alexandru Csete, OZ9AEC
*
* Qthid is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Qthid is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Qthid. If not, see .
*
***************************************************************************/
#ifndef FCD_H
#define FCD_H 1
#ifdef FCD
#define EXTERN
#define ASSIGN(x) =x
#else
#define EXTERN extern
#define ASSIGN(x)
#endif
#ifdef _WIN32
#define FCD_API_EXPORT __declspec(dllexport)
#define FCD_API_CALL _stdcall
#else
#define FCD_API_EXPORT
#define FCD_API_CALL
#endif
#include
#include "fcdhidcmd.h"
/** \brief FCD mode enumeration. */
typedef enum {
FCD_MODE_NONE, /*!< No FCD detected. */
FCD_MODE_BL, /*!< FCD present in bootloader mode. */
FCD_MODE_APP /*!< FCD present in application mode. */
} FCD_MODE_ENUM; // The current mode of the FCD: no FCD, in bootloader mode or in normal application mode
#ifdef __cplusplus
extern "C" {
#endif
/* Application functions */
EXTERN FCD_API_EXPORT FCD_API_CALL FCD_MODE_ENUM fcdGetMode(void);
EXTERN FCD_API_EXPORT FCD_API_CALL FCD_MODE_ENUM fcdGetFwVerStr(char *str);
EXTERN FCD_API_EXPORT FCD_API_CALL FCD_MODE_ENUM fcdAppReset(void);
EXTERN FCD_API_EXPORT FCD_API_CALL FCD_MODE_ENUM fcdAppSetFreqKhz(int nFreq);
EXTERN FCD_API_EXPORT FCD_API_CALL FCD_MODE_ENUM fcdAppSetFreq(unsigned int uFreq, unsigned int *rFreq);
EXTERN FCD_API_EXPORT FCD_API_CALL FCD_MODE_ENUM fcdAppGetFreq(unsigned int *rFreq);
EXTERN FCD_API_EXPORT FCD_API_CALL FCD_MODE_ENUM fcdAppSetLna(char enabled);
EXTERN FCD_API_EXPORT FCD_API_CALL FCD_MODE_ENUM fcdAppGetLna(char *enabled);
EXTERN FCD_API_EXPORT FCD_API_CALL FCD_MODE_ENUM fcdAppSetRfFilter(tuner_rf_filter_t filter);
EXTERN FCD_API_EXPORT FCD_API_CALL FCD_MODE_ENUM fcdAppGetRfFilter(tuner_rf_filter_t *filter);
EXTERN FCD_API_EXPORT FCD_API_CALL FCD_MODE_ENUM fcdAppSetMixerGain(char enabled);
EXTERN FCD_API_EXPORT FCD_API_CALL FCD_MODE_ENUM fcdAppGetMixerGain(char *enabled);
EXTERN FCD_API_EXPORT FCD_API_CALL FCD_MODE_ENUM fcdAppSetIfGain(unsigned char gain);
EXTERN FCD_API_EXPORT FCD_API_CALL FCD_MODE_ENUM fcdAppGetIfGain(unsigned char *gain);
EXTERN FCD_API_EXPORT FCD_API_CALL FCD_MODE_ENUM fcdAppSetIfFilter(tuner_if_filter_t filter);
EXTERN FCD_API_EXPORT FCD_API_CALL FCD_MODE_ENUM fcdAppGetIfFilter(tuner_if_filter_t *filter);
EXTERN FCD_API_EXPORT FCD_API_CALL FCD_MODE_ENUM fcdAppSetBiasTee(char enabled);
EXTERN FCD_API_EXPORT FCD_API_CALL FCD_MODE_ENUM fcdAppGetBiasTee(char *enabled);
#ifdef __cplusplus
}
#endif
#endif // FCD_H
qthid-4.1-source/hidmac.c 0000644 0001750 0001750 00000066674 12051012677 013462 0 ustar alc alc /*******************************************************
HIDAPI - Multi-Platform library for
communication with HID devices.
Alan Ott
Signal 11 Software
2010-07-03
Copyright 2010, All Rights Reserved.
At the discretion of the user of this library,
this software may be licensed under the terms of the
GNU Public License v3, a BSD-Style license, or the
original HIDAPI license as outlined in the LICENSE.txt,
LICENSE-gpl3.txt, LICENSE-bsd.txt, and LICENSE-orig.txt
files located at the root of the source distribution.
These files may also be found in the public source
code repository located at:
http://github.com/signal11/hidapi .
********************************************************/
/* See Apple Technical Note TN2187 for details on IOHidManager. */
#include
#include
#include
#include
#include
#include
#include
#include
#include "hidapi.h"
/* Barrier implementation because Mac OSX doesn't have pthread_barrier.
It also doesn't have clock_gettime(). So much for POSIX and SUSv2.
This implementation came from Brent Priddy and was posted on
StackOverflow. It is used with his permission. */
typedef int pthread_barrierattr_t;
typedef struct pthread_barrier {
pthread_mutex_t mutex;
pthread_cond_t cond;
int count;
int trip_count;
} pthread_barrier_t;
static int pthread_barrier_init(pthread_barrier_t *barrier, const pthread_barrierattr_t *attr, unsigned int count)
{
if(count == 0) {
errno = EINVAL;
return -1;
}
if(pthread_mutex_init(&barrier->mutex, 0) < 0) {
return -1;
}
if(pthread_cond_init(&barrier->cond, 0) < 0) {
pthread_mutex_destroy(&barrier->mutex);
return -1;
}
barrier->trip_count = count;
barrier->count = 0;
return 0;
}
static int pthread_barrier_destroy(pthread_barrier_t *barrier)
{
pthread_cond_destroy(&barrier->cond);
pthread_mutex_destroy(&barrier->mutex);
return 0;
}
static int pthread_barrier_wait(pthread_barrier_t *barrier)
{
pthread_mutex_lock(&barrier->mutex);
++(barrier->count);
if(barrier->count >= barrier->trip_count)
{
barrier->count = 0;
pthread_cond_broadcast(&barrier->cond);
pthread_mutex_unlock(&barrier->mutex);
return 1;
}
else
{
pthread_cond_wait(&barrier->cond, &(barrier->mutex));
pthread_mutex_unlock(&barrier->mutex);
return 0;
}
}
static int return_data(hid_device *dev, unsigned char *data, size_t length);
/* Linked List of input reports received from the device. */
struct input_report {
uint8_t *data;
size_t len;
struct input_report *next;
};
struct hid_device_ {
IOHIDDeviceRef device_handle;
int blocking;
int uses_numbered_reports;
int disconnected;
CFStringRef run_loop_mode;
CFRunLoopRef run_loop;
CFRunLoopSourceRef source;
uint8_t *input_report_buf;
CFIndex max_input_report_len;
struct input_report *input_reports;
pthread_t thread;
pthread_mutex_t mutex; /* Protects input_reports */
pthread_cond_t condition;
pthread_barrier_t barrier; /* Ensures correct startup sequence */
pthread_barrier_t shutdown_barrier; /* Ensures correct shutdown sequence */
int shutdown_thread;
};
static hid_device *new_hid_device(void)
{
hid_device *dev = calloc(1, sizeof(hid_device));
dev->device_handle = NULL;
dev->blocking = 1;
dev->uses_numbered_reports = 0;
dev->disconnected = 0;
dev->run_loop_mode = NULL;
dev->run_loop = NULL;
dev->source = NULL;
dev->input_report_buf = NULL;
dev->input_reports = NULL;
dev->shutdown_thread = 0;
/* Thread objects */
pthread_mutex_init(&dev->mutex, NULL);
pthread_cond_init(&dev->condition, NULL);
pthread_barrier_init(&dev->barrier, NULL, 2);
pthread_barrier_init(&dev->shutdown_barrier, NULL, 2);
return dev;
}
static void free_hid_device(hid_device *dev)
{
if (!dev)
return;
/* Delete any input reports still left over. */
struct input_report *rpt = dev->input_reports;
while (rpt) {
struct input_report *next = rpt->next;
free(rpt->data);
free(rpt);
rpt = next;
}
/* Free the string and the report buffer. The check for NULL
is necessary here as CFRelease() doesn't handle NULL like
free() and others do. */
if (dev->run_loop_mode)
CFRelease(dev->run_loop_mode);
if (dev->source)
CFRelease(dev->source);
free(dev->input_report_buf);
/* Clean up the thread objects */
pthread_barrier_destroy(&dev->shutdown_barrier);
pthread_barrier_destroy(&dev->barrier);
pthread_cond_destroy(&dev->condition);
pthread_mutex_destroy(&dev->mutex);
/* Free the structure itself. */
free(dev);
}
static IOHIDManagerRef hid_mgr = 0x0;
#if 0
static void register_error(hid_device *device, const char *op)
{
}
#endif
static int32_t get_int_property(IOHIDDeviceRef device, CFStringRef key)
{
CFTypeRef ref;
int32_t value;
ref = IOHIDDeviceGetProperty(device, key);
if (ref) {
if (CFGetTypeID(ref) == CFNumberGetTypeID()) {
CFNumberGetValue((CFNumberRef) ref, kCFNumberSInt32Type, &value);
return value;
}
}
return 0;
}
static unsigned short get_vendor_id(IOHIDDeviceRef device)
{
return get_int_property(device, CFSTR(kIOHIDVendorIDKey));
}
static unsigned short get_product_id(IOHIDDeviceRef device)
{
return get_int_property(device, CFSTR(kIOHIDProductIDKey));
}
static int32_t get_max_report_length(IOHIDDeviceRef device)
{
return get_int_property(device, CFSTR(kIOHIDMaxInputReportSizeKey));
}
static int get_string_property(IOHIDDeviceRef device, CFStringRef prop, wchar_t *buf, size_t len)
{
CFStringRef str;
if (!len)
return 0;
str = IOHIDDeviceGetProperty(device, prop);
buf[0] = 0;
if (str) {
len --;
CFIndex str_len = CFStringGetLength(str);
CFRange range;
range.location = 0;
range.length = (str_len > len)? len: str_len;
CFIndex used_buf_len;
CFIndex chars_copied;
chars_copied = CFStringGetBytes(str,
range,
kCFStringEncodingUTF32LE,
(char)'?',
FALSE,
(UInt8*)buf,
len,
&used_buf_len);
buf[chars_copied] = 0;
return 0;
}
else
return -1;
}
static int get_string_property_utf8(IOHIDDeviceRef device, CFStringRef prop, char *buf, size_t len)
{
CFStringRef str;
if (!len)
return 0;
str = IOHIDDeviceGetProperty(device, prop);
buf[0] = 0;
if (str) {
len--;
CFIndex str_len = CFStringGetLength(str);
CFRange range;
range.location = 0;
range.length = (str_len > len)? len: str_len;
CFIndex used_buf_len;
CFIndex chars_copied;
chars_copied = CFStringGetBytes(str,
range,
kCFStringEncodingUTF8,
(char)'?',
FALSE,
(UInt8*)buf,
len,
&used_buf_len);
buf[chars_copied] = 0;
return used_buf_len;
}
else
return 0;
}
static int get_serial_number(IOHIDDeviceRef device, wchar_t *buf, size_t len)
{
return get_string_property(device, CFSTR(kIOHIDSerialNumberKey), buf, len);
}
static int get_manufacturer_string(IOHIDDeviceRef device, wchar_t *buf, size_t len)
{
return get_string_property(device, CFSTR(kIOHIDManufacturerKey), buf, len);
}
static int get_product_string(IOHIDDeviceRef device, wchar_t *buf, size_t len)
{
return get_string_property(device, CFSTR(kIOHIDProductKey), buf, len);
}
/* Implementation of wcsdup() for Mac. */
static wchar_t *dup_wcs(const wchar_t *s)
{
size_t len = wcslen(s);
wchar_t *ret = malloc((len+1)*sizeof(wchar_t));
wcscpy(ret, s);
return ret;
}
static int make_path(IOHIDDeviceRef device, char *buf, size_t len)
{
int res;
unsigned short vid, pid;
char transport[32];
buf[0] = '\0';
res = get_string_property_utf8(
device, CFSTR(kIOHIDTransportKey),
transport, sizeof(transport));
if (!res)
return -1;
vid = get_vendor_id(device);
pid = get_product_id(device);
res = snprintf(buf, len, "%s_%04hx_%04hx_%p",
transport, vid, pid, device);
buf[len-1] = '\0';
return res+1;
}
/* Initialize the IOHIDManager. Return 0 for success and -1 for failure. */
static int init_hid_manager(void)
{
/* Initialize all the HID Manager Objects */
hid_mgr = IOHIDManagerCreate(kCFAllocatorDefault, kIOHIDOptionsTypeNone);
if (hid_mgr) {
IOHIDManagerSetDeviceMatching(hid_mgr, NULL);
IOHIDManagerScheduleWithRunLoop(hid_mgr, CFRunLoopGetCurrent(), kCFRunLoopDefaultMode);
return 0;
}
return -1;
}
/* Initialize the IOHIDManager if necessary. This is the public function, and
it is safe to call this function repeatedly. Return 0 for success and -1
for failure. */
int HID_API_EXPORT hid_init(void)
{
if (!hid_mgr) {
return init_hid_manager();
}
/* Already initialized. */
return 0;
}
int HID_API_EXPORT hid_exit(void)
{
if (hid_mgr) {
/* Close the HID manager. */
IOHIDManagerClose(hid_mgr, kIOHIDOptionsTypeNone);
CFRelease(hid_mgr);
hid_mgr = NULL;
}
return 0;
}
static void process_pending_events(void) {
SInt32 res;
do {
res = CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.001, FALSE);
} while(res != kCFRunLoopRunFinished && res != kCFRunLoopRunTimedOut);
}
struct hid_device_info HID_API_EXPORT *hid_enumerate(unsigned short vendor_id, unsigned short product_id)
{
struct hid_device_info *root = NULL; // return object
struct hid_device_info *cur_dev = NULL;
CFIndex num_devices;
int i;
/* Set up the HID Manager if it hasn't been done */
if (hid_init() < 0)
return NULL;
/* give the IOHIDManager a chance to update itself */
process_pending_events();
/* Get a list of the Devices */
CFSetRef device_set = IOHIDManagerCopyDevices(hid_mgr);
/* Convert the list into a C array so we can iterate easily. */
num_devices = CFSetGetCount(device_set);
IOHIDDeviceRef *device_array = calloc(num_devices, sizeof(IOHIDDeviceRef));
CFSetGetValues(device_set, (const void **) device_array);
/* Iterate over each device, making an entry for it. */
for (i = 0; i < num_devices; i++) {
unsigned short dev_vid;
unsigned short dev_pid;
#define BUF_LEN 256
wchar_t buf[BUF_LEN];
char cbuf[BUF_LEN];
IOHIDDeviceRef dev = device_array[i];
if (!dev) {
continue;
}
dev_vid = get_vendor_id(dev);
dev_pid = get_product_id(dev);
/* Check the VID/PID against the arguments */
if ((vendor_id == 0x0 && product_id == 0x0) ||
(vendor_id == dev_vid && product_id == dev_pid)) {
struct hid_device_info *tmp;
size_t len;
/* VID/PID match. Create the record. */
tmp = malloc(sizeof(struct hid_device_info));
if (cur_dev) {
cur_dev->next = tmp;
}
else {
root = tmp;
}
cur_dev = tmp;
// Get the Usage Page and Usage for this device.
cur_dev->usage_page = get_int_property(dev, CFSTR(kIOHIDPrimaryUsagePageKey));
cur_dev->usage = get_int_property(dev, CFSTR(kIOHIDPrimaryUsageKey));
/* Fill out the record */
cur_dev->next = NULL;
len = make_path(dev, cbuf, sizeof(cbuf));
cur_dev->path = strdup(cbuf);
/* Serial Number */
get_serial_number(dev, buf, BUF_LEN);
cur_dev->serial_number = dup_wcs(buf);
/* Manufacturer and Product strings */
get_manufacturer_string(dev, buf, BUF_LEN);
cur_dev->manufacturer_string = dup_wcs(buf);
get_product_string(dev, buf, BUF_LEN);
cur_dev->product_string = dup_wcs(buf);
/* VID/PID */
cur_dev->vendor_id = dev_vid;
cur_dev->product_id = dev_pid;
/* Release Number */
cur_dev->release_number = get_int_property(dev, CFSTR(kIOHIDVersionNumberKey));
/* Interface Number (Unsupported on Mac)*/
cur_dev->interface_number = -1;
}
}
free(device_array);
CFRelease(device_set);
return root;
}
void HID_API_EXPORT hid_free_enumeration(struct hid_device_info *devs)
{
/* This function is identical to the Linux version. Platform independent. */
struct hid_device_info *d = devs;
while (d) {
struct hid_device_info *next = d->next;
free(d->path);
free(d->serial_number);
free(d->manufacturer_string);
free(d->product_string);
free(d);
d = next;
}
}
hid_device * HID_API_EXPORT hid_open(unsigned short vendor_id, unsigned short product_id, const wchar_t *serial_number)
{
/* 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) {
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;
}
static void hid_device_removal_callback(void *context, IOReturn result,
void *sender)
{
/* Stop the Run Loop for this device. */
hid_device *d = context;
d->disconnected = 1;
CFRunLoopStop(d->run_loop);
}
/* The Run Loop calls this function for each input report received.
This function puts the data into a linked list to be picked up by
hid_read(). */
static void hid_report_callback(void *context, IOReturn result, void *sender,
IOHIDReportType report_type, uint32_t report_id,
uint8_t *report, CFIndex report_length)
{
struct input_report *rpt;
hid_device *dev = context;
/* Make a new Input Report object */
rpt = calloc(1, sizeof(struct input_report));
rpt->data = calloc(1, report_length);
memcpy(rpt->data, report, report_length);
rpt->len = report_length;
rpt->next = NULL;
/* Lock this section */
pthread_mutex_lock(&dev->mutex);
/* Attach the new report object to the end of the list. */
if (dev->input_reports == NULL) {
/* The list is empty. Put it at the root. */
dev->input_reports = rpt;
}
else {
/* Find the end of the list and attach. */
struct input_report *cur = dev->input_reports;
int num_queued = 0;
while (cur->next != NULL) {
cur = cur->next;
num_queued++;
}
cur->next = rpt;
/* Pop one off if we've reached 30 in the queue. This
way we don't grow forever if the user never reads
anything from the device. */
if (num_queued > 30) {
return_data(dev, NULL, 0);
}
}
/* Signal a waiting thread that there is data. */
pthread_cond_signal(&dev->condition);
/* Unlock */
pthread_mutex_unlock(&dev->mutex);
}
/* This gets called when the read_thred's run loop gets signaled by
hid_close(), and serves to stop the read_thread's run loop. */
static void perform_signal_callback(void *context)
{
hid_device *dev = context;
CFRunLoopStop(dev->run_loop); //TODO: CFRunLoopGetCurrent()
}
static void *read_thread(void *param)
{
hid_device *dev = param;
/* Move the device's run loop to this thread. */
IOHIDDeviceScheduleWithRunLoop(dev->device_handle, CFRunLoopGetCurrent(), dev->run_loop_mode);
/* Create the RunLoopSource which is used to signal the
event loop to stop when hid_close() is called. */
CFRunLoopSourceContext ctx;
memset(&ctx, 0, sizeof(ctx));
ctx.version = 0;
ctx.info = dev;
ctx.perform = &perform_signal_callback;
dev->source = CFRunLoopSourceCreate(kCFAllocatorDefault, 0/*order*/, &ctx);
CFRunLoopAddSource(CFRunLoopGetCurrent(), dev->source, dev->run_loop_mode);
/* Store off the Run Loop so it can be stopped from hid_close()
and on device disconnection. */
dev->run_loop = CFRunLoopGetCurrent();
/* Notify the main thread that the read thread is up and running. */
pthread_barrier_wait(&dev->barrier);
/* Run the Event Loop. CFRunLoopRunInMode() will dispatch HID input
reports into the hid_report_callback(). */
SInt32 code;
while (!dev->shutdown_thread && !dev->disconnected) {
code = CFRunLoopRunInMode(dev->run_loop_mode, 1000/*sec*/, FALSE);
/* Return if the device has been disconnected */
if (code == kCFRunLoopRunFinished) {
dev->disconnected = 1;
break;
}
/* Break if The Run Loop returns Finished or Stopped. */
if (code != kCFRunLoopRunTimedOut &&
code != kCFRunLoopRunHandledSource) {
/* There was some kind of error. Setting
shutdown seems to make sense, but
there may be something else more appropriate */
dev->shutdown_thread = 1;
break;
}
}
/* Now that the read thread is stopping, Wake any threads which are
waiting on data (in hid_read_timeout()). Do this under a mutex to
make sure that a thread which is about to go to sleep waiting on
the condition acutally will go to sleep before the condition is
signaled. */
pthread_mutex_lock(&dev->mutex);
pthread_cond_broadcast(&dev->condition);
pthread_mutex_unlock(&dev->mutex);
/* Wait here until hid_close() is called and makes it past
the call to CFRunLoopWakeUp(). This thread still needs to
be valid when that function is called on the other thread. */
pthread_barrier_wait(&dev->shutdown_barrier);
return NULL;
}
hid_device * HID_API_EXPORT hid_open_path(const char *path)
{
int i;
hid_device *dev = NULL;
CFIndex num_devices;
dev = new_hid_device();
/* Set up the HID Manager if it hasn't been done */
if (hid_init() < 0)
return NULL;
/* give the IOHIDManager a chance to update itself */
process_pending_events();
CFSetRef device_set = IOHIDManagerCopyDevices(hid_mgr);
num_devices = CFSetGetCount(device_set);
IOHIDDeviceRef *device_array = calloc(num_devices, sizeof(IOHIDDeviceRef));
CFSetGetValues(device_set, (const void **) device_array);
for (i = 0; i < num_devices; i++) {
char cbuf[BUF_LEN];
size_t len;
IOHIDDeviceRef os_dev = device_array[i];
len = make_path(os_dev, cbuf, sizeof(cbuf));
if (!strcmp(cbuf, path)) {
// Matched Paths. Open this Device.
IOReturn ret = IOHIDDeviceOpen(os_dev, kIOHIDOptionsTypeNone);
if (ret == kIOReturnSuccess) {
char str[32];
free(device_array);
CFRetain(os_dev);
CFRelease(device_set);
dev->device_handle = os_dev;
/* Create the buffers for receiving data */
dev->max_input_report_len = (CFIndex) get_max_report_length(os_dev);
dev->input_report_buf = calloc(dev->max_input_report_len, sizeof(uint8_t));
/* Create the Run Loop Mode for this device.
printing the reference seems to work. */
sprintf(str, "HIDAPI_%p", os_dev);
dev->run_loop_mode =
CFStringCreateWithCString(NULL, str, kCFStringEncodingASCII);
/* Attach the device to a Run Loop */
IOHIDDeviceRegisterInputReportCallback(
os_dev, dev->input_report_buf, dev->max_input_report_len,
&hid_report_callback, dev);
IOHIDDeviceRegisterRemovalCallback(dev->device_handle, hid_device_removal_callback, dev);
/* Start the read thread */
pthread_create(&dev->thread, NULL, read_thread, dev);
/* Wait here for the read thread to be initialized. */
pthread_barrier_wait(&dev->barrier);
return dev;
}
else {
goto return_error;
}
}
}
return_error:
free(device_array);
CFRelease(device_set);
free_hid_device(dev);
return NULL;
}
static int set_report(hid_device *dev, IOHIDReportType type, const unsigned char *data, size_t length)
{
const unsigned char *data_to_send;
size_t length_to_send;
IOReturn res;
/* Return if the device has been disconnected. */
if (dev->disconnected)
return -1;
if (data[0] == 0x0) {
/* Not using numbered Reports.
Don't send the report number. */
data_to_send = data+1;
length_to_send = length-1;
}
else {
/* Using numbered Reports.
Send the Report Number */
data_to_send = data;
length_to_send = length;
}
if (!dev->disconnected) {
res = IOHIDDeviceSetReport(dev->device_handle,
type,
data[0], /* Report ID*/
data_to_send, length_to_send);
if (res == kIOReturnSuccess) {
return length;
}
else
return -1;
}
return -1;
}
int HID_API_EXPORT hid_write(hid_device *dev, const unsigned char *data, size_t length)
{
return set_report(dev, kIOHIDReportTypeOutput, data, length);
}
/* Helper function, so that this isn't duplicated in hid_read(). */
static int return_data(hid_device *dev, unsigned char *data, size_t length)
{
/* Copy the data out of the linked list item (rpt) into the
return buffer (data), and delete the liked list item. */
struct input_report *rpt = dev->input_reports;
size_t len = (length < rpt->len)? length: rpt->len;
memcpy(data, rpt->data, len);
dev->input_reports = rpt->next;
free(rpt->data);
free(rpt);
return len;
}
static int cond_wait(const hid_device *dev, pthread_cond_t *cond, pthread_mutex_t *mutex)
{
while (!dev->input_reports) {
int res = pthread_cond_wait(cond, mutex);
if (res != 0)
return res;
/* A res of 0 means we may have been signaled or it may
be a spurious wakeup. Check to see that there's acutally
data in the queue before returning, and if not, go back
to sleep. See the pthread_cond_timedwait() man page for
details. */
if (dev->shutdown_thread || dev->disconnected)
return -1;
}
return 0;
}
static int cond_timedwait(const hid_device *dev, pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime)
{
while (!dev->input_reports) {
int res = pthread_cond_timedwait(cond, mutex, abstime);
if (res != 0)
return res;
/* A res of 0 means we may have been signaled or it may
be a spurious wakeup. Check to see that there's acutally
data in the queue before returning, and if not, go back
to sleep. See the pthread_cond_timedwait() man page for
details. */
if (dev->shutdown_thread || dev->disconnected)
return -1;
}
return 0;
}
int HID_API_EXPORT hid_read_timeout(hid_device *dev, unsigned char *data, size_t length, int milliseconds)
{
int bytes_read = -1;
/* Lock the access to the report list. */
pthread_mutex_lock(&dev->mutex);
/* There's an input report queued up. Return it. */
if (dev->input_reports) {
/* Return the first one */
bytes_read = return_data(dev, data, length);
goto ret;
}
/* Return if the device has been disconnected. */
if (dev->disconnected) {
bytes_read = -1;
goto ret;
}
if (dev->shutdown_thread) {
/* This means the device has been closed (or there
has been an error. An error code of -1 should
be returned. */
bytes_read = -1;
goto ret;
}
/* There is no data. Go to sleep and wait for data. */
if (milliseconds == -1) {
/* Blocking */
int res;
res = cond_wait(dev, &dev->condition, &dev->mutex);
if (res == 0)
bytes_read = return_data(dev, data, length);
else {
/* There was an error, or a device disconnection. */
bytes_read = -1;
}
}
else if (milliseconds > 0) {
/* Non-blocking, but called with timeout. */
int res;
struct timespec ts;
struct timeval tv;
gettimeofday(&tv, NULL);
TIMEVAL_TO_TIMESPEC(&tv, &ts);
ts.tv_sec += milliseconds / 1000;
ts.tv_nsec += (milliseconds % 1000) * 1000000;
if (ts.tv_nsec >= 1000000000L) {
ts.tv_sec++;
ts.tv_nsec -= 1000000000L;
}
res = cond_timedwait(dev, &dev->condition, &dev->mutex, &ts);
if (res == 0)
bytes_read = return_data(dev, data, length);
else if (res == ETIMEDOUT)
bytes_read = 0;
else
bytes_read = -1;
}
else {
/* Purely non-blocking */
bytes_read = 0;
}
ret:
/* Unlock */
pthread_mutex_unlock(&dev->mutex);
return bytes_read;
}
int HID_API_EXPORT hid_read(hid_device *dev, unsigned char *data, size_t length)
{
return hid_read_timeout(dev, data, length, (dev->blocking)? -1: 0);
}
int HID_API_EXPORT hid_set_nonblocking(hid_device *dev, int nonblock)
{
/* All Nonblocking operation is handled by the library. */
dev->blocking = !nonblock;
return 0;
}
int HID_API_EXPORT hid_send_feature_report(hid_device *dev, const unsigned char *data, size_t length)
{
return set_report(dev, kIOHIDReportTypeFeature, data, length);
}
int HID_API_EXPORT hid_get_feature_report(hid_device *dev, unsigned char *data, size_t length)
{
CFIndex len = length;
IOReturn res;
/* Return if the device has been unplugged. */
if (dev->disconnected)
return -1;
res = IOHIDDeviceGetReport(dev->device_handle,
kIOHIDReportTypeFeature,
data[0], /* Report ID */
data, &len);
if (res == kIOReturnSuccess)
return len;
else
return -1;
}
void HID_API_EXPORT hid_close(hid_device *dev)
{
if (!dev)
return;
/* Disconnect the report callback before close. */
if (!dev->disconnected) {
IOHIDDeviceRegisterInputReportCallback(
dev->device_handle, dev->input_report_buf, dev->max_input_report_len,
NULL, dev);
IOHIDManagerRegisterDeviceRemovalCallback(hid_mgr, NULL, dev);
IOHIDDeviceUnscheduleFromRunLoop(dev->device_handle, dev->run_loop, dev->run_loop_mode);
IOHIDDeviceScheduleWithRunLoop(dev->device_handle, CFRunLoopGetMain(), kCFRunLoopDefaultMode);
}
/* Cause read_thread() to stop. */
dev->shutdown_thread = 1;
/* Wake up the run thread's event loop so that the thread can exit. */
CFRunLoopSourceSignal(dev->source);
CFRunLoopWakeUp(dev->run_loop);
/* Notify the read thread that it can shut down now. */
pthread_barrier_wait(&dev->shutdown_barrier);
/* Wait for read_thread() to end. */
pthread_join(dev->thread, NULL);
/* Close the OS handle to the device, but only if it's not
been unplugged. If it's been unplugged, then calling
IOHIDDeviceClose() will crash. */
if (!dev->disconnected) {
IOHIDDeviceClose(dev->device_handle, kIOHIDOptionsTypeNone);
}
/* Clear out the queue of received reports. */
pthread_mutex_lock(&dev->mutex);
while (dev->input_reports) {
return_data(dev, NULL, 0);
}
pthread_mutex_unlock(&dev->mutex);
CFRelease(dev->device_handle);
free_hid_device(dev);
}
int HID_API_EXPORT_CALL hid_get_manufacturer_string(hid_device *dev, wchar_t *string, size_t maxlen)
{
return get_manufacturer_string(dev->device_handle, string, maxlen);
}
int HID_API_EXPORT_CALL hid_get_product_string(hid_device *dev, wchar_t *string, size_t maxlen)
{
return get_product_string(dev->device_handle, string, maxlen);
}
int HID_API_EXPORT_CALL hid_get_serial_number_string(hid_device *dev, wchar_t *string, size_t maxlen)
{
return get_serial_number(dev->device_handle, string, maxlen);
}
int HID_API_EXPORT_CALL hid_get_indexed_string(hid_device *dev, int string_index, wchar_t *string, size_t maxlen)
{
// TODO:
return 0;
}
HID_API_EXPORT const wchar_t * HID_API_CALL hid_error(hid_device *dev)
{
// TODO:
return NULL;
}
#if 0
static int32_t get_location_id(IOHIDDeviceRef device)
{
return get_int_property(device, CFSTR(kIOHIDLocationIDKey));
}
static int32_t get_usage(IOHIDDeviceRef device)
{
int32_t res;
res = get_int_property(device, CFSTR(kIOHIDDeviceUsageKey));
if (!res)
res = get_int_property(device, CFSTR(kIOHIDPrimaryUsageKey));
return res;
}
static int32_t get_usage_page(IOHIDDeviceRef device)
{
int32_t res;
res = get_int_property(device, CFSTR(kIOHIDDeviceUsagePageKey));
if (!res)
res = get_int_property(device, CFSTR(kIOHIDPrimaryUsagePageKey));
return res;
}
static int get_transport(IOHIDDeviceRef device, wchar_t *buf, size_t len)
{
return get_string_property(device, CFSTR(kIOHIDTransportKey), buf, len);
}
int main(void)
{
IOHIDManagerRef mgr;
int i;
mgr = IOHIDManagerCreate(kCFAllocatorDefault, kIOHIDOptionsTypeNone);
IOHIDManagerSetDeviceMatching(mgr, NULL);
IOHIDManagerOpen(mgr, kIOHIDOptionsTypeNone);
CFSetRef device_set = IOHIDManagerCopyDevices(mgr);
CFIndex num_devices = CFSetGetCount(device_set);
IOHIDDeviceRef *device_array = calloc(num_devices, sizeof(IOHIDDeviceRef));
CFSetGetValues(device_set, (const void **) device_array);
for (i = 0; i < num_devices; i++) {
IOHIDDeviceRef dev = device_array[i];
printf("Device: %p\n", dev);
printf(" %04hx %04hx\n", get_vendor_id(dev), get_product_id(dev));
wchar_t serial[256], buf[256];
char cbuf[256];
get_serial_number(dev, serial, 256);
printf(" Serial: %ls\n", serial);
printf(" Loc: %ld\n", get_location_id(dev));
get_transport(dev, buf, 256);
printf(" Trans: %ls\n", buf);
make_path(dev, cbuf, 256);
printf(" Path: %s\n", cbuf);
}
return 0;
}
#endif
qthid-4.1-source/hidwin.c 0000644 0001750 0001750 00000057514 12051012677 013510 0 ustar alc alc /*******************************************************
HIDAPI - Multi-Platform library for
communication with HID devices.
Alan Ott
Signal 11 Software
8/22/2009
Copyright 2009, All Rights Reserved.
At the discretion of the user of this library,
this software may be licensed under the terms of the
GNU Public License v3, a BSD-Style license, or the
original HIDAPI license as outlined in the LICENSE.txt,
LICENSE-gpl3.txt, LICENSE-bsd.txt, and LICENSE-orig.txt
files located at the root of the source distribution.
These files may also be found in the public source
code repository located at:
http://github.com/signal11/hidapi .
********************************************************/
#include
#ifndef _NTDEF_
typedef LONG NTSTATUS;
#endif
#ifdef __MINGW32__
#include
#include
#endif
#ifdef __CYGWIN__
#include
#define _wcsdup wcsdup
#endif
//#define HIDAPI_USE_DDK
#ifdef __cplusplus
extern "C" {
#endif
#include
#include
#ifdef HIDAPI_USE_DDK
#include
#endif
// Copied from inc/ddk/hidclass.h, part of the Windows DDK.
#define HID_OUT_CTL_CODE(id) \
CTL_CODE(FILE_DEVICE_KEYBOARD, (id), METHOD_OUT_DIRECT, FILE_ANY_ACCESS)
#define IOCTL_HID_GET_FEATURE HID_OUT_CTL_CODE(100)
#ifdef __cplusplus
} // extern "C"
#endif
#include
#include
#include "hidapi.h"
#ifdef _MSC_VER
// Thanks Microsoft, but I know how to use strncpy().
#pragma warning(disable:4996)
#endif
#ifdef __cplusplus
extern "C" {
#endif
#ifndef HIDAPI_USE_DDK
// Since we're not building with the DDK, and the HID header
// files aren't part of the SDK, we have to define all this
// stuff here. In lookup_functions(), the function pointers
// defined below are set.
typedef struct _HIDD_ATTRIBUTES{
ULONG Size;
USHORT VendorID;
USHORT ProductID;
USHORT VersionNumber;
} HIDD_ATTRIBUTES, *PHIDD_ATTRIBUTES;
typedef USHORT USAGE;
typedef struct _HIDP_CAPS {
USAGE Usage;
USAGE UsagePage;
USHORT InputReportByteLength;
USHORT OutputReportByteLength;
USHORT FeatureReportByteLength;
USHORT Reserved[17];
USHORT fields_not_used_by_hidapi[10];
} HIDP_CAPS, *PHIDP_CAPS;
typedef void* PHIDP_PREPARSED_DATA;
#define HIDP_STATUS_SUCCESS 0x110000
typedef BOOLEAN (__stdcall *HidD_GetAttributes_)(HANDLE device, PHIDD_ATTRIBUTES attrib);
typedef BOOLEAN (__stdcall *HidD_GetSerialNumberString_)(HANDLE device, PVOID buffer, ULONG buffer_len);
typedef BOOLEAN (__stdcall *HidD_GetManufacturerString_)(HANDLE handle, PVOID buffer, ULONG buffer_len);
typedef BOOLEAN (__stdcall *HidD_GetProductString_)(HANDLE handle, PVOID buffer, ULONG buffer_len);
typedef BOOLEAN (__stdcall *HidD_SetFeature_)(HANDLE handle, PVOID data, ULONG length);
typedef BOOLEAN (__stdcall *HidD_GetFeature_)(HANDLE handle, PVOID data, ULONG length);
typedef BOOLEAN (__stdcall *HidD_GetIndexedString_)(HANDLE handle, ULONG string_index, PVOID buffer, ULONG buffer_len);
typedef BOOLEAN (__stdcall *HidD_GetPreparsedData_)(HANDLE handle, PHIDP_PREPARSED_DATA *preparsed_data);
typedef BOOLEAN (__stdcall *HidD_FreePreparsedData_)(PHIDP_PREPARSED_DATA preparsed_data);
typedef NTSTATUS (__stdcall *HidP_GetCaps_)(PHIDP_PREPARSED_DATA preparsed_data, HIDP_CAPS *caps);
static HidD_GetAttributes_ HidD_GetAttributes;
static HidD_GetSerialNumberString_ HidD_GetSerialNumberString;
static HidD_GetManufacturerString_ HidD_GetManufacturerString;
static HidD_GetProductString_ HidD_GetProductString;
static HidD_SetFeature_ HidD_SetFeature;
static HidD_GetFeature_ HidD_GetFeature;
static HidD_GetIndexedString_ HidD_GetIndexedString;
static HidD_GetPreparsedData_ HidD_GetPreparsedData;
static HidD_FreePreparsedData_ HidD_FreePreparsedData;
static HidP_GetCaps_ HidP_GetCaps;
static HMODULE lib_handle = NULL;
static BOOLEAN initialized = FALSE;
#endif // HIDAPI_USE_DDK
struct hid_device_ {
HANDLE device_handle;
BOOL blocking;
USHORT output_report_length;
size_t input_report_length;
void *last_error_str;
DWORD last_error_num;
BOOL read_pending;
char *read_buf;
OVERLAPPED ol;
};
static hid_device *new_hid_device()
{
hid_device *dev = (hid_device*) calloc(1, sizeof(hid_device));
dev->device_handle = INVALID_HANDLE_VALUE;
dev->blocking = TRUE;
dev->output_report_length = 0;
dev->input_report_length = 0;
dev->last_error_str = NULL;
dev->last_error_num = 0;
dev->read_pending = FALSE;
dev->read_buf = NULL;
memset(&dev->ol, 0, sizeof(dev->ol));
dev->ol.hEvent = CreateEvent(NULL, FALSE, FALSE /*inital state f=nonsignaled*/, NULL);
return dev;
}
static void register_error(hid_device *device, const char *op)
{
WCHAR *ptr, *msg;
FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_IGNORE_INSERTS,
NULL,
GetLastError(),
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPWSTR)&msg, 0/*sz*/,
NULL);
// Get rid of the CR and LF that FormatMessage() sticks at the
// end of the message. Thanks Microsoft!
ptr = msg;
while (*ptr) {
if (*ptr == '\r') {
*ptr = 0x0000;
break;
}
ptr++;
}
// Store the message off in the Device entry so that
// the hid_error() function can pick it up.
LocalFree(device->last_error_str);
device->last_error_str = msg;
}
#ifndef HIDAPI_USE_DDK
static int lookup_functions()
{
lib_handle = LoadLibraryA("hid.dll");
if (lib_handle) {
#define RESOLVE(x) x = (x##_)GetProcAddress(lib_handle, #x); if (!x) return -1;
RESOLVE(HidD_GetAttributes);
RESOLVE(HidD_GetSerialNumberString);
RESOLVE(HidD_GetManufacturerString);
RESOLVE(HidD_GetProductString);
RESOLVE(HidD_SetFeature);
RESOLVE(HidD_GetFeature);
RESOLVE(HidD_GetIndexedString);
RESOLVE(HidD_GetPreparsedData);
RESOLVE(HidD_FreePreparsedData);
RESOLVE(HidP_GetCaps);
#undef RESOLVE
}
else
return -1;
return 0;
}
#endif
static HANDLE open_device(const char *path, BOOL enumerate)
{
HANDLE handle;
DWORD desired_access = (enumerate)? 0: (GENERIC_WRITE | GENERIC_READ);
DWORD share_mode = (enumerate)?
FILE_SHARE_READ|FILE_SHARE_WRITE:
FILE_SHARE_READ;
handle = CreateFileA(path,
desired_access,
share_mode,
NULL,
OPEN_EXISTING,
FILE_FLAG_OVERLAPPED,//FILE_ATTRIBUTE_NORMAL,
0);
return handle;
}
int HID_API_EXPORT hid_init(void)
{
#ifndef HIDAPI_USE_DDK
if (!initialized) {
if (lookup_functions() < 0) {
hid_exit();
return -1;
}
initialized = TRUE;
}
#endif
return 0;
}
int HID_API_EXPORT hid_exit(void)
{
#ifndef HIDAPI_USE_DDK
if (lib_handle)
FreeLibrary(lib_handle);
lib_handle = NULL;
initialized = FALSE;
#endif
return 0;
}
struct hid_device_info HID_API_EXPORT * HID_API_CALL hid_enumerate(unsigned short vendor_id, unsigned short product_id)
{
BOOL res;
struct hid_device_info *root = NULL; // return object
struct hid_device_info *cur_dev = NULL;
// Windows objects for interacting with the driver.
GUID InterfaceClassGuid = {0x4d1e55b2, 0xf16f, 0x11cf, {0x88, 0xcb, 0x00, 0x11, 0x11, 0x00, 0x00, 0x30} };
SP_DEVINFO_DATA devinfo_data;
SP_DEVICE_INTERFACE_DATA device_interface_data;
SP_DEVICE_INTERFACE_DETAIL_DATA_A *device_interface_detail_data = NULL;
HDEVINFO device_info_set = INVALID_HANDLE_VALUE;
int device_index = 0;
int i;
if (hid_init() < 0)
return NULL;
// Initialize the Windows objects.
memset(&devinfo_data, 0x0, sizeof(devinfo_data));
devinfo_data.cbSize = sizeof(SP_DEVINFO_DATA);
device_interface_data.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
// Get information for all the devices belonging to the HID class.
device_info_set = SetupDiGetClassDevsA(&InterfaceClassGuid, NULL, NULL, DIGCF_PRESENT | DIGCF_DEVICEINTERFACE);
// Iterate over each device in the HID class, looking for the right one.
for (;;) {
HANDLE write_handle = INVALID_HANDLE_VALUE;
DWORD required_size = 0;
HIDD_ATTRIBUTES attrib;
res = SetupDiEnumDeviceInterfaces(device_info_set,
NULL,
&InterfaceClassGuid,
device_index,
&device_interface_data);
if (!res) {
// A return of FALSE from this function means that
// there are no more devices.
break;
}
// Call with 0-sized detail size, and let the function
// tell us how long the detail struct needs to be. The
// size is put in &required_size.
res = SetupDiGetDeviceInterfaceDetailA(device_info_set,
&device_interface_data,
NULL,
0,
&required_size,
NULL);
// Allocate a long enough structure for device_interface_detail_data.
device_interface_detail_data = (SP_DEVICE_INTERFACE_DETAIL_DATA_A*) malloc(required_size);
device_interface_detail_data->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_A);
// Get the detailed data for this device. The detail data gives us
// the device path for this device, which is then passed into
// CreateFile() to get a handle to the device.
res = SetupDiGetDeviceInterfaceDetailA(device_info_set,
&device_interface_data,
device_interface_detail_data,
required_size,
NULL,
NULL);
if (!res) {
//register_error(dev, "Unable to call SetupDiGetDeviceInterfaceDetail");
// Continue to the next device.
goto cont;
}
// Make sure this device is of Setup Class "HIDClass" and has a
// driver bound to it.
for (i = 0; ; i++) {
char driver_name[256];
// Populate devinfo_data. This function will return failure
// when there are no more interfaces left.
res = SetupDiEnumDeviceInfo(device_info_set, i, &devinfo_data);
if (!res)
goto cont;
res = SetupDiGetDeviceRegistryPropertyA(device_info_set, &devinfo_data,
SPDRP_CLASS, NULL, (PBYTE)driver_name, sizeof(driver_name), NULL);
if (!res)
goto cont;
if (strcmp(driver_name, "HIDClass") == 0) {
// See if there's a driver bound.
res = SetupDiGetDeviceRegistryPropertyA(device_info_set, &devinfo_data,
SPDRP_DRIVER, NULL, (PBYTE)driver_name, sizeof(driver_name), NULL);
if (res)
break;
}
}
//wprintf(L"HandleName: %s\n", device_interface_detail_data->DevicePath);
// Open a handle to the device
write_handle = open_device(device_interface_detail_data->DevicePath, TRUE);
// Check validity of write_handle.
if (write_handle == INVALID_HANDLE_VALUE) {
// Unable to open the device.
//register_error(dev, "CreateFile");
goto cont_close;
}
// Get the Vendor ID and Product ID for this device.
attrib.Size = sizeof(HIDD_ATTRIBUTES);
HidD_GetAttributes(write_handle, &attrib);
//wprintf(L"Product/Vendor: %x %x\n", attrib.ProductID, attrib.VendorID);
// Check the VID/PID to see if we should add this
// device to the enumeration list.
if ((vendor_id == 0x0 && product_id == 0x0) ||
(attrib.VendorID == vendor_id && attrib.ProductID == product_id)) {
#define WSTR_LEN 512
const char *str;
struct hid_device_info *tmp;
PHIDP_PREPARSED_DATA pp_data = NULL;
HIDP_CAPS caps;
BOOLEAN res;
NTSTATUS nt_res;
wchar_t wstr[WSTR_LEN]; // TODO: Determine Size
size_t len;
/* VID/PID match. Create the record. */
tmp = (struct hid_device_info*) calloc(1, sizeof(struct hid_device_info));
if (cur_dev) {
cur_dev->next = tmp;
}
else {
root = tmp;
}
cur_dev = tmp;
// Get the Usage Page and Usage for this device.
res = HidD_GetPreparsedData(write_handle, &pp_data);
if (res) {
nt_res = HidP_GetCaps(pp_data, &caps);
if (nt_res == HIDP_STATUS_SUCCESS) {
cur_dev->usage_page = caps.UsagePage;
cur_dev->usage = caps.Usage;
}
HidD_FreePreparsedData(pp_data);
}
/* Fill out the record */
cur_dev->next = NULL;
str = device_interface_detail_data->DevicePath;
if (str) {
len = strlen(str);
cur_dev->path = (char*) calloc(len+1, sizeof(char));
strncpy(cur_dev->path, str, len+1);
cur_dev->path[len] = '\0';
}
else
cur_dev->path = NULL;
/* Serial Number */
res = HidD_GetSerialNumberString(write_handle, wstr, sizeof(wstr));
wstr[WSTR_LEN-1] = 0x0000;
if (res) {
cur_dev->serial_number = _wcsdup(wstr);
}
/* Manufacturer String */
res = HidD_GetManufacturerString(write_handle, wstr, sizeof(wstr));
wstr[WSTR_LEN-1] = 0x0000;
if (res) {
cur_dev->manufacturer_string = _wcsdup(wstr);
}
/* Product String */
res = HidD_GetProductString(write_handle, wstr, sizeof(wstr));
wstr[WSTR_LEN-1] = 0x0000;
if (res) {
cur_dev->product_string = _wcsdup(wstr);
}
/* VID/PID */
cur_dev->vendor_id = attrib.VendorID;
cur_dev->product_id = attrib.ProductID;
/* Release Number */
cur_dev->release_number = attrib.VersionNumber;
/* Interface Number. It can sometimes be parsed out of the path
on Windows if a device has multiple interfaces. See
http://msdn.microsoft.com/en-us/windows/hardware/gg487473 or
search for "Hardware IDs for HID Devices" at MSDN. If it's not
in the path, it's set to -1. */
cur_dev->interface_number = -1;
if (cur_dev->path) {
char *interface_component = strstr(cur_dev->path, "&mi_");
if (interface_component) {
char *hex_str = interface_component + 4;
char *endptr = NULL;
cur_dev->interface_number = strtol(hex_str, &endptr, 16);
if (endptr == hex_str) {
/* The parsing failed. Set interface_number to -1. */
cur_dev->interface_number = -1;
}
}
}
}
cont_close:
CloseHandle(write_handle);
cont:
// We no longer need the detail data. It can be freed
free(device_interface_detail_data);
device_index++;
}
// Close the device information handle.
SetupDiDestroyDeviceInfoList(device_info_set);
return root;
}
void HID_API_EXPORT HID_API_CALL hid_free_enumeration(struct hid_device_info *devs)
{
// TODO: Merge this with the Linux version. This function is platform-independent.
struct hid_device_info *d = devs;
while (d) {
struct hid_device_info *next = d->next;
free(d->path);
free(d->serial_number);
free(d->manufacturer_string);
free(d->product_string);
free(d);
d = next;
}
}
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;
}
HID_API_EXPORT hid_device * HID_API_CALL hid_open_path(const char *path)
{
hid_device *dev;
HIDP_CAPS caps;
PHIDP_PREPARSED_DATA pp_data = NULL;
BOOLEAN res;
NTSTATUS nt_res;
if (hid_init() < 0) {
return NULL;
}
dev = new_hid_device();
// Open a handle to the device
dev->device_handle = open_device(path, FALSE);
// Check validity of write_handle.
if (dev->device_handle == INVALID_HANDLE_VALUE) {
// Unable to open the device.
register_error(dev, "CreateFile");
goto err;
}
// Get the Input Report length for the device.
res = HidD_GetPreparsedData(dev->device_handle, &pp_data);
if (!res) {
register_error(dev, "HidD_GetPreparsedData");
goto err;
}
nt_res = HidP_GetCaps(pp_data, &caps);
if (nt_res != HIDP_STATUS_SUCCESS) {
register_error(dev, "HidP_GetCaps");
goto err_pp_data;
}
dev->output_report_length = caps.OutputReportByteLength;
dev->input_report_length = caps.InputReportByteLength;
HidD_FreePreparsedData(pp_data);
dev->read_buf = (char*) malloc(dev->input_report_length);
return dev;
err_pp_data:
HidD_FreePreparsedData(pp_data);
err:
CloseHandle(dev->device_handle);
free(dev);
return NULL;
}
int HID_API_EXPORT HID_API_CALL hid_write(hid_device *dev, const unsigned char *data, size_t length)
{
DWORD bytes_written;
BOOL res;
OVERLAPPED ol;
unsigned char *buf;
memset(&ol, 0, sizeof(ol));
/* Make sure the right number of bytes are passed to WriteFile. Windows
expects the number of bytes which are in the _longest_ report (plus
one for the report number) bytes even if the data is a report
which is shorter than that. Windows gives us this value in
caps.OutputReportByteLength. If a user passes in fewer bytes than this,
create a temporary buffer which is the proper size. */
if (length >= dev->output_report_length) {
/* The user passed the right number of bytes. Use the buffer as-is. */
buf = (unsigned char *) data;
} else {
/* Create a temporary buffer and copy the user's data
into it, padding the rest with zeros. */
buf = (unsigned char *) malloc(dev->output_report_length);
memcpy(buf, data, length);
memset(buf + length, 0, dev->output_report_length - length);
length = dev->output_report_length;
}
res = WriteFile(dev->device_handle, buf, length, NULL, &ol);
if (!res) {
if (GetLastError() != ERROR_IO_PENDING) {
// WriteFile() failed. Return error.
register_error(dev, "WriteFile");
bytes_written = -1;
goto end_of_function;
}
}
// Wait here until the write is done. This makes
// hid_write() synchronous.
res = GetOverlappedResult(dev->device_handle, &ol, &bytes_written, TRUE/*wait*/);
if (!res) {
// The Write operation failed.
register_error(dev, "WriteFile");
bytes_written = -1;
goto end_of_function;
}
end_of_function:
if (buf != data)
free(buf);
return bytes_written;
}
int HID_API_EXPORT HID_API_CALL hid_read_timeout(hid_device *dev, unsigned char *data, size_t length, int milliseconds)
{
DWORD bytes_read = 0;
BOOL res;
// Copy the handle for convenience.
HANDLE ev = dev->ol.hEvent;
if (!dev->read_pending) {
// Start an Overlapped I/O read.
dev->read_pending = TRUE;
memset(dev->read_buf, 0, dev->input_report_length);
ResetEvent(ev);
res = ReadFile(dev->device_handle, dev->read_buf, dev->input_report_length, &bytes_read, &dev->ol);
if (!res) {
if (GetLastError() != ERROR_IO_PENDING) {
// ReadFile() has failed.
// Clean up and return error.
CancelIo(dev->device_handle);
dev->read_pending = FALSE;
goto end_of_function;
}
}
}
if (milliseconds >= 0) {
// See if there is any data yet.
res = WaitForSingleObject(ev, milliseconds);
if (res != WAIT_OBJECT_0) {
// There was no data this time. Return zero bytes available,
// but leave the Overlapped I/O running.
return 0;
}
}
// Either WaitForSingleObject() told us that ReadFile has completed, or
// we are in non-blocking mode. Get the number of bytes read. The actual
// data has been copied to the data[] array which was passed to ReadFile().
res = GetOverlappedResult(dev->device_handle, &dev->ol, &bytes_read, TRUE/*wait*/);
// Set pending back to false, even if GetOverlappedResult() returned error.
dev->read_pending = FALSE;
if (res && bytes_read > 0) {
if (dev->read_buf[0] == 0x0) {
/* If report numbers aren't being used, but Windows sticks a report
number (0x0) on the beginning of the report anyway. To make this
work like the other platforms, and to make it work more like the
HID spec, we'll skip over this byte. */
size_t copy_len;
bytes_read--;
copy_len = length > bytes_read ? bytes_read : length;
memcpy(data, dev->read_buf+1, copy_len);
}
else {
/* Copy the whole buffer, report number and all. */
size_t copy_len = length > bytes_read ? bytes_read : length;
memcpy(data, dev->read_buf, copy_len);
}
}
end_of_function:
if (!res) {
register_error(dev, "GetOverlappedResult");
return -1;
}
return bytes_read;
}
int HID_API_EXPORT HID_API_CALL hid_read(hid_device *dev, unsigned char *data, size_t length)
{
return hid_read_timeout(dev, data, length, (dev->blocking)? -1: 0);
}
int HID_API_EXPORT HID_API_CALL hid_set_nonblocking(hid_device *dev, int nonblock)
{
dev->blocking = !nonblock;
return 0; /* Success */
}
int HID_API_EXPORT HID_API_CALL hid_send_feature_report(hid_device *dev, const unsigned char *data, size_t length)
{
BOOL res = HidD_SetFeature(dev->device_handle, (PVOID)data, length);
if (!res) {
register_error(dev, "HidD_SetFeature");
return -1;
}
return length;
}
int HID_API_EXPORT HID_API_CALL hid_get_feature_report(hid_device *dev, unsigned char *data, size_t length)
{
BOOL res;
#if 0
res = HidD_GetFeature(dev->device_handle, data, length);
if (!res) {
register_error(dev, "HidD_GetFeature");
return -1;
}
return 0; /* HidD_GetFeature() doesn't give us an actual length, unfortunately */
#else
DWORD bytes_returned;
OVERLAPPED ol;
memset(&ol, 0, sizeof(ol));
res = DeviceIoControl(dev->device_handle,
IOCTL_HID_GET_FEATURE,
data, length,
data, length,
&bytes_returned, &ol);
if (!res) {
if (GetLastError() != ERROR_IO_PENDING) {
// DeviceIoControl() failed. Return error.
register_error(dev, "Send Feature Report DeviceIoControl");
return -1;
}
}
// Wait here until the write is done. This makes
// hid_get_feature_report() synchronous.
res = GetOverlappedResult(dev->device_handle, &ol, &bytes_returned, TRUE/*wait*/);
if (!res) {
// The operation failed.
register_error(dev, "Send Feature Report GetOverLappedResult");
return -1;
}
return bytes_returned;
#endif
}
void HID_API_EXPORT HID_API_CALL hid_close(hid_device *dev)
{
if (!dev)
return;
CancelIo(dev->device_handle);
CloseHandle(dev->ol.hEvent);
CloseHandle(dev->device_handle);
LocalFree(dev->last_error_str);
free(dev->read_buf);
free(dev);
}
int HID_API_EXPORT_CALL HID_API_CALL hid_get_manufacturer_string(hid_device *dev, wchar_t *string, size_t maxlen)
{
BOOL res;
res = HidD_GetManufacturerString(dev->device_handle, string, 2 * maxlen);
if (!res) {
register_error(dev, "HidD_GetManufacturerString");
return -1;
}
return 0;
}
int HID_API_EXPORT_CALL HID_API_CALL hid_get_product_string(hid_device *dev, wchar_t *string, size_t maxlen)
{
BOOL res;
res = HidD_GetProductString(dev->device_handle, string, 2 * maxlen);
if (!res) {
register_error(dev, "HidD_GetProductString");
return -1;
}
return 0;
}
int HID_API_EXPORT_CALL HID_API_CALL hid_get_serial_number_string(hid_device *dev, wchar_t *string, size_t maxlen)
{
BOOL res;
res = HidD_GetSerialNumberString(dev->device_handle, string, 2 * maxlen);
if (!res) {
register_error(dev, "HidD_GetSerialNumberString");
return -1;
}
return 0;
}
int HID_API_EXPORT_CALL HID_API_CALL hid_get_indexed_string(hid_device *dev, int string_index, wchar_t *string, size_t maxlen)
{
BOOL res;
res = HidD_GetIndexedString(dev->device_handle, string_index, string, 2 * maxlen);
if (!res) {
register_error(dev, "HidD_GetIndexedString");
return -1;
}
return 0;
}
HID_API_EXPORT const wchar_t * HID_API_CALL hid_error(hid_device *dev)
{
return (wchar_t*)dev->last_error_str;
}
//#define PICPGM
//#define S11
#define P32
#ifdef S11
unsigned short VendorID = 0xa0a0;
unsigned short ProductID = 0x0001;
#endif
#ifdef P32
unsigned short VendorID = 0x04d8;
unsigned short ProductID = 0x3f;
#endif
#ifdef PICPGM
unsigned short VendorID = 0x04d8;
unsigned short ProductID = 0x0033;
#endif
#if 0
int __cdecl main(int argc, char* argv[])
{
int res;
unsigned char buf[65];
UNREFERENCED_PARAMETER(argc);
UNREFERENCED_PARAMETER(argv);
// Set up the command buffer.
memset(buf,0x00,sizeof(buf));
buf[0] = 0;
buf[1] = 0x81;
// Open the device.
int handle = open(VendorID, ProductID, L"12345");
if (handle < 0)
printf("unable to open device\n");
// Toggle LED (cmd 0x80)
buf[1] = 0x80;
res = write(handle, buf, 65);
if (res < 0)
printf("Unable to write()\n");
// Request state (cmd 0x81)
buf[1] = 0x81;
write(handle, buf, 65);
if (res < 0)
printf("Unable to write() (2)\n");
// Read requested state
read(handle, buf, 65);
if (res < 0)
printf("Unable to read()\n");
// Print out the returned buffer.
for (int i = 0; i < 4; i++)
printf("buf[%d]: %d\n", i, buf[i]);
return 0;
}
#endif
#ifdef __cplusplus
} // extern "C"
#endif
qthid-4.1-source/mainwindow.ui 0000644 0001750 0001750 00000041752 12054762152 014575 0 ustar alc alc
MainWindow
0
0
473
336
Qthid
:/qthid/images/qthid.png:/qthid/images/qthid.png
true
3
5
-
-
0
0
372
44
Qt::WheelFocus
QFrame::StyledPanel
QFrame::Raised
-
Qt::Horizontal
40
20
-
-
LNB:
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
true
Frequency offset for up- and downconverters.
Shown frequency = FCD_freq + LNB_offset
Use positive offset for downconverters and negative offset for upconverters.
true
QAbstractSpinBox::UpDownArrows
MHz
3
-1000.000000000000000
15000.000000000000000
-
0
0
Correction:
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
true
0
0
Frequency correction
Qt::AlignLeading|Qt::AlignLeft|Qt::AlignVCenter
ppm
-500
500
-
0
0
Switch power to bias tee ON/OFF.
Requires FCD with S/N TBD or above.
Bias T
true
-
Qt::Horizontal
40
20
-
Qt::Horizontal
-
-
Funcube Dongle Pro+ RF diagram
:/qthid/images/rfchain.png
false
Qt::AlignCenter
0
0
-
Qt::Horizontal
40
20
-
Qt::Horizontal
-
-
false
RF filter
-
0.15 - 4 MHz
-
4 - 8 MHz
-
8 - 16 MHz
-
16 - 32 MHz
-
32 - 75 MHz
-
75 - 125 MHz
-
125 - 250 MHz
-
145 MHz
-
410 - 875 MHz
-
435 MHz
-
0.87 - 2.0 GHz
-
LNA gain
LNA
true
true
-
Mixer gain
Mixer gain
true
true
-
false
IF filter
-
200 kHz
-
300 kHz
-
600 kHz
-
1.5 MHz
-
5 MHz
-
6 MHz
-
7 MHz
-
8 MHz
-
true
IF gain
dB
59
-
Qt::Horizontal
40
20
-
Qt::Vertical
20
40
:/qthid/images/info.png:/qthid/images/info.png
About
Information about Qthid
:/qthid/images/info.png:/qthid/images/info.png
About Qt
Information about Qt
:/qthid/images/quit.png:/qthid/images/quit.png
&Quit
Ctrl+Q
false
:/qthid/images/open.png:/qthid/images/open.png
Load Settings
Load FCD settings from file
false
:/qthid/images/save.png:/qthid/images/save.png
Save Settings
Save FCD settings to file
false
:/qthid/images/fw.png:/qthid/images/fw.png
Firmware
Open firmware tools
:/qthid/images/help.png:/qthid/images/help.png
What's This?
Enter What's This?
Reset to defaults
Reset all settings to their default value
CFreqCtrl
QFrame
1
actionQuit
activated()
MainWindow
close()
-1
-1
494
181
qthid-4.1-source/NEWS.txt 0000644 0001750 0001750 00000004156 12054762152 013374 0 ustar alc alc Changes in version 4.1:
- Special release with Funcube Dongle Pro+ support.
Changes in version 4.0:
- New layout with IF, IQ and firmware controls hidden by default.
- New frequency controller widget.
- Support for up- and downconverters.
Changes in version 3.2:
- Switch to using hidraw driver on Linux 2.6.38 or later (fixes crashes
experienced on recent Linux with libusb-1.0.9).
- Update HID API.
- Reduce widow width.
Changes in version 3.1:
- Support for Mac OS X 10.7 Lion.
- Support for Bias-T with firmware 18h and later.
- Allow user to force band selection to be different from the one chosen by
the FCD (temporary workaround for a FW 18f bug occurring at 861 MHz).
- Change default value of IQ gain correction from 0.0 to 1.0.
- Use correct FCD command for setting IQ phase correction (GH-5).
- Various fixes for windows build using latest SDK (7.0).
- Removed RSSI indicator since it is unlikely that it will ever work.
Changes in version 3.0:
- Implement full API in firmware 18f (thanks Mario Lorenz, DL5MLO).
- Requires firmware 18f or later (earlier firmwares are not detected).
- Added auto-repeat to tuning buttons (click and hold the button to scan).
- Added new RF chain diagram.
- Show firmware version in status message.
Changes in version 2.2:
- Use native toolbar and status bar on Mac OS X
- New application icon based on SVG drawing
- Correctly set application and bundle icon on Mac OS X and Windows
- Minor UI tweaks.
- Fix qthid.pro to allow correct build on Ubuntu 9.04 (thanks EA4FVS).
- Correct application name in file headers (thanks Andrew Elwell)
Changes in version 2.1:
- Various fixes and workarounds to prevent crash and freeze when switching
between application and bootloader mode. The application can now run with or
without FCD (hotplug). Upgrade and verify firmware have been tested on Linux
(32 and 64 bit) and OSX 10.6.
- Updated HID API to hidapi/master from 2011-02-17
- Retrieve libusb configuration on Linux using pkg-config
- Remove local Qt Creator configuration from distribution
- Improvements to the UI layout and widgets
- Added application icon
- Applied GPL V3 license
qthid-4.1-source/funcube-dongle.rules 0000644 0001750 0001750 00000000724 12051012677 016022 0 ustar alc alc # Udev rules for the Funcube Dongle Pro (0xfb56) and Pro+ (0xfb31)
# HIDAPI/libusb:
SUBSYSTEMS=="usb" ATTRS{idVendor}=="04d8" ATTRS{idProduct}=="fb56" MODE:="0666"
SUBSYSTEMS=="usb" ATTRS{idVendor}=="04d8" ATTRS{idProduct}=="fb31" MODE:="0666"
# HIDAPI/hidraw:
KERNEL=="hidraw*", ATTRS{busnum}=="1", ATTRS{idVendor}=="04d8", ATTRS{idProduct}=="fb56", MODE="0666"
KERNEL=="hidraw*", ATTRS{busnum}=="1", ATTRS{idVendor}=="04d8", ATTRS{idProduct}=="fb31", MODE="0666"
qthid-4.1-source/hidapi.h 0000644 0001750 0001750 00000032003 12051012642 013443 0 ustar alc alc /*******************************************************
HIDAPI - Multi-Platform library for
communication with HID devices.
Alan Ott
Signal 11 Software
8/22/2009
Copyright 2009, All Rights Reserved.
At the discretion of the user of this library,
this software may be licensed under the terms of the
GNU Public License v3, a BSD-Style license, or the
original HIDAPI license as outlined in the LICENSE.txt,
LICENSE-gpl3.txt, LICENSE-bsd.txt, and LICENSE-orig.txt
files located at the root of the source distribution.
These files may also be found in the public source
code repository located at:
http://github.com/signal11/hidapi .
********************************************************/
/** @file
* @defgroup API hidapi API
*/
#ifndef HIDAPI_H__
#define HIDAPI_H__
#include
#ifdef _WIN32
#define HID_API_EXPORT __declspec(dllexport)
#define HID_API_CALL
#else
#define HID_API_EXPORT /**< API export macro */
#define HID_API_CALL /**< API call macro */
#endif
#define HID_API_EXPORT_CALL HID_API_EXPORT HID_API_CALL /**< API export and call macro*/
#ifdef __cplusplus
extern "C" {
#endif
struct hid_device_;
typedef struct hid_device_ hid_device; /**< opaque hidapi structure */
/** hidapi info structure */
struct hid_device_info {
/** Platform-specific device path */
char *path;
/** Device Vendor ID */
unsigned short vendor_id;
/** Device Product ID */
unsigned short product_id;
/** Serial Number */
wchar_t *serial_number;
/** Device Release Number in binary-coded decimal,
also known as Device Version Number */
unsigned short release_number;
/** Manufacturer String */
wchar_t *manufacturer_string;
/** Product string */
wchar_t *product_string;
/** Usage Page for this Device/Interface
(Windows/Mac only). */
unsigned short usage_page;
/** Usage for this Device/Interface
(Windows/Mac only).*/
unsigned short usage;
/** The USB interface which this logical device
represents. Valid on both Linux implementations
in all cases, and valid on the Windows implementation
only if the device contains more than one interface. */
int interface_number;
/** Pointer to the next device */
struct hid_device_info *next;
};
/** @brief Initialize the HIDAPI library.
This function initializes the HIDAPI library. Calling it is not
strictly necessary, as it will be called automatically by
hid_enumerate() and any of the hid_open_*() functions if it is
needed. This function should be called at the beginning of
execution however, if there is a chance of HIDAPI handles
being opened by different threads simultaneously.
@ingroup API
@returns
This function returns 0 on success and -1 on error.
*/
int HID_API_EXPORT HID_API_CALL hid_init(void);
/** @brief Finalize the HIDAPI library.
This function frees all of the static data associated with
HIDAPI. It should be called at the end of execution to avoid
memory leaks.
@ingroup API
@returns
This function returns 0 on success and -1 on error.
*/
int HID_API_EXPORT HID_API_CALL hid_exit(void);
/** @brief Enumerate the HID Devices.
This function returns a linked list of all the HID devices
attached to the system which match vendor_id and product_id.
If @p vendor_id and @p product_id are both set to 0, then
all HID devices will be returned.
@ingroup API
@param vendor_id The Vendor ID (VID) of the types of device
to open.
@param product_id The Product ID (PID) of the types of
device to open.
@returns
This function returns a pointer to a linked list of type
struct #hid_device, containing information about the HID devices
attached to the system, or NULL in the case of failure. Free
this linked list by calling hid_free_enumeration().
*/
struct hid_device_info HID_API_EXPORT * HID_API_CALL hid_enumerate(unsigned short vendor_id, unsigned short product_id);
/** @brief Free an enumeration Linked List
This function frees a linked list created by hid_enumerate().
@ingroup API
@param devs Pointer to a list of struct_device returned from
hid_enumerate().
*/
void HID_API_EXPORT HID_API_CALL hid_free_enumeration(struct hid_device_info *devs);
/** @brief Open a HID device using a Vendor ID (VID), Product ID
(PID) and optionally a serial number.
If @p serial_number is NULL, the first device with the
specified VID and PID is opened.
@ingroup API
@param vendor_id The Vendor ID (VID) of the device to open.
@param product_id The Product ID (PID) of the device to open.
@param serial_number The Serial Number of the device to open
(Optionally NULL).
@returns
This function returns a pointer to a #hid_device object on
success or NULL on failure.
*/
HID_API_EXPORT hid_device * HID_API_CALL hid_open(unsigned short vendor_id, unsigned short product_id, const wchar_t *serial_number);
/** @brief Open a HID device by its path name.
The path name be determined by calling hid_enumerate(), or a
platform-specific path name can be used (eg: /dev/hidraw0 on
Linux).
@ingroup API
@param path The path name of the device to open
@returns
This function returns a pointer to a #hid_device object on
success or NULL on failure.
*/
HID_API_EXPORT hid_device * HID_API_CALL hid_open_path(const char *path);
/** @brief Write an Output report to a HID device.
The first byte of @p data[] must contain the Report ID. For
devices which only support a single report, this must be set
to 0x0. The remaining bytes contain the report data. Since
the Report ID is mandatory, calls to hid_write() will always
contain one more byte than the report contains. For example,
if a hid report is 16 bytes long, 17 bytes must be passed to
hid_write(), the Report ID (or 0x0, for devices with a
single report), followed by the report data (16 bytes). In
this example, the length passed in would be 17.
hid_write() will send the data on the first OUT endpoint, if
one exists. If it does not, it will send the data through
the Control Endpoint (Endpoint 0).
@ingroup API
@param device A device handle returned from hid_open().
@param data The data to send, including the report number as
the first byte.
@param length The length in bytes of the data to send.
@returns
This function returns the actual number of bytes written and
-1 on error.
*/
int HID_API_EXPORT HID_API_CALL hid_write(hid_device *device, const unsigned char *data, size_t length);
/** @brief Read an Input report from a HID device with timeout.
Input reports are returned
to the host through the INTERRUPT IN endpoint. The first byte will
contain the Report number if the device uses numbered reports.
@ingroup API
@param device A device handle returned from hid_open().
@param data A buffer to put the read data into.
@param length The number of bytes to read. For devices with
multiple reports, make sure to read an extra byte for
the report number.
@param milliseconds timeout in milliseconds or -1 for blocking wait.
@returns
This function returns the actual number of bytes read and
-1 on error.
*/
int HID_API_EXPORT HID_API_CALL hid_read_timeout(hid_device *dev, unsigned char *data, size_t length, int milliseconds);
/** @brief Read an Input report from a HID device.
Input reports are returned
to the host through the INTERRUPT IN endpoint. The first byte will
contain the Report number if the device uses numbered reports.
@ingroup API
@param device A device handle returned from hid_open().
@param data A buffer to put the read data into.
@param length The number of bytes to read. For devices with
multiple reports, make sure to read an extra byte for
the report number.
@returns
This function returns the actual number of bytes read and
-1 on error.
*/
int HID_API_EXPORT HID_API_CALL hid_read(hid_device *device, unsigned char *data, size_t length);
/** @brief Set the device handle to be non-blocking.
In non-blocking mode calls to hid_read() will return
immediately with a value of 0 if there is no data to be
read. In blocking mode, hid_read() will wait (block) until
there is data to read before returning.
Nonblocking can be turned on and off at any time.
@ingroup API
@param device A device handle returned from hid_open().
@param nonblock enable or not the nonblocking reads
- 1 to enable nonblocking
- 0 to disable nonblocking.
@returns
This function returns 0 on success and -1 on error.
*/
int HID_API_EXPORT HID_API_CALL hid_set_nonblocking(hid_device *device, int nonblock);
/** @brief Send a Feature report to the device.
Feature reports are sent over the Control endpoint as a
Set_Report transfer. The first byte of @p data[] must
contain the Report ID. For devices which only support a
single report, this must be set to 0x0. The remaining bytes
contain the report data. Since the Report ID is mandatory,
calls to hid_send_feature_report() will always contain one
more byte than the report contains. For example, if a hid
report is 16 bytes long, 17 bytes must be passed to
hid_send_feature_report(): the Report ID (or 0x0, for
devices which do not use numbered reports), followed by the
report data (16 bytes). In this example, the length passed
in would be 17.
@ingroup API
@param device A device handle returned from hid_open().
@param data The data to send, including the report number as
the first byte.
@param length The length in bytes of the data to send, including
the report number.
@returns
This function returns the actual number of bytes written and
-1 on error.
*/
int HID_API_EXPORT HID_API_CALL hid_send_feature_report(hid_device *device, const unsigned char *data, size_t length);
/** @brief Get a feature report from a HID device.
Make sure to set the first byte of @p data[] to the Report
ID of the report to be read. Make sure to allow space for
this extra byte in @p data[].
@ingroup API
@param device A device handle returned from hid_open().
@param data A buffer to put the read data into, including
the Report ID. Set the first byte of @p data[] to the
Report ID of the report to be read.
@param length The number of bytes to read, including an
extra byte for the report ID. The buffer can be longer
than the actual report.
@returns
This function returns the number of bytes read and
-1 on error.
*/
int HID_API_EXPORT HID_API_CALL hid_get_feature_report(hid_device *device, unsigned char *data, size_t length);
/** @brief Close a HID device.
@ingroup API
@param device A device handle returned from hid_open().
*/
void HID_API_EXPORT HID_API_CALL hid_close(hid_device *device);
/** @brief Get The Manufacturer String from a HID device.
@ingroup API
@param device A device handle returned from hid_open().
@param string A wide string buffer to put the data into.
@param maxlen The length of the buffer in multiples of wchar_t.
@returns
This function returns 0 on success and -1 on error.
*/
int HID_API_EXPORT_CALL hid_get_manufacturer_string(hid_device *device, wchar_t *string, size_t maxlen);
/** @brief Get The Product String from a HID device.
@ingroup API
@param device A device handle returned from hid_open().
@param string A wide string buffer to put the data into.
@param maxlen The length of the buffer in multiples of wchar_t.
@returns
This function returns 0 on success and -1 on error.
*/
int HID_API_EXPORT_CALL hid_get_product_string(hid_device *device, wchar_t *string, size_t maxlen);
/** @brief Get The Serial Number String from a HID device.
@ingroup API
@param device A device handle returned from hid_open().
@param string A wide string buffer to put the data into.
@param maxlen The length of the buffer in multiples of wchar_t.
@returns
This function returns 0 on success and -1 on error.
*/
int HID_API_EXPORT_CALL hid_get_serial_number_string(hid_device *device, wchar_t *string, size_t maxlen);
/** @brief Get a string from a HID device, based on its string index.
@ingroup API
@param device A device handle returned from hid_open().
@param string_index The index of the string to get.
@param string A wide string buffer to put the data into.
@param maxlen The length of the buffer in multiples of wchar_t.
@returns
This function returns 0 on success and -1 on error.
*/
int HID_API_EXPORT_CALL hid_get_indexed_string(hid_device *device, int string_index, wchar_t *string, size_t maxlen);
/** @brief Get a string describing the last error which occurred.
@ingroup API
@param device A device handle returned from hid_open().
@returns
This function returns a string containing the last error
which occurred or NULL if none has occurred.
*/
HID_API_EXPORT const wchar_t* HID_API_CALL hid_error(hid_device *device);
#ifdef __cplusplus
}
#endif
#endif
qthid-4.1-source/qthid.rc 0000644 0001750 0001750 00000000103 12051012642 013467 0 ustar alc alc IDI_ICON1 ICON DISCARDABLE "images/qthid.ico"
qthid-4.1-source/README.txt 0000644 0001750 0001750 00000011222 12054762152 013545 0 ustar alc alc 1. INTRODUCTION
Qthid is a small control application for the Funcube Dongle devices. It is an evolution of the qthid002 package by Howard Long G6LVB.
This version 4.1 is a special version that adds support for the Funcube Dongle Pro+ (see http://www.funcubedongle.com/?page_id=1073). The original Funcube Dongle Pro is not supported by this version.
Qthid uses the HIDAPI cross platform library by Signal 11 Software (http://www.signal11.us/oss/hidapi/). All the required files are bundled with qthid and no installation of the library is required.
2. INSTALLATION AND USAGE
2.1 Linux
Precompiled binaries (32 or 64 bit) are avaialble for download but users are required to install the Qt runtime libraries on their own. All common Linux distrib utions have the Qt libraries packaged and they can be installed using the package manager for the platform. Qt 4.7 and 4.8 has been tested.
In order to use the Funcube Dongle Pro+ as regular user and udev rule is required. An example funcube-dongle.rules file is included with the package and you can simply copy that file to the /etc/udev/rules.d/ directory (hint: open a terminal and type: "sudo cp funcube-dongle.rules /etc/udev/rules.d/" without the quotes)
Qthid should now detect your Funcube Dongle Pro+ when you plug it in. No reboot or udev restart is necessary.
2.2 Mac OS X (10.6+)
The Mac OS X bundle contains all the necessary Qt libraries and no additional installation or configuration is required. Unlike Linux, the Funcube Dongle will just work.
2.3 Windows
The windows package is self containing and does not require and Qt libs to be installed separately. This release has been tested on Windows 7.
2.4 Building from source
- Install Qt Creator 2.0.1 or newer and Qt SDK 4.7. On recent linux it is normally sufficient to select Qt Creator and the required Qt libraries will be installed as dependencies. On Mac and Windows you need to download the full Qt SDK. On Windows you also need the MS Windows SDK.
- On linux you also need to install the libudev-dev package using the package manager (the name may be different depending on distribution but it should have libudev and dev int he name).
- Open the qthid.pro file in Qt Creator. It will say something about setting up a target; say OK or Finish or Done (depends on version and OS).
- You can now build and execute the project.
It is also possible to build in a terminal:
$ tar xvfz qthid-X.Y.tar.gz
$ cd qthid-X.Y
$ mkdir build
$ cd build
$ qmake ../qthid.pro
$ make
You should now have a qthid binary.
3. License
Qthid is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License along with this program. If not, see .
The frequency controller widget was taken from Cutesdr by Moe Wheatley, released under the following "Simplified BSD License":
Copyright 2010 Moe Wheatley. All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY Moe Wheatley "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL Moe Wheatley OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
The views and conclusions contained in the software and documentation are those of the authors and should not be interpreted as representing official policies, either expressed or implied, of Moe Wheatley.
qthid-4.1-source/freqctrl.cpp 0000644 0001750 0001750 00000063475 12051012642 014403 0 ustar alc alc /////////////////////////////////////////////////////////////////////
// freqctrl.cpp: implementation of the CFreqCtrl class.
//
// This class implements a frequency control widget to set/change
//frequency data.
//
// History:
// 2010-09-15 Initial creation MSW
// 2011-03-27 Initial release
// 2011-04-17 Fixed bug with m_Oldfreq being set after emit instead of before
/////////////////////////////////////////////////////////////////////
//==========================================================================================
// + + + This Software is released under the "Simplified BSD License" + + +
//Copyright 2010 Moe Wheatley. All rights reserved.
//
//Redistribution and use in source and binary forms, with or without modification, are
//permitted provided that the following conditions are met:
//
// 1. Redistributions of source code must retain the above copyright notice, this list of
// conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright notice, this list
// of conditions and the following disclaimer in the documentation and/or other materials
// provided with the distribution.
//
//THIS SOFTWARE IS PROVIDED BY Moe Wheatley ``AS IS'' AND ANY EXPRESS OR IMPLIED
//WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
//FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL Moe Wheatley OR
//CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
//CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
//SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
//ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
//NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
//ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
//The views and conclusions contained in the software and documentation are those of the
//authors and should not be interpreted as representing official policies, either expressed
//or implied, of Moe Wheatley.
//==========================================================================================
//#include
#include
#include "freqctrl.h"
//Manual adjustment of Font size as percent of control height
#define DIGIT_SIZE_PERCENT 90
#define UNITS_SIZE_PERCENT 60
//adjustment for separation between digits
#define SEPRATIO_N 100 //separation rectangle size ratio numerator times 100
#define SEPRATIO_D 3 //separation rectangle size ratio denominator
/////////////////////////////////////////////////////////////////////
// Constructor/Destructor
/////////////////////////////////////////////////////////////////////
CFreqCtrl::CFreqCtrl(QWidget *parent) :
QFrame(parent)
{
setAutoFillBackground(false);
setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
setFocusPolicy(Qt::StrongFocus);
setMouseTracking ( TRUE );
m_BkColor = QColor(0x20,0x20,0x20,0xFF);//Qt::black;
m_DigitColor = QColor(0xFF, 0xE6, 0xC8, 0xFF);
m_HighlightColor = QColor(0x5A, 0x5A, 0x5A, 0xFF);
m_UnitsColor = Qt::gray;
m_freq = 146123456;
Setup( 10, 1, 4000000000U, 1, UNITS_MHZ);
m_Oldfreq = 0;
m_LastLeadZeroPos = 0;
m_LRMouseFreqSel = FALSE;
m_ActiveEditDigit = -1;
m_ResetLowerDigits = FALSE;
m_UnitsFont = QFont("Arial",12,QFont::Normal);
m_DigitFont = QFont("Arial",12,QFont::Normal);
}
CFreqCtrl::~CFreqCtrl()
{
}
/////////////////////////////////////////////////////////////////////
// Size hint stuff
/////////////////////////////////////////////////////////////////////
QSize CFreqCtrl::minimumSizeHint() const
{
return QSize(100, 20);
}
QSize CFreqCtrl::sizeHint() const
{
return QSize(100, 20);
}
/////////////////////////////////////////////////////////////////////
// Various helper functions
/////////////////////////////////////////////////////////////////////
bool CFreqCtrl::InRect(QRect &rect, QPoint &point)
{
if( ( point.x() < rect.right( ) ) && ( point.x() > rect.x() ) &&
( point.y() < rect.bottom() ) && ( point.y() > rect.y() ) )
return TRUE;
else
return FALSE;
}
//////////////////////////////////////////////////////////////////////////////
// Setup various parameters for the control
//////////////////////////////////////////////////////////////////////////////
void CFreqCtrl::Setup(int NumDigits, qint64 Minf, qint64 Maxf,int MinStep, FUNITS UnitsType)
{
int i;
qint64 pwr = 1;
m_LastEditDigit = 0;
m_Oldfreq = -1;
m_NumDigits = NumDigits;
if( m_NumDigits>MAX_DIGITS )
m_NumDigits = MAX_DIGITS;
if( m_NumDigits m_MaxFreq)
m_freq = m_MaxFreq;
for(i=0; ipwr )
m_MaxFreq = pwr-1;
m_MaxFreq = m_MaxFreq - m_MaxFreq%m_MinStep;
if( m_MinFreq>pwr )
m_MinFreq = 1;
m_MinFreq = m_MinFreq - m_MinFreq%m_MinStep;
m_DigStart = 0;
switch(UnitsType)
{
case UNITS_HZ:
m_DecPos = 0;
m_UnitString = "Hz ";
break;
case UNITS_KHZ:
m_DecPos = 3;
m_UnitString = "KHz";
break;
case UNITS_MHZ:
m_DecPos = 6;
m_UnitString = "MHz";
break;
case UNITS_GHZ:
m_DecPos = 9;
m_UnitString = "GHz";
break;
case UNITS_SEC:
m_DecPos = 6;
m_UnitString = "Sec";
break;
case UNITS_MSEC:
m_DecPos = 3;
m_UnitString = "mS ";
break;
case UNITS_USEC:
m_DecPos = 0;
m_UnitString = "uS ";
break;
case UNITS_NSEC:
m_DecPos = 0;
m_UnitString = "nS ";
break;
}
for(i=m_NumDigits-1; i>=0; i--)
{
if( m_DigitInfo[i].weight <= m_MinStep )
{
if(m_DigStart == 0)
{
m_DigitInfo[i].incval = m_MinStep;
m_DigStart = i;
}
else
{
if( (m_MinStep%m_DigitInfo[i+1].weight) != 0)
m_DigStart = i;
m_DigitInfo[i].incval = 0;
}
}
}
m_NumSeps = (m_NumDigits-1)/3 - m_DigStart/3;
}
//////////////////////////////////////////////////////////////////////////////
// Sets the frequency and individual digit values
//////////////////////////////////////////////////////////////////////////////
void CFreqCtrl::SetFrequency(qint64 freq)
{
int i;
qint64 acc = 0;
qint64 rem;
int val;
if( freq == m_Oldfreq)
return;
if( freq < m_MinFreq)
freq = m_MinFreq;
if( freq > m_MaxFreq)
freq = m_MaxFreq;
m_freq = freq - freq%m_MinStep;
rem = m_freq;
m_LeadZeroPos = m_NumDigits;
for(i=m_NumDigits-1; i>=m_DigStart; i--)
{
val = (int)(rem/m_DigitInfo[i].weight);
if(m_DigitInfo[i].val != val)
{
m_DigitInfo[i].val = val;
m_DigitInfo[i].modified = TRUE;
}
rem = rem - val*m_DigitInfo[i].weight;
acc += val;
if( (acc==0) && ( i>m_DecPos) )
m_LeadZeroPos = i;
}
// signal the new frequency to world
m_Oldfreq = m_freq;
emit NewFrequency( m_freq );
UpdateCtrl(m_LastLeadZeroPos != m_LeadZeroPos);
m_LastLeadZeroPos = m_LeadZeroPos;
}
//////////////////////////////////////////////////////////////////////////////
// Sets the Digit and comma and decimal pt color
//////////////////////////////////////////////////////////////////////////////
void CFreqCtrl::SetDigitColor(QColor cr)
{
m_UpdateAll = TRUE;
m_DigitColor = cr;
for(int i=m_DigStart; i=0)
{
if( m_DigitInfo[m_ActiveEditDigit].editmode )
{
m_DigitInfo[m_ActiveEditDigit].editmode = FALSE;
m_DigitInfo[m_ActiveEditDigit].modified = TRUE;
m_ActiveEditDigit = -1;
UpdateCtrl(FALSE);
}
}
}
/////////////////////////////////////////////////////////////////////
// main draw event for this control
/////////////////////////////////////////////////////////////////////
void CFreqCtrl::paintEvent(QPaintEvent *)
{
QPainter painter(&m_Pixmap);
if(m_UpdateAll) //if need to redraw everything
{
DrawBkGround(painter);
m_UpdateAll = FALSE;
}
// draw any modified digits to the m_MemDC
DrawDigits(painter);
//now draw pixmap onto screen
QPainter scrnpainter(this);
scrnpainter.drawPixmap(0,0,m_Pixmap); //blt to the screen(flickers like a candle, why?)
}
/////////////////////////////////////////////////////////////////////
// Mouse Event overrides
/////////////////////////////////////////////////////////////////////
void CFreqCtrl::mouseMoveEvent(QMouseEvent * event)
{
QPoint pt = event->pos();
//find which digit is to be edited
if( isActiveWindow() )
{
if(!hasFocus())
setFocus(Qt::MouseFocusReason);
for(int i=m_DigStart; ipos();
if(event->button() == Qt::LeftButton)
{
for(int i=m_DigStart; ibutton() == Qt::RightButton)
{
for(int i=m_DigStart; ipos();
int numDegrees = event->delta() / 8;
int numSteps = numDegrees / 15;
for(int i=m_DigStart; i0)
IncFreq();
else
if(numSteps<0)
DecFreq();
}
}
}
/////////////////////////////////////////////////////////////////////
// Keyboard Event overrides
/////////////////////////////////////////////////////////////////////
void CFreqCtrl::keyPressEvent( QKeyEvent * event )
{ //call base class if dont over ride key
bool fSkipMsg = FALSE;
qint64 tmp;
//qDebug() <key();
switch(event->key())
{
case Qt::Key_0:
case Qt::Key_1:
case Qt::Key_2:
case Qt::Key_3:
case Qt::Key_4:
case Qt::Key_5:
case Qt::Key_6:
case Qt::Key_7:
case Qt::Key_8:
case Qt::Key_9:
if( m_ActiveEditDigit>=0)
{
if( m_DigitInfo[m_ActiveEditDigit].editmode)
{
tmp = (m_freq/m_DigitInfo[m_ActiveEditDigit].weight)%10;
m_freq -= tmp*m_DigitInfo[m_ActiveEditDigit].weight;
m_freq = m_freq+(event->key()-'0')*m_DigitInfo[m_ActiveEditDigit].weight;
SetFrequency(m_freq);
}
}
MoveCursorRight();
fSkipMsg = TRUE;
break;
case Qt::Key_Left:
if( m_ActiveEditDigit != -1 )
{
MoveCursorLeft();
fSkipMsg = TRUE;
}
break;
case Qt::Key_Up:
if(m_ActiveEditDigit != -1 )
{
IncFreq();
fSkipMsg = TRUE;
}
break;
case Qt::Key_Down:
if(m_ActiveEditDigit != -1)
{
DecFreq();
fSkipMsg = TRUE;
}
break;
case Qt::Key_Right:
if(m_ActiveEditDigit != -1 )
{
MoveCursorRight();
fSkipMsg = TRUE;
}
break;
case Qt::Key_Home:
CursorHome();
fSkipMsg = TRUE;
break;
case Qt::Key_End:
CursorEnd();
fSkipMsg = TRUE;
break;
default:
break;
}
if(!fSkipMsg)
QFrame::keyPressEvent(event);
}
//////////////////////////////////////////////////////////////////////////////
// Calculates all the rectangles for the digits, separators, and units text
// and creates the fonts for them.
//////////////////////////////////////////////////////////////////////////////
void CFreqCtrl::DrawBkGround(QPainter &Painter)
{
QRect rect(0, 0, width(), height());
//qDebug() <m_DigStart) && ( (i%3)==0 ) )
{
m_SepRect[i].setCoords( digpos - sepwidth,
rect.top(),
digpos,
rect.bottom());
Painter.fillRect(m_SepRect[i], m_BkColor);
digpos -= sepwidth;
if( i==m_DecPos)
Painter.drawText(m_SepRect[i], Qt::AlignHCenter|Qt::AlignVCenter, ".");
else
if( i>m_DecPos && i= m_LeadZeroPos)
Painter.setPen(m_BkColor);
else
Painter.setPen(m_DigitColor);
digchar = '0' + m_DigitInfo[i].val;
Painter.drawText(m_DigitInfo[i].dQRect, Qt::AlignHCenter|Qt::AlignVCenter, QString().number( m_DigitInfo[i].val ) );
m_DigitInfo[i].modified = FALSE;
}
}
}
//////////////////////////////////////////////////////////////////////////////
// Increment just the digit active in edit mode
//////////////////////////////////////////////////////////////////////////////
void CFreqCtrl::IncDigit()
{
int tmp;
qint64 tmpl;
if( m_ActiveEditDigit>=0)
{
if( m_DigitInfo[m_ActiveEditDigit].editmode)
{
if(m_DigitInfo[m_ActiveEditDigit].weight == m_DigitInfo[m_ActiveEditDigit].incval)
{
// get the current digit value
tmp = (int)((m_freq/m_DigitInfo[m_ActiveEditDigit].weight)%10);
// set the current digit value to zero
m_freq -= tmp*m_DigitInfo[m_ActiveEditDigit].weight;
tmp++;
if( tmp>9 )
tmp = 0;
m_freq = m_freq+(qint64)tmp*m_DigitInfo[m_ActiveEditDigit].weight;
}
else
{
tmp = (int)((m_freq/m_DigitInfo[m_ActiveEditDigit+1].weight)%10);
tmpl = m_freq + m_DigitInfo[m_ActiveEditDigit].incval;
if(tmp != (int)((tmpl/m_DigitInfo[m_ActiveEditDigit+1].weight)%10) )
{
tmpl -= m_DigitInfo[m_ActiveEditDigit+1].weight;
}
m_freq = tmpl;
}
SetFrequency(m_freq);
}
}
}
//////////////////////////////////////////////////////////////////////////////
// Increment the frequency by this digit active in edit mode
//////////////////////////////////////////////////////////////////////////////
void CFreqCtrl::IncFreq()
{
if( m_ActiveEditDigit>=0)
{
if( m_DigitInfo[m_ActiveEditDigit].editmode)
{
m_freq += m_DigitInfo[m_ActiveEditDigit].incval;
if (m_ResetLowerDigits) {
/* Set digits below the active one to 0 */
m_freq = m_freq - m_freq%m_DigitInfo[m_ActiveEditDigit].weight;
}
SetFrequency(m_freq);
m_LastEditDigit = m_ActiveEditDigit;
}
}
}
//////////////////////////////////////////////////////////////////////////////
// Decrement the digit active in edit mode
//////////////////////////////////////////////////////////////////////////////
void CFreqCtrl::DecDigit()
{
int tmp;
qint64 tmpl;
if( m_ActiveEditDigit>=0)
{
if( m_DigitInfo[m_ActiveEditDigit].editmode)
{
if(m_DigitInfo[m_ActiveEditDigit].weight == m_DigitInfo[m_ActiveEditDigit].incval)
{
// get the current digit value
tmp = (int)((m_freq/m_DigitInfo[m_ActiveEditDigit].weight)%10);
// set the current digit value to zero
m_freq -= tmp*m_DigitInfo[m_ActiveEditDigit].weight;
tmp--;
if( tmp<0 )
tmp = 9;
m_freq = m_freq+(qint64)tmp*m_DigitInfo[m_ActiveEditDigit].weight;
}
else
{
tmp = (int)((m_freq/m_DigitInfo[m_ActiveEditDigit+1].weight)%10);
tmpl = m_freq - m_DigitInfo[m_ActiveEditDigit].incval;
if(tmp != (int)((tmpl/m_DigitInfo[m_ActiveEditDigit+1].weight)%10) )
{
tmpl += m_DigitInfo[m_ActiveEditDigit+1].weight;
}
m_freq = tmpl;
}
SetFrequency(m_freq);
}
}
}
//////////////////////////////////////////////////////////////////////////////
// Decrement the frequency by this digit active in edit mode
//////////////////////////////////////////////////////////////////////////////
void CFreqCtrl::DecFreq()
{
if( m_ActiveEditDigit>=0)
{
if( m_DigitInfo[m_ActiveEditDigit].editmode)
{
m_freq -= m_DigitInfo[m_ActiveEditDigit].incval;
if (m_ResetLowerDigits) {
/* digits below the active one are reset to 0 */
m_freq = m_freq - m_freq%m_DigitInfo[m_ActiveEditDigit].weight;
}
SetFrequency(m_freq);
m_LastEditDigit = m_ActiveEditDigit;
}
}
}
/////////////////////////////////////////////////////////////////////
// Cursor move routines for arrow key editing
/////////////////////////////////////////////////////////////////////
void CFreqCtrl::MoveCursorLeft()
{
QPoint pt;
if( (m_ActiveEditDigit >=0) && (m_ActiveEditDigit m_FirstEditableDigit )
{
cursor().setPos( mapToGlobal( m_DigitInfo[--m_ActiveEditDigit].dQRect.center() ) );
}
}
void CFreqCtrl::CursorHome()
{
QPoint pt;
if( m_ActiveEditDigit >= 0 )
{
cursor().setPos( mapToGlobal( m_DigitInfo[m_NumDigits-1].dQRect.center() ) );
}
}
void CFreqCtrl::CursorEnd()
{
QPoint pt;
if( m_ActiveEditDigit > 0 )
{
cursor().setPos( mapToGlobal( m_DigitInfo[m_FirstEditableDigit].dQRect.center() ) );
}
}
qthid-4.1-source/mainwindow.h 0000644 0001750 0001750 00000004726 12054762152 014407 0 ustar alc alc /***************************************************************************
* This file is part of Qthid.
*
* Copyright (C) 2010 Howard Long, G6LVB
* Copyright (C) 2011 Mario Lorenz, DL5MLO
* Copyright (C) 2011-2012 Alexandru Csete, OZ9AEC
*
* Qthid is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Qthid is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Qthid. If not, see .
*
***************************************************************************/
#ifndef MAINWINDOW_H
#define MAINWINDOW_H
#include
#include
#include
#include "fcd.h"
#include "firmware.h"
namespace Ui {
class MainWindow;
}
class MainWindow : public QMainWindow
{
Q_OBJECT
public:
explicit MainWindow(QWidget *parent = 0);
~MainWindow();
private:
Ui::MainWindow *ui; /*! UI generated by Qt Designer. */
QTimer *timer; /*! Timer for cyclic polling of FCD. */
QLabel *fcdStatus; /*! Label showing FCD status in statusbar. */
FCD_MODE_ENUM prevMode; /*! Previous mode to detect FCd mode changes (bootloader/app). */
CFirmware *fwDialog; /*! Firmware tools (uplaod and verify firmware). */
qint64 lnbOffset; /*! Frequency offset when using up- and downconverters (Hz). */
double StrToDouble(QString s);
void readDevice(quint16 flags);
public slots:
void setNewFrequency(qint64 freq);
private slots:
void on_spinBoxCorr_valueChanged(int);
void on_spinBoxLnb_valueChanged(double);
void on_biasTeeButton_clicked();
void on_lnaButton_clicked();
void on_mixerButton_clicked();
void on_ifGainSpinBox_valueChanged(int);
void enableControls();
void fwDialogFinished(int result);
/* actions */
void on_actionLoad_triggered();
void on_actionSave_triggered();
void on_actionFirmware_triggered();
void on_actionDefault_triggered();
void on_actionAbout_triggered();
void on_actionAboutQt_triggered();
};
#endif // MAINWINDOW_H
qthid-4.1-source/firmware.h 0000644 0001750 0001750 00000003060 12051012677 014032 0 ustar alc alc /***************************************************************************
* This file is part of Qthid.
*
* Copyright (C) 2011-2012 Alexandru Csete, OZ9AEC
*
* Qthid is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Qthid is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Qthid. If not, see .
*
***************************************************************************/
#ifndef FIRMWARE_H
#define FIRMWARE_H
#include
#include
namespace Ui {
class CFirmware;
}
/*! \brief Firmware tools for uploading and verifying firmware. */
class CFirmware : public QDialog
{
Q_OBJECT
public:
explicit CFirmware(QWidget *parent = 0);
~CFirmware();
void closeEvent(QCloseEvent *event);
private slots:
void on_selectButton_clicked();
void on_uploadButton_clicked();
void on_verifyButton_clicked();
void on_lineEdit_textChanged(const QString & text);
void on_lineEdit_textEdited(const QString & text);
private:
Ui::CFirmware *ui;
void checkFirmwareSelection(const QString &fwFile);
};
#endif // FIRMWARE_H
qthid-4.1-source/fcdhidcmd.h 0000644 0001750 0001750 00000006037 12051012677 014132 0 ustar alc alc /***************************************************************************
* This file is part of Qthid.
*
* Copyright (C) 2010 Howard Long, G6LVB
* Copyright (C) 2011 Mario Lorenz, DL5MLO
* Copyright (C) 2011-2012 Alexandru Csete, OZ9AEC
*
* Qthid is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Qthid is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Qthid. If not, see .
*
***************************************************************************/
#ifndef FCD_HID_CMD_H
#define FCD_HID_CMD_H 1
/* Commands applicable in bootloader mode */
#define FCD_CMD_BL_QUERY 1 /*!< Returns string with "FCDAPP version". */
/* Commands applicable in application mode */
#define FCD_CMD_APP_SET_FREQ_KHZ 100 /*!< Send with 3 byte unsigned little endian frequency in kHz. */
#define FCD_CMD_APP_SET_FREQ_HZ 101 /*!< Send with 4 byte unsigned little endian frequency in Hz, returns with actual frequency set in Hz */
#define FCD_CMD_APP_GET_FREQ_HZ 102 /*!< Returns 4 byte unsigned little endian frequency in Hz. */
#define FCD_CMD_APP_SET_LNA_GAIN 110 /*!< Send one byte: 1=ON, 0=OFF. */
#define FCD_CMD_APP_SET_RF_FILTER 113 /*!< Send one byte, see tuner_rf_filter_t enum. */
#define FCD_CMD_APP_SET_MIXER_GAIN 114 /*!< Send one byte:1=ON, 0=OFF. */
#define FCD_CMD_APP_SET_IF_GAIN 117 /*!< Send one byte, valid value 0 to 59 (dB). */
#define FCD_CMD_APP_SET_IF_FILTER 122 /*!< Send one byte, see tuner_if_filter_t enum. */
#define FCD_CMD_APP_SET_BIAS_TEE 126 /*!< Bias T for ext LNA. Send with one byte: 1=ON, 0=OFF. */
#define FCD_CMD_APP_GET_LNA_GAIN 150 /*!< Returns one byte: 1=ON, 0=OFF. */
#define FCD_CMD_APP_GET_RF_FILTER 153 /*!< Returns one byte, see tuner_rf_filter_t enum. */
#define FCD_CMD_APP_GET_MIXER_GAIN 154 /*!< Returns one byte: 1=ON, 0=OFF. */
#define FCD_CMD_APP_GET_IF_GAIN 157 /*!< Returns one byte, valid value 0 to 59 (dB). */
#define FCD_CMD_APP_GET_IF_FILTER 162 /*!< Returns one byte, see tuner_if_filter_t enum. */
#define FCD_CMD_APP_GET_BIAS_TEE 166 /*!< Returns one byte: 1=ON, 0=OFF. */
#define FCD_CMD_APP_RESET 255 /*!< Reset to bootloader. */
typedef enum
{
TRFE_0_4 = 0,
TRFE_4_8,
TRFE_8_16,
TRFE_16_32,
TRFE_32_75,
TRFE_75_125,
TRFE_125_250,
TRFE_145,
TRFE_410_875,
TRFE_435,
TRFE_875_2000
} tuner_rf_filter_t;
typedef enum
{
TIFE_200KHZ = 0,
TIFE_300KHZ,
TIFE_600KHZ,
TIFE_1536KHZ,
TIFE_5MHZ,
TIFE_6MHZ,
TIFE_7MHZ,
TIFE_8MHZ
} tuner_if_filter_t;
#endif // FCD_HID_CMD_H
qthid-4.1-source/images/ 0000755 0001750 0001750 00000000000 12051012677 013313 5 ustar alc alc qthid-4.1-source/images/fw.png 0000644 0001750 0001750 00000004001 12051012642 014420 0 ustar alc alc PNG
IHDR 0 0 W sRGB bKGD pHYs
B(x tIME?r IDAThogff{@ "U)AI4iDHmkU@AZ)U%!`(qJ
v!"8k`c7lzӇgUZi?|sogۙ9g,e)KYR|u" Z3l ZO|5Heks~@;W59
9 MH@krj_ү'r4,?>LNTfmxrtibzwWr[8*9HOwM4MK.ȍй'tt9kCG?c)~m[WTPYMɕ! (ྱo rmk>w_pK?qgQ
~
DX,f'ʽ4RrPaɧr`h[ڑ&Z(_;Ɨ5sR>U|R>sFBE|H(|xwx͜4ҳ:4uYzB7Ǐe7zG^>x8w
\Ց>f@(
ew<)][Jsxصck\F}Y/8w}š^.-
}ޗ@(½==b;Js/?s_;R~
Tww{v#]̾GIgbӧs{
J\E_{ Td'vd.-ßP=3獾#qҙR,\{Tzsy
sյRUgV̀Ygp_'|`FX6_9ʁL` s>J;X6zm=v4Z
-.@cƓ|G4UTT$#GW>fW GIkk_ߏUBz
E. ւƍue.T$
fsM(Jä3Di
uM0s7ΦND'{7NLL tr{zD"N8XN&&'Fggfb.}ٹ$wL(>o|D"`~>M<W =&РXF2iRikh)@nT1CJ15ON麫m]|ܚu͛Cؒ!ZMyXX?iY
)A .f9QB_u!`q!0NZibo%$l,c%cУ%(
FVEd=,fFYP&ෞ!ᡡ^ahhT~CW>/kέ^AJx 6\tmdchhy%Noy{ 4* ݏ0)pCSAjqTHKv7nCokwq.|>o7NueQ^8Khj6PTNa
j
+H) QuIxݍjv^&ipcT,I 0̭C^
h6k( l:4 Ҥ+kRYfv`# @m]ɕP`7z@f~tMFt2P Ԙ%#%EKAB_# 4l
fI%PE:F[(@䈹IaOѼ=C֔s
ϲ߈~(b95܀HO)2-rHIS9 MϮt |j"-9#2@hr^eBΡ(E{,Je)KY?"?- IENDB` qthid-4.1-source/images/qthid.ico 0000644 0001750 0001750 00000133735 12051012642 015124 0 ustar alc alc q V 00 h&