elksmart-comm: adjust code style
This commit is contained in:
parent
26b38ecb88
commit
f68bf51234
GPG Key ID:
A0420B94F92B9493
183
elksmart-comm.c
183
elksmart-comm.c
@ -35,14 +35,12 @@ find_device (int vendor, int product, int *error)
|
||||
int result = 0;
|
||||
|
||||
ssize_t len = libusb_get_device_list(NULL, &list);
|
||||
if (len < 0)
|
||||
{
|
||||
if (len < 0) {
|
||||
result = len;
|
||||
goto out;
|
||||
}
|
||||
|
||||
for (ssize_t i = 0; i < len; i++)
|
||||
{
|
||||
for (ssize_t i = 0; i < len; i++) {
|
||||
libusb_device *device = list[i];
|
||||
struct libusb_device_descriptor desc = {};
|
||||
if ((result = libusb_get_device_descriptor(device, &desc)))
|
||||
@ -80,16 +78,15 @@ read_hex (const char *string, struct str *out)
|
||||
{
|
||||
static const char *alphabet = "0123456789abcdef";
|
||||
str_reset(out);
|
||||
while (true)
|
||||
{
|
||||
while (true) {
|
||||
while (*string && strchr(" \t\n\r\v\f", *string))
|
||||
string++;
|
||||
if (!*string)
|
||||
return true;
|
||||
|
||||
const char *hi, *lo;
|
||||
if (!(hi = strchr (alphabet, tolower_ascii (*string++))) || !*string
|
||||
|| !(lo = strchr (alphabet, tolower_ascii (*string++))))
|
||||
if (!(hi = strchr(alphabet, tolower_ascii(*string++))) || !*string ||
|
||||
!(lo = strchr(alphabet, tolower_ascii(*string++))))
|
||||
return false;
|
||||
|
||||
str_pack_u8(out, (hi - alphabet) << 4 | (lo - alphabet));
|
||||
@ -99,7 +96,9 @@ read_hex (const char *string, struct str *out)
|
||||
// --- Coding ------------------------------------------------------------------
|
||||
|
||||
// Values are in microseconds.
|
||||
struct pulse { unsigned on, off; };
|
||||
struct pulse {
|
||||
unsigned on, off;
|
||||
};
|
||||
|
||||
static bool
|
||||
pulse_equal(struct pulse a, struct pulse b)
|
||||
@ -111,11 +110,9 @@ static size_t
|
||||
decode_learned_direct(const uint8_t *b, size_t b_len, struct pulse *pulses)
|
||||
{
|
||||
size_t pulses_len = 0;
|
||||
for (size_t i = 0; i < b_len; )
|
||||
{
|
||||
for (size_t i = 0; i < b_len;) {
|
||||
struct pulse *pulse = &pulses[pulses_len++];
|
||||
while (b[i] == 0xff)
|
||||
{
|
||||
while (b[i] == 0xff) {
|
||||
pulse->on += 4080;
|
||||
if (++i == b_len)
|
||||
return 0;
|
||||
@ -126,8 +123,7 @@ decode_learned_direct (const uint8_t *b, size_t b_len, struct pulse *pulses)
|
||||
if (i == b_len)
|
||||
break;
|
||||
|
||||
while (b[i] == 0xff)
|
||||
{
|
||||
while (b[i] == 0xff) {
|
||||
pulse->off += 4080;
|
||||
if (++i == b_len)
|
||||
return 0;
|
||||
@ -142,9 +138,8 @@ decode_learned (const struct str *code, size_t *len, struct error **e)
|
||||
{
|
||||
// This conveniently has an upper bound.
|
||||
struct pulse *pulses = xcalloc(code->len, sizeof *pulses);
|
||||
if (!(*len = decode_learned_direct
|
||||
((const uint8_t *) code->str, code->len, pulses)))
|
||||
{
|
||||
if (!(*len = decode_learned_direct(
|
||||
(const uint8_t *) code->str, code->len, pulses))) {
|
||||
error_set(e, "code ends unexpectedly");
|
||||
free(pulses);
|
||||
return NULL;
|
||||
@ -164,8 +159,7 @@ encode_nec_byte (struct pulse *p, uint8_t byte)
|
||||
static struct pulse *
|
||||
encode_nec(const struct str *code, size_t *len, struct error **e)
|
||||
{
|
||||
if (code->len % 2)
|
||||
{
|
||||
if (code->len % 2) {
|
||||
error_set(e, "NEC transmission format requires pairs");
|
||||
return NULL;
|
||||
}
|
||||
@ -173,8 +167,7 @@ encode_nec (const struct str *code, size_t *len, struct error **e)
|
||||
// The timings seem to be rather tolerant.
|
||||
*len = code->len / 2 * (1 /* leader */ + 32 + 1 /* stop */);
|
||||
struct pulse *pulses = xcalloc(*len, sizeof *pulses), *p = pulses;
|
||||
for (size_t i = 0; i < code->len; i += 2)
|
||||
{
|
||||
for (size_t i = 0; i < code->len; i += 2) {
|
||||
*p++ = (struct pulse) {.on = 8500, .off = 4250};
|
||||
p = encode_nec_byte(p, code->str[i + 0]);
|
||||
p = encode_nec_byte(p, ~code->str[i + 0]);
|
||||
@ -188,21 +181,19 @@ encode_nec (const struct str *code, size_t *len, struct error **e)
|
||||
static void
|
||||
compress_value(unsigned value, struct str *encoded)
|
||||
{
|
||||
if (value <= 2032)
|
||||
{
|
||||
if (value <= 2032) {
|
||||
// We fix a minor problem in the original Ocrustar algorithm.
|
||||
uint8_t v = value / 16. + .5;
|
||||
str_pack_u8(encoded, MAX(2, v));
|
||||
}
|
||||
else
|
||||
do
|
||||
{
|
||||
} else {
|
||||
do {
|
||||
uint8_t v = value & 0x7f;
|
||||
if ((value >>= 7))
|
||||
v |= 0x80;
|
||||
str_pack_u8(encoded, v);
|
||||
} while (value);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
compress_pulses (const struct pulse *pulses, size_t len, struct str *encoded)
|
||||
@ -220,8 +211,8 @@ compress_pulses (const struct pulse *pulses, size_t len, struct str *encoded)
|
||||
if (counts[i] > counts[top1])
|
||||
p1 = pulses[top1 = i];
|
||||
for (size_t i = 0; i < len; i++)
|
||||
if (counts[i] < counts[top1]
|
||||
&& counts[i] > counts[top2])
|
||||
if (counts[i] < counts[top1] &&
|
||||
counts[i] > counts[top2])
|
||||
p2 = pulses[top2 = i];
|
||||
else if (counts[top2] == counts[top1])
|
||||
p2 = pulses[top2 = i];
|
||||
@ -238,14 +229,12 @@ compress_pulses (const struct pulse *pulses, size_t len, struct str *encoded)
|
||||
str_pack_u8(encoded, -1);
|
||||
str_pack_u8(encoded, -1);
|
||||
|
||||
for (size_t i = 0; i < len; i++)
|
||||
{
|
||||
if (pulse_equal (pulses[i], p1))
|
||||
for (size_t i = 0; i < len; i++) {
|
||||
if (pulse_equal(pulses[i], p1)) {
|
||||
str_pack_u8(encoded, 0);
|
||||
else if (pulse_equal (pulses[i], p2))
|
||||
} else if (pulse_equal(pulses[i], p2)) {
|
||||
str_pack_u8(encoded, 1);
|
||||
else
|
||||
{
|
||||
} else {
|
||||
compress_value(pulses[i].on, encoded);
|
||||
compress_value(pulses[i].off, encoded);
|
||||
}
|
||||
@ -254,8 +243,7 @@ compress_pulses (const struct pulse *pulses, size_t len, struct str *encoded)
|
||||
|
||||
// --- Device interaction ------------------------------------------------------
|
||||
|
||||
enum
|
||||
{
|
||||
enum {
|
||||
USB_VENDOR_SMTCTL = 0x045c,
|
||||
|
||||
// 0x134 (EKX5S ~ 5s, 5th generation remote)
|
||||
@ -274,12 +262,10 @@ static uint8_t
|
||||
c_stop[] = {-3, -3, -3, -3},
|
||||
c_identify[] = {-4, -4, -4, -4};
|
||||
|
||||
static struct
|
||||
{
|
||||
static struct {
|
||||
unsigned char endpoint_out; ///< Outgoing endpoint
|
||||
unsigned char endpoint_in; ///< Incoming endpoint
|
||||
}
|
||||
g;
|
||||
} g;
|
||||
|
||||
static bool
|
||||
init_device_from_desc(struct libusb_config_descriptor *desc, struct error **e)
|
||||
@ -297,15 +283,13 @@ init_device_from_desc (struct libusb_config_descriptor *desc, struct error **e)
|
||||
return error_set(e, "unexpected endpoint count");
|
||||
|
||||
bool have_out = false, have_in = false;
|
||||
for (uint8_t i = 0; i < asd->bNumEndpoints; i++)
|
||||
{
|
||||
for (uint8_t i = 0; i < asd->bNumEndpoints; i++) {
|
||||
const struct libusb_endpoint_descriptor *epd = asd->endpoint + i;
|
||||
if ((epd->bmAttributes & LIBUSB_TRANSFER_TYPE_MASK)
|
||||
!= LIBUSB_ENDPOINT_TRANSFER_TYPE_BULK)
|
||||
if ((epd->bmAttributes & LIBUSB_TRANSFER_TYPE_MASK) !=
|
||||
LIBUSB_ENDPOINT_TRANSFER_TYPE_BULK)
|
||||
return error_set(e, "unexpected endpoint transfer type");
|
||||
|
||||
switch ((epd->bEndpointAddress & LIBUSB_ENDPOINT_DIR_MASK))
|
||||
{
|
||||
switch ((epd->bEndpointAddress & LIBUSB_ENDPOINT_DIR_MASK)) {
|
||||
break; case LIBUSB_ENDPOINT_OUT:
|
||||
have_out = true;
|
||||
g.endpoint_out = epd->bEndpointAddress;
|
||||
@ -346,8 +330,7 @@ static uint8_t
|
||||
mangle(uint8_t value)
|
||||
{
|
||||
uint8_t reversed = 0;
|
||||
for (int i = 0; i < 8; i++)
|
||||
{
|
||||
for (int i = 0; i < 8; i++) {
|
||||
reversed = (reversed << 1) | (value & 1);
|
||||
value >>= 1;
|
||||
}
|
||||
@ -368,8 +351,7 @@ send_transmit (libusb_device_handle *device, unsigned long frequency,
|
||||
const struct pulse *pulses, size_t pulses_len, struct error **e)
|
||||
{
|
||||
if (g_debug_mode)
|
||||
for (size_t i = 0; i < pulses_len; )
|
||||
{
|
||||
for (size_t i = 0; i < pulses_len;) {
|
||||
printf("%u,%u", pulses[i].on, pulses[i].off);
|
||||
putchar(++i == pulses_len ? '\n' : ',');
|
||||
}
|
||||
@ -391,21 +373,18 @@ send_transmit (libusb_device_handle *device, unsigned long frequency,
|
||||
size_t i = 0;
|
||||
uint8_t buffer[64];
|
||||
bool ok = true;
|
||||
while (i != message.len)
|
||||
{
|
||||
while (i != message.len) {
|
||||
size_t chunk = MIN(62, message.len - i);
|
||||
memcpy(buffer, message.str + i, chunk);
|
||||
i += chunk;
|
||||
if (chunk == 62)
|
||||
{
|
||||
if (chunk == 62) {
|
||||
buffer[chunk] = checksum(buffer, chunk);
|
||||
chunk++;
|
||||
}
|
||||
|
||||
int result = 0, len = 0;
|
||||
if ((result = libusb_bulk_transfer (device, g.endpoint_out,
|
||||
buffer, chunk, &len, 100)))
|
||||
{
|
||||
if ((result = libusb_bulk_transfer(
|
||||
device, g.endpoint_out, buffer, chunk, &len, 100))) {
|
||||
ok = error_set(e, "send: %s", libusb_strerror(result));
|
||||
break;
|
||||
}
|
||||
@ -432,17 +411,14 @@ try_to_depulse (const struct str *code)
|
||||
return;
|
||||
|
||||
struct pulse *p = pulses, *end = p + len;
|
||||
while (p != end && pulse_is_likely_leader (p))
|
||||
{
|
||||
while (p != end && pulse_is_likely_leader(p)) {
|
||||
p++;
|
||||
printf("Attempted pulse decode:\n");
|
||||
|
||||
uint8_t bits = 0, nibble = 0;
|
||||
for (; p != end && !pulse_is_likely_leader (p); p++)
|
||||
{
|
||||
for (; p != end && !pulse_is_likely_leader(p); p++) {
|
||||
nibble = nibble << 1 | (p->off > 2 * p->on);
|
||||
if (++bits == 4)
|
||||
{
|
||||
if (++bits == 4) {
|
||||
putchar("0123456789abcdef"[nibble]);
|
||||
bits = nibble = 0;
|
||||
}
|
||||
@ -457,9 +433,8 @@ recv_learn (libusb_device_handle *device, struct str *data, struct error **e)
|
||||
{
|
||||
uint8_t buffer[64] = {};
|
||||
int result = 0, len = 0;
|
||||
while ((result = libusb_bulk_transfer (device, g.endpoint_in,
|
||||
buffer, sizeof buffer, &len, 100)))
|
||||
{
|
||||
while ((result = libusb_bulk_transfer(
|
||||
device, g.endpoint_in, buffer, sizeof buffer, &len, 100))) {
|
||||
if (result != LIBUSB_ERROR_TIMEOUT)
|
||||
return error_set(e, "learn/recv: %s", libusb_strerror(result));
|
||||
print_debug("learn/recv: %s", libusb_strerror(result));
|
||||
@ -475,16 +450,14 @@ recv_learn (libusb_device_handle *device, struct str *data, struct error **e)
|
||||
|
||||
str_append_data(data, buffer + 6, len - 6);
|
||||
dump_hex((const unsigned char *) data->str, data->len);
|
||||
while (data->len < size)
|
||||
{
|
||||
if (!(result = libusb_bulk_transfer (device, g.endpoint_in,
|
||||
buffer, sizeof buffer, &len, 100)))
|
||||
{
|
||||
while (data->len < size) {
|
||||
if (!(result = libusb_bulk_transfer(
|
||||
device, g.endpoint_in, buffer, sizeof buffer, &len, 100))) {
|
||||
dump_hex(buffer, len);
|
||||
|
||||
str_append_data(data, buffer, len);
|
||||
print_debug ("learn: received %d (have %zu of %zu)",
|
||||
len, data->len, size);
|
||||
print_debug(
|
||||
"learn: received %d (have %zu of %zu)", len, data->len, size);
|
||||
continue;
|
||||
}
|
||||
if (result != LIBUSB_ERROR_TIMEOUT)
|
||||
@ -496,8 +469,8 @@ recv_learn (libusb_device_handle *device, struct str *data, struct error **e)
|
||||
|
||||
// As far as I know, this doesn't do anything,
|
||||
// and the device doesn't accept it while scanning infrared codes either.
|
||||
if ((result = libusb_bulk_transfer (device, g.endpoint_out,
|
||||
c_stop, sizeof c_stop, &len, 100)))
|
||||
if ((result = libusb_bulk_transfer(
|
||||
device, g.endpoint_out, c_stop, sizeof c_stop, &len, 100)))
|
||||
return error_set(e, "learn/send: %s", libusb_strerror(result));
|
||||
return true;
|
||||
}
|
||||
@ -506,8 +479,8 @@ static bool
|
||||
send_learn(libusb_device_handle *device, struct error **e)
|
||||
{
|
||||
int result = 0, len = 0;
|
||||
if ((result = libusb_bulk_transfer (device, g.endpoint_out,
|
||||
c_learn, sizeof c_learn, &len, 100)))
|
||||
if ((result = libusb_bulk_transfer(
|
||||
device, g.endpoint_out, c_learn, sizeof c_learn, &len, 100)))
|
||||
return error_set(e, "learn/send: %s", libusb_strerror(result));
|
||||
|
||||
printf("Reading remote control codes.\n");
|
||||
@ -518,8 +491,7 @@ send_learn (libusb_device_handle *device, struct error **e)
|
||||
|
||||
struct str data = str_make();
|
||||
bool ok = recv_learn(device, &data, e);
|
||||
if (ok)
|
||||
{
|
||||
if (ok) {
|
||||
printf("Full command:\n");
|
||||
dump_hex((const unsigned char *) data.str, data.len);
|
||||
try_to_depulse(&data);
|
||||
@ -536,20 +508,20 @@ send_identify (libusb_device_handle *device, struct error **e)
|
||||
{
|
||||
uint8_t buffer[64] = {};
|
||||
int result = 0, len = 0;
|
||||
while (!(result = libusb_bulk_transfer (device, g.endpoint_in,
|
||||
buffer, sizeof buffer, &len, 10)))
|
||||
while (!(result = libusb_bulk_transfer(
|
||||
device, g.endpoint_in, buffer, sizeof buffer, &len, 10)))
|
||||
/* Flush buffers. */;
|
||||
|
||||
if ((result = libusb_bulk_transfer (device, g.endpoint_out,
|
||||
c_identify, sizeof c_identify, &len, 100)))
|
||||
if ((result = libusb_bulk_transfer(
|
||||
device, g.endpoint_out, c_identify, sizeof c_identify, &len, 100)))
|
||||
return error_set(e, "identify/send: %s", libusb_strerror(result));
|
||||
if ((result = libusb_bulk_transfer (device, g.endpoint_in,
|
||||
buffer, sizeof buffer, &len, 100)))
|
||||
if ((result = libusb_bulk_transfer(
|
||||
device, g.endpoint_in, buffer, sizeof buffer, &len, 100)))
|
||||
return error_set(e, "identify/recv: %s", libusb_strerror(result));
|
||||
|
||||
// XXX: Sometimes, the device doesn't send any identification values.
|
||||
if (len != 6 || memcmp (buffer, c_identify, sizeof c_identify)
|
||||
|| buffer[4] != 0x70 || buffer[5] != 0x01)
|
||||
if (len != 6 || memcmp(buffer, c_identify, sizeof c_identify) ||
|
||||
buffer[4] != 0x70 || buffer[5] != 0x01)
|
||||
return error_set(e, "device busy or not supported");
|
||||
|
||||
#if 0
|
||||
@ -561,8 +533,8 @@ send_identify (libusb_device_handle *device, struct error **e)
|
||||
if ((result = libusb_bulk_transfer (device, g.endpoint_in,
|
||||
buffer, sizeof buffer, &len, 100)))
|
||||
return error_set (e, "serial/recv: %s", libusb_strerror (result));
|
||||
if (len < (int) sizeof c_serial
|
||||
|| memcmp (buffer, c_serial, sizeof c_serial))
|
||||
if (len < (int) sizeof c_serial ||
|
||||
memcmp (buffer, c_serial, sizeof c_serial))
|
||||
return error_set (e, "serial retrieval failed");
|
||||
#endif
|
||||
return true;
|
||||
@ -579,10 +551,8 @@ run (libusb_device_handle *device, unsigned long frequency, bool nec,
|
||||
|
||||
struct str code = str_make();
|
||||
bool ok = true;
|
||||
for (size_t i = 0; i < codes_len; i++)
|
||||
{
|
||||
if (!read_hex (codes[i], &code))
|
||||
{
|
||||
for (size_t i = 0; i < codes_len; i++) {
|
||||
if (!read_hex(codes[i], &code)) {
|
||||
ok = error_set(e, "invalid hex string");
|
||||
break;
|
||||
}
|
||||
@ -610,23 +580,20 @@ main (int argc, char *argv[])
|
||||
{
|
||||
unsigned long frequency = 38000;
|
||||
bool nec = false;
|
||||
static const struct opt opts[] =
|
||||
{
|
||||
static const struct opt opts[] = {
|
||||
{'d', "debug", NULL, 0, "run in debug mode"},
|
||||
{'f', "frequency", "HZ", 0, "frequency (38000 Hz by default)"},
|
||||
{'n', "nec", NULL, 0, "use the NEC transmission format"},
|
||||
{'h', "help", NULL, 0, "display this help and exit"},
|
||||
{'V', "version", NULL, 0, "output version information and exit"},
|
||||
{ 0, NULL, NULL, 0, NULL }
|
||||
};
|
||||
{0, NULL, NULL, 0, NULL}};
|
||||
|
||||
struct opt_handler oh = opt_handler_make(argc, argv, opts, "[COMMAND...]",
|
||||
"Transmit or receive infrared commands.");
|
||||
|
||||
int c;
|
||||
while ((c = opt_handler_get(&oh)) != -1)
|
||||
switch (c)
|
||||
{
|
||||
switch (c) {
|
||||
case 'd':
|
||||
g_debug_mode = true;
|
||||
break;
|
||||
@ -657,8 +624,7 @@ main (int argc, char *argv[])
|
||||
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
||||
|
||||
#if LIBUSB_API_VERSION >= 0x0100010A
|
||||
const struct libusb_init_option option =
|
||||
{
|
||||
const struct libusb_init_option option = {
|
||||
.option = LIBUSB_OPTION_LOG_LEVEL,
|
||||
.value.ival = LIBUSB_LOG_LEVEL_DEBUG,
|
||||
};
|
||||
@ -671,11 +637,11 @@ main (int argc, char *argv[])
|
||||
|
||||
libusb_device_handle *device = NULL;
|
||||
if (!device && !result)
|
||||
device = find_device (USB_VENDOR_SMTCTL,
|
||||
USB_PRODUCT_SMTCTL_SMART_EKX4S, &result);
|
||||
device = find_device(
|
||||
USB_VENDOR_SMTCTL, USB_PRODUCT_SMTCTL_SMART_EKX4S, &result);
|
||||
if (!device && !result)
|
||||
device = find_device (USB_VENDOR_SMTCTL,
|
||||
USB_PRODUCT_SMTCTL_SMART_EKX5S_T, &result);
|
||||
device = find_device(
|
||||
USB_VENDOR_SMTCTL, USB_PRODUCT_SMTCTL_SMART_EKX5S_T, &result);
|
||||
|
||||
if (result)
|
||||
exit_fatal("couldn't open device: %s", libusb_strerror(result));
|
||||
@ -688,8 +654,7 @@ main (int argc, char *argv[])
|
||||
if ((result = libusb_claim_interface(device, USB_INTERFACE)) == 1)
|
||||
exit_fatal("couldn't claim interface: %s", libusb_strerror(result));
|
||||
|
||||
if (!run (device, frequency, nec, argv, argc, &e))
|
||||
{
|
||||
if (!run(device, frequency, nec, argv, argc, &e)) {
|
||||
print_error("%s", e->message);
|
||||
error_free(e);
|
||||
}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user