int main (int argc, char *argv[])
{
static const char *args = "/dev/hidrawX page";
auto mem_type = HIDPP20::IOnboardProfiles::MemoryType::Writeable;
HIDPP::DeviceIndex device_index = HIDPP::DefaultDevice;
std::vector<Option> options = {
DeviceIndexOption (device_index),
VerboseOption (),
Option ('r', "rom",
Option::NoArgument, "",
"Read data from ROM",
[&mem_type] (const char *) -> bool {
mem_type = HIDPP20::IOnboardProfiles::MemoryType::ROM;
return true;
}),
};
Option help = HelpOption (argv[0], args, &options);
options.push_back (help);
int first_arg;
if (!Option::processOptions (argc, argv, options, first_arg))
return EXIT_FAILURE;
if (argc-first_arg != 2) {
fprintf (stderr, "%s", getUsage (argv[0], args, &options).c_str ());
return EXIT_FAILURE;
}
const char *path = argv[first_arg];
char *endptr;
unsigned int page = strtol (argv[first_arg+1], &endptr, 0);
if (*endptr != '\0') {
fprintf (stderr, "Invalid page number.\n");
return EXIT_FAILURE;
}
try {
HIDPP20::Device dev (path, device_index);
HIDPP20::IOnboardProfiles iop (&dev);
auto desc = iop.getDescription ();
unsigned int i = 0;
while (i < desc.sector_size) {
auto data = iop.memoryRead (mem_type, page, i);
write (1, data.data (), data.size ());
i += data.size ();
}
}
catch (HIDPP20::Error e) {
fprintf (stderr, "HID++2 error %d: %s\n", e.errorCode (), e.what ());
return e.errorCode ();
}
return EXIT_SUCCESS;
}
int main (int argc, char *argv[])
{
static const char *args = "/dev/hidrawX";
HIDPP::DeviceIndex device_index = HIDPP::DefaultDevice;
std::vector<Option> options = {
DeviceIndexOption (device_index),
VerboseOption (),
};
Option help = HelpOption (argv[0], args, &options);
options.push_back (help);
int first_arg;
if (!Option::processOptions (argc, argv, options, first_arg))
return EXIT_FAILURE;
if (argc-first_arg != 1) {
fprintf (stderr, "%s", getUsage (argv[0], args, &options).c_str ());
return EXIT_FAILURE;
}
const char *path = argv[first_arg];
try {
unsigned int major, minor;
HIDPP::Device dev (path, device_index);
dev.getProtocolVersion (major, minor);
printf ("%d.%d\n", major, minor);
Log::printf (Log::Info, "Device is %s (%04hx:%04hx)\n",
dev.name ().c_str (),
dev.vendorID (), dev.productID ());
}
catch (HIDPP::Device::NoHIDPPReportException e) {
Log::info () << "Device is not a HID++ device" << std::endl;
return EXIT_FAILURE;
}
catch (std::system_error e) {
fprintf (stderr, "Failed to open %s: %s\n", path, e.what ());
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
int main (int argc, char *argv[])
{
std::vector<Option> options = {
VerboseOption (),
};
Option help = HelpOption (argv[0], "", &options);
options.push_back (help);
int first_arg;
if (!Option::processOptions (argc, argv, options, first_arg))
return EXIT_FAILURE;
if (argc-first_arg != 0) {
fprintf (stderr, "%s", getUsage (argv[0], "", &options).c_str ());
return EXIT_FAILURE;
}
int ret;
struct udev *ctx = udev_new ();
if (!ctx) {
fprintf (stderr, "Failed to create udev context\n");
return EXIT_FAILURE;
}
struct udev_enumerate *enumerator = udev_enumerate_new (ctx);
if (!enumerator) {
fprintf (stderr, "Failed to create udev enumerator\n");
return EXIT_FAILURE;
}
if (0 != (ret = udev_enumerate_add_match_subsystem (enumerator, "hidraw"))) {
fprintf (stderr, "Failed to add match: %s\n", strerror (ret));
return EXIT_FAILURE;
}
if (0 != (ret = udev_enumerate_scan_devices (enumerator))) {
fprintf (stderr, "Failed to scan devices: %s\n", strerror (ret));
return EXIT_FAILURE;
}
struct udev_list_entry *current;
udev_list_entry_foreach (current, udev_enumerate_get_list_entry (enumerator)) {
struct udev_device *device = udev_device_new_from_syspath (ctx, udev_list_entry_get_name (current));
const char *hidraw_node = udev_device_get_devnode (device);
try {
for (HIDPP::DeviceIndex index: {
HIDPP::DefaultDevice,
HIDPP::CordedDevice,
HIDPP::WirelessDevice1,
HIDPP::WirelessDevice2,
HIDPP::WirelessDevice3,
HIDPP::WirelessDevice4,
HIDPP::WirelessDevice5,
HIDPP::WirelessDevice6 }) {
try {
HIDPP::Device dev (hidraw_node, index);
unsigned int major, minor;
dev.getProtocolVersion (major, minor);
printf ("%s", hidraw_node);
if (index != HIDPP::DefaultDevice)
printf (" (device %d)", index);
printf (": %s (%04hx:%04hx) HID++ %d.%d\n",
dev.name ().c_str (),
dev.vendorID (), dev.productID (),
major, minor);
}
catch (HIDPP10::Error e) {
if (e.errorCode () != HIDPP10::Error::UnknownDevice && e.errorCode () != HIDPP10::Error::InvalidSubID) {
Log::printf (Log::Error,
"Error while querying %s wireless device %d: %s\n",
hidraw_node, index, e.what ());
}
}
catch (HIDPP20::Error e) {
Log::printf (Log::Error, "Error while querying %s device %d: %s\n",
hidraw_node, index, e.what ());
}
catch (HIDRaw::TimeoutError e) {
Log::printf (Log::Warning, "Device %s (index %d) timed out\n",
hidraw_node, index);
}
}
}
catch (HIDPP::Device::NoHIDPPReportException e) {
}
catch (std::system_error e) {
Log::printf (Log::Warning, "Failed to open %s: %s\n", hidraw_node, e.what ());
}
udev_device_unref (device);
}
udev_enumerate_unref (enumerator);
udev_unref (ctx);
return 0;
}
int main (int argc, char *argv[])
{
static const char *args = "/dev/hidrawX feature_index function [parameters...]";
HIDPP::DeviceIndex device_index = HIDPP::DefaultDevice;
std::vector<Option> options = {
DeviceIndexOption (device_index),
VerboseOption (),
};
Option help = HelpOption (argv[0], args, &options);
options.push_back (help);
int first_arg;
if (!Option::processOptions (argc, argv, options, first_arg))
return EXIT_FAILURE;
if (argc-first_arg < 3) {
fprintf (stderr, "Too few arguments.\n");
fprintf (stderr, "%s", getUsage (argv[0], args, &options).c_str ());
return EXIT_FAILURE;
}
char *endptr;
const char *path = argv[first_arg];
int feature_index = strtol (argv[first_arg+1], &endptr, 0);
if (*endptr != '\0' || feature_index < 0 || feature_index > 255) {
fprintf (stderr, "Invalid feature index.\n");
return EXIT_FAILURE;
}
int function = strtol (argv[first_arg+2], &endptr, 0);
if (*endptr != '\0' || function < 0 || function > 15) {
fprintf (stderr, "Invalid function.\n");
return EXIT_FAILURE;
}
std::vector<uint8_t> params, results;
for (int i = 0; first_arg+3+i < argc; ++i) {
int value = strtol (argv[first_arg+3+i], &endptr, 16);
if (*endptr != '\0' || value < 0 || value > 255) {
fprintf (stderr, "Invalid parameter %d value.\n", i);
return EXIT_FAILURE;
}
params.push_back (static_cast<uint8_t> (value));
}
try {
HIDPP20::Device dev (path, device_index);
results = dev.callFunction (static_cast<uint8_t> (feature_index),
static_cast<unsigned int> (function),
params);
}
catch (HIDPP20::Error e) {
fprintf (stderr, "Error code %d: %s\n", e.errorCode (), e.what ());
return e.errorCode ();
}
bool first = true;
for (uint8_t value: results) {
if (first)
first = false;
else
printf (" ");
printf ("%02hhx", value);
}
printf ("\n");
return EXIT_SUCCESS;
}
void Help(const char *name)
{
std::cerr << "\n" << name << " Version ";
std::cerr << ssfit_VERSION_MAJOR << ".";
std::cerr << ssfit_VERSION_MINOR;
std::cerr << "\n";
std::cerr << "\n";
std::cerr << "USAGE: " << "\n";
const char *usage = "-i <input filename> -p <number> -v <number> -t <number> [-r <ranges filename>] [-R <pressure ranges filename>] [-s <save filename prefix>] [-n <number>] [--kelvin] [--curves] [--scan] [--data] [--approximate] [--fixp] [--fixv] [--fixt] [--blockdata]";
std::string USAGE = name;
USAGE += " ";
USAGE += usage;
HelpOption(USAGE.c_str(),
NULL,
NULL);
std::cerr << "OPTIONS:" << "\n";
HelpOption("--blockdata",
"-b",
"The data file is in block format.");
HelpOption("--fixp",
NULL,
"Fix Pstar to the value specified on the command line.");
HelpOption("--fixv",
NULL,
"Fix Vstar to the value specified on the command line.");
HelpOption("--fixt",
NULL,
"Fix Tstar to the value specified on the command line.");
HelpOption("--dataonly",
"--data, -d",
"Save the data in easy to plot files. This will not do any fitting.");
HelpOption("--scan",
NULL,
"Scan the fitting parameters around the minimum after and initial fitting, following by a second round of fitting.");
HelpOption("--curves",
NULL,
"Generate curves for nice plotting (see -n option).");
HelpOption("--approximate",
"--approx",
"Use an approximate equation for fitting (See documentation for more details).");
HelpOption("--kelvin",
NULL,
"The input temperatures are in Kelvin. The default is Celsius. All output temperatures are, however, in Kelvin.");
HelpOption("--input <filename>",
"-i <filename>",
"Input file containing PVT data.");
HelpOption("--ranges <filename>",
"-r <filename>",
"File specifying the temperature ranges, for each pressure, to use for fitting and curve generating.");
HelpOption("--pranges <filename>",
"-R <filename>",
"File specifying the pressure ranges, for each temperature, to use for curve generating.");
HelpOption("--pstar <number>",
"-p <number>",
"Initial Pstar value to use for fitting.");
HelpOption("--vstar <number>",
"-v <number>",
"Initial Vstar value to use for fitting.");
HelpOption("--tstar <number>",
"-t <number>",
"Initial Tstar value to use for fitting.");
HelpOption("--numpoints <number>",
"-n <number>",
"Number of points to use for curve generation.");
HelpOption("--yonly",
"-y",
"Only calculate y. Used to T < Tg. pstar, vstar, and tstar are fixed.");
HelpOption("--save <filename>",
"-s <filename>",
"Name use as prefix for saving data. If not specified then 'default' will be used. The type of data will be appended to this, for example: using '--save Polystyrene' will save data as 'Polystyrene-PVTVy.dat'.");
HelpOption("--help",
"-h",
"Show this help.");
std::cerr << "\n";
std::cerr << "Compiled on " << __DATE__;
std::cerr << " at " << __TIME__ << ".\n";
std::cerr << "Author: Brian G. Olson ([email protected])\n";
std::cerr << "https://github.com/olsonbg/ssfit\n";
}
int main (int argc, char *argv[])
{
static const char *args = "/dev/hidrawX";
HIDPP::DeviceIndex device_index = HIDPP::DefaultDevice;
bool do_write_tests = false;
std::vector<Option> options = {
DeviceIndexOption (device_index),
VerboseOption (),
Option ('w', "write",
Option::NoArgument, "",
"Also do write tests with HID++ 1.0 devices.",
[&do_write_tests] (const char *optarg) -> bool {
do_write_tests = true;
return true;
})
};
Option help = HelpOption (argv[0], args, &options);
options.push_back (help);
int first_arg;
if (!Option::processOptions (argc, argv, options, first_arg))
return EXIT_FAILURE;
if (argc-first_arg != 1) {
fprintf (stderr, "%s", getUsage (argv[0], args, &options).c_str ());
return EXIT_FAILURE;
}
const char *path = argv[first_arg];
/*
* Check protocol version
*/
unsigned int major, minor;
try {
HIDPP::Device dev (path, device_index);
dev.getProtocolVersion (major, minor);
printf ("%s (%04hx:%04hx) is a HID++ %d.%d device\n",
dev.name ().c_str (),
dev.vendorID (), dev.productID (),
major, minor);
}
catch (HIDPP::Device::NoHIDPPReportException e) {
printf ("%s is not a HID++ device\n", path);
return EXIT_FAILURE;
}
catch (std::system_error e) {
fprintf (stderr, "Failed to open %s: %s\n", path, e.what ());
return EXIT_FAILURE;
}
/*
* HID++ 1.0
*/
if (major == 1 && minor == 0) {
HIDPP10::Device dev (path, device_index);
for (unsigned int address = 0; address < 256; ++address) {
testRegister (&dev, HIDPP::ShortParamLength, static_cast<uint8_t> (address), do_write_tests);
testRegister (&dev, HIDPP::LongParamLength, static_cast<uint8_t> (address), do_write_tests);
}
if (do_write_tests) {
try {
HIDPP10::IIndividualFeatures iif (&dev);
unsigned int old_flags = iif.flags ();
iif.setFlags (0x00FFFFFF);
unsigned int flags = iif.flags ();
iif.setFlags (old_flags);
printf ("Individual features: %06x\n", flags);
if (flags & HIDPP10::IIndividualFeatures::SpecialButtonFunction) {
printf (" - Special Button Function\n");
}
if (flags & HIDPP10::IIndividualFeatures::EnhancedKeyUsage) {
printf (" - Enhanced Key Usage\n");
}
if (flags & HIDPP10::IIndividualFeatures::FastForwardRewind) {
printf (" - Fast Forward/Rewind\n");
}
if (flags & HIDPP10::IIndividualFeatures::ScrollingAcceleration) {
printf (" - Scrolling Acceleration\n");
}
if (flags & HIDPP10::IIndividualFeatures::ButtonsControlResolution) {
printf (" - Buttons Control Resolution\n");
}
if (flags & HIDPP10::IIndividualFeatures::InhibitLockKeySound) {
printf (" - Inhibit Lock KeyS ound\n");
}
if (flags & HIDPP10::IIndividualFeatures::MXAir3DEngine) {
printf (" - 3D Engine\n");
}
if (flags & HIDPP10::IIndividualFeatures::LEDControl) {
printf (" - LED Control\n");
}
}
catch (HIDPP10::Error e) {
printf ("Individual features: %s\n", e.what ());
}
}
}
/*
* HID++ 2.0 and later
*/
else if (major >= 2) {
HIDPP20::Device dev (path, device_index);
HIDPP20::IFeatureSet ifeatureset (&dev);
unsigned int feature_count = ifeatureset.getCount ();
for (unsigned int i = 1; i <= feature_count; ++i) {
uint8_t feature_index = i;
uint16_t feature_id;
bool obsolete, hidden;
feature_id = ifeatureset.getFeatureID (feature_index, &obsolete, &hidden);
printf ("Feature 0x%02hhx: [0x%04hx]", feature_index, feature_id);
if (obsolete)
printf (" obsolete");
if (hidden)
printf (" hidden");
printf ("\n");
}
}
else {
fprintf (stderr, "Unsupported HID++ protocol version.\n");
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
