337 lines
9.2 KiB
C
337 lines
9.2 KiB
C
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <unistd.h>
|
|
#include <ctype.h>
|
|
#include <time.h>
|
|
#include <string.h>
|
|
#include <strings.h>
|
|
#include <errno.h>
|
|
#include <signal.h>
|
|
#include <getopt.h>
|
|
#include <libusb-1.0/libusb.h>
|
|
|
|
#define VERSION "1.2.0"
|
|
|
|
/* TEMPer type definition */
|
|
|
|
typedef struct {
|
|
const int vendor_id;
|
|
const int product_id;
|
|
const char product_name[256];
|
|
const int check_product_name; // if set, check product name in forward match
|
|
const int has_sensor; // number of temperature sensor
|
|
const int has_humid; // flag for humidity sensor
|
|
void (*decode_func)();
|
|
float divisor;
|
|
} temper_type_t;
|
|
|
|
typedef struct {
|
|
libusb_device_handle *handle;
|
|
temper_type_t *type;
|
|
} temper_device_t;
|
|
|
|
void decode_answer();
|
|
|
|
#define TEMPER_TYPES 4
|
|
|
|
const char GetFirmware[8] = { 0x01, 0x86, 0xff, 0x01, 0x00, 0x00, 0x00, 0x00 };
|
|
const char GetTemperature[8] = { 0x01, 0x80, 0x33, 0x01, 0x00, 0x00, 0x00, 0x00 };
|
|
//#define Temperature { 0x01, 0x82, 0x77, 0x01, 0x00, 0x00, 0x00, 0x00 }
|
|
|
|
//const char uTemperature1[8] = { 0x01, 0x80, 0x33, 0x01, 0x00, 0x00, 0x00, 0x00 };
|
|
//const char uTemperature2[8] = { 0x01, 0x82, 0x77, 0x01, 0x00, 0x00, 0x00, 0x00 };
|
|
//const char uTemperature3[8] = { 0x01, 0x86, 0xff, 0x01, 0x00, 0x00, 0x00, 0x00 };
|
|
|
|
|
|
temper_type_t tempers[TEMPER_TYPES] = {
|
|
{0x1a86, 0xe025, "TEMPerGold", 1, 1, 0, decode_answer, 100.0},
|
|
{0x0c45, 0x7401, "TEMPer2", 1, 2, 0, decode_answer, 256.0},
|
|
{0x0c45, 0x7401, "TEMPer1", 0, 1, 0, decode_answer, 256.0},
|
|
//{0x0c45, 0x7402, "TEMPerHUM", 0, 1, 1, decode_answer_sht1x, 100.0},
|
|
};
|
|
|
|
/* memo: TEMPer2 cannot be distinguished with VID:PID,
|
|
thus product name (like TEMPer2V1.3) should be checked. */
|
|
|
|
/* global variables */
|
|
|
|
#define MAX_DEV 8
|
|
|
|
#define INTERFACE1 0x00
|
|
#define INTERFACE2 0x01
|
|
|
|
const int reqIntLen = 8;
|
|
const int endpoint_Int_out = 0x02;
|
|
const int endpoint_Int_in = 0x82;
|
|
const int timeout = 300; /* timeout in ms */
|
|
|
|
static int bsalir = 1;
|
|
static int debug = 0;
|
|
|
|
static libusb_context *ctx = NULL;
|
|
|
|
/* functions */
|
|
|
|
void bad(const char *why) {
|
|
fprintf(stderr, "Fatal error> %s\n", why);
|
|
exit(17);
|
|
}
|
|
|
|
void usb_detach(libusb_device_handle *lvr_winusb, int iInterface) {
|
|
int ret;
|
|
|
|
ret = libusb_detach_kernel_driver(lvr_winusb, iInterface);
|
|
if (ret) {
|
|
if (errno == ENODATA) {
|
|
if (debug) {
|
|
fprintf(stderr, "Device already detached\n");
|
|
}
|
|
} else {
|
|
if (debug) {
|
|
fprintf(stderr, "Detach failed: %s[%d]\n", strerror(errno), errno);
|
|
fprintf(stderr, "Continuing anyway\n");
|
|
}
|
|
}
|
|
} else {
|
|
if (debug) {
|
|
fprintf(stderr, "detach successful\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
int find_lvr_winusb(temper_device_t *devices) {
|
|
int i, j, s, cnt, numdev;
|
|
libusb_device **devs;
|
|
|
|
//handle = libusb_open_device_with_vid_pid(ctx, VENDOR_ID, PRODUCT_ID);
|
|
|
|
cnt = libusb_get_device_list(ctx, &devs);
|
|
if (cnt < 1) {
|
|
fprintf(stderr, "Could not find USB device: %d\n", cnt);
|
|
}
|
|
|
|
numdev = 0;
|
|
for (i = 0; i < cnt && numdev < MAX_DEV; i++) {
|
|
struct libusb_device_descriptor desc;
|
|
|
|
if ((s = libusb_get_device_descriptor(devs[i], &desc)) < 0) {
|
|
fprintf(stderr, "Could not get USB device descriptor: %d\n", s);
|
|
continue;
|
|
}
|
|
|
|
for (j = 0; j < TEMPER_TYPES; j++) {
|
|
if (desc.idVendor == tempers[j].vendor_id && desc.idProduct == tempers[j].product_id) {
|
|
unsigned char bus, addr, descmanu[256], descprod[256], descseri[256];
|
|
|
|
bus = libusb_get_bus_number(devs[i]);
|
|
addr = libusb_get_device_address(devs[i]);
|
|
|
|
if ((s = libusb_open(devs[i], &devices[numdev].handle)) < 0) {
|
|
fprintf(stderr, "Could not open USB device: %d\n", s);
|
|
continue;
|
|
}
|
|
|
|
libusb_get_string_descriptor_ascii(devices[numdev].handle, desc.iManufacturer, descmanu, 256);
|
|
libusb_get_string_descriptor_ascii(devices[numdev].handle, desc.iProduct, descprod, 256);
|
|
libusb_get_string_descriptor_ascii(devices[numdev].handle, desc.iSerialNumber, descseri, 256);
|
|
|
|
if (tempers[j].check_product_name) {
|
|
if (strncmp((const char *)descprod, tempers[j].product_name, strlen(tempers[j].product_name)) == 0) {
|
|
devices[numdev].type = &tempers[j];
|
|
} else {
|
|
// vid and pid match, but product name unmatch
|
|
libusb_close(devices[numdev].handle);
|
|
continue;
|
|
}
|
|
} else {
|
|
devices[numdev].type = &tempers[j];
|
|
}
|
|
|
|
if (debug) {
|
|
fprintf(stderr, "lvr_winusb with Bus:%03d Addr:%03d VendorID:%04x ProductID:%04x Manufacturer:%s Product:%s Serial:%s found.\n",
|
|
bus, addr, desc.idVendor, desc.idProduct, descmanu, descprod, descseri);
|
|
}
|
|
|
|
numdev++;
|
|
}
|
|
}
|
|
}
|
|
|
|
libusb_free_device_list(devs, 1);
|
|
|
|
return numdev;
|
|
}
|
|
|
|
int setup_libusb_access(temper_device_t *devices) {
|
|
int log_level = 0;
|
|
int numdev;
|
|
|
|
libusb_init(&ctx);
|
|
|
|
if (debug) {
|
|
log_level = 4;
|
|
}
|
|
#if LIBUSBX_API_VERSION < 0x01000106
|
|
libusb_set_debug(ctx, log_level);
|
|
#else
|
|
libusb_set_option(ctx, LIBUSB_OPTION_LOG_LEVEL, log_level);
|
|
#endif
|
|
|
|
if ((numdev = find_lvr_winusb(devices)) < 1) {
|
|
fprintf(stderr, "Couldn't find the USB device, Exiting: %d\n", numdev);
|
|
return -1;
|
|
}
|
|
|
|
for (int i = 0; i < numdev; i++) {
|
|
usb_detach(devices[i].handle, INTERFACE1);
|
|
usb_detach(devices[i].handle, INTERFACE2);
|
|
//libusb_reset_device(devices[i].handle);
|
|
|
|
if (libusb_set_configuration(devices[i].handle, 0x01) < 0) {
|
|
fprintf(stderr, "Could not set configuration 1\n");
|
|
return -1;
|
|
}
|
|
|
|
int s;
|
|
if ((s = libusb_claim_interface(devices[i].handle, INTERFACE1)) < 0) {
|
|
fprintf(stderr, "Could not claim interface. Error:%d\n", s);
|
|
return -1;
|
|
}
|
|
|
|
if ((s = libusb_claim_interface(devices[i].handle, INTERFACE2)) < 0) {
|
|
fprintf(stderr, "Could not claim interface. Error:%d\n", s);
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
return numdev;
|
|
}
|
|
|
|
void control_transfer(libusb_device_handle *dev, const char *pquestion) {
|
|
int r, i;
|
|
|
|
char question[reqIntLen];
|
|
|
|
memcpy(question, pquestion, sizeof question);
|
|
|
|
r = libusb_control_transfer(dev, 0x21, 0x09, 0x0200, 0x01, (unsigned char *)question, reqIntLen, timeout);
|
|
if (r < 0) {
|
|
perror("USB control write");
|
|
return;
|
|
}
|
|
|
|
if (debug) {
|
|
for (i = 0; i < reqIntLen; i++)
|
|
fprintf(stderr, "%02x ", question[i] & 0xFF);
|
|
fprintf(stderr, "\n");
|
|
}
|
|
}
|
|
|
|
void interrupt_read(libusb_device_handle *dev, unsigned char *answer, const char *pquestion, const char *product_name) {
|
|
int r, s, i;
|
|
char question[reqIntLen];
|
|
|
|
memset(answer, 0, reqIntLen);
|
|
memcpy(question, pquestion, sizeof question);
|
|
|
|
s = libusb_interrupt_transfer(dev, endpoint_Int_in, answer, reqIntLen, &r, timeout);
|
|
|
|
if (strcmp(product_name, "TEMPerGold") == 0) {
|
|
libusb_interrupt_transfer(dev, endpoint_Int_out, (unsigned char *)question, reqIntLen, &r, timeout);
|
|
s = libusb_interrupt_transfer(dev, endpoint_Int_in, answer, reqIntLen, &r, timeout);
|
|
}
|
|
|
|
if (s != 0) {
|
|
fprintf(stderr, "USB read failed: %s\n", libusb_error_name(s));
|
|
perror("USB interrupt read");
|
|
exit(1);
|
|
return;
|
|
}
|
|
|
|
if (debug) {
|
|
for (i = 0; i < reqIntLen; i++)
|
|
fprintf(stderr, "%02x ", answer[i] & 0xFF);
|
|
|
|
fprintf(stderr, "\n");
|
|
}
|
|
}
|
|
|
|
void cleanup_usb_devices(temper_device_t *devices, int numdev) {
|
|
for (int i = 0; i < numdev; i++) {
|
|
libusb_release_interface(devices[i].handle, INTERFACE1);
|
|
libusb_release_interface(devices[i].handle, INTERFACE2);
|
|
|
|
libusb_attach_kernel_driver(devices[i].handle, INTERFACE1);
|
|
libusb_attach_kernel_driver(devices[i].handle, INTERFACE2);
|
|
|
|
libusb_close(devices[i].handle);
|
|
}
|
|
|
|
libusb_exit(ctx);
|
|
}
|
|
|
|
void ex_program() {
|
|
bsalir = 1;
|
|
|
|
(void)signal(SIGINT, SIG_DFL);
|
|
}
|
|
|
|
void decode_answer(unsigned char *answer, float *divisor, float *tempd, float *calibration) {
|
|
int buf;
|
|
|
|
// temp C internal
|
|
buf = ((signed char)answer[2] << 8) + (answer[3] & 0xFF);
|
|
tempd[0] = buf / *divisor;
|
|
tempd[0] = tempd[0] * calibration[0] + calibration[1];
|
|
|
|
// temp C external
|
|
buf = ((signed char)answer[4] << 8) + (answer[5] & 0xFF);
|
|
tempd[1] = buf / *divisor;
|
|
tempd[1] = tempd[1] * calibration[0] + calibration[1];
|
|
}
|
|
|
|
/*
|
|
void decode_answer_sht1x(unsigned char *answer, float *divisor, float *tempd, float *calibration) {
|
|
int buf;
|
|
|
|
// temp C
|
|
buf = ((signed char)answer[2] << 8) + (answer[3] & 0xFF);
|
|
tempd[0] = -39.7 + 0.01 * buf;
|
|
tempd[0] = tempd[0] * calibration[0] + calibration[1];
|
|
|
|
// relative humidity
|
|
buf = ((signed char)answer[4] << 8) + (answer[5] & 0xFF);
|
|
tempd[1] = -2.0468 + 0.0367 * buf - 1.5955e-6 * buf * buf;
|
|
tempd[1] = (tempd[0] - 25) * (0.01 + 0.00008 * buf) + tempd[1];
|
|
if (tempd[1] < 0)
|
|
tempd[1] = 0;
|
|
if (tempd[1] > 99)
|
|
tempd[1] = 100;
|
|
}
|
|
*/
|
|
|
|
float get_temp_c() {
|
|
temper_device_t *devices;
|
|
int numdev;
|
|
int i = 0;
|
|
unsigned char *answer;
|
|
float tempd[2];
|
|
float calibration[2] = {1, 0};
|
|
|
|
devices = calloc(MAX_DEV, sizeof(temper_device_t));
|
|
if ((numdev = setup_libusb_access(devices)) < 1) {
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
(void)signal(SIGINT, ex_program);
|
|
|
|
answer = calloc(reqIntLen, sizeof(unsigned char));
|
|
|
|
control_transfer(devices[i].handle, GetTemperature);
|
|
interrupt_read(devices[i].handle, answer, GetTemperature, devices[i].type->product_name);
|
|
devices[i].type->decode_func(answer, &devices[i].type->divisor, tempd, calibration);
|
|
|
|
cleanup_usb_devices(devices, numdev);
|
|
|
|
return tempd[0];
|
|
} |