bool ScanDataBuilder::Parse(char*& buffer, size_t& size) {
char* prev_buf = NULL;
bool success;
while (method_index <= 25) {
// std::cout << "method index: " << method_index <<std::endl;
prev_buf = buffer;
switch (method_index) {
case -1:
success = parse_byte(buffer, size, lms100_cola::STX_BYTE);
break;
case 0:
success = parse_command_type(buffer, size, data);
break;
case 1:
success = parse_command(buffer, size, data);
break;
case 2:
success = parse_version_number(buffer, size, data);
break;
case 3:
success = parse_device_number(buffer, size, data);
break;
case 4:
success = parse_serial_number(buffer, size, data);
break;
case 5:
success = parse_device_status(buffer, size, data);
break;
case 6:
success = parse_telegram_counter(buffer, size, data);
break;
case 7:
success = parse_scan_counter(buffer, size, data);
break;
case 8:
success = parse_time_since_startup(buffer, size, data);
break;
case 9:
success = parse_time_of_transmission(buffer, size, data);
break;
case 10:
success = parse_status_of_digital_inputs(buffer, size, data);
break;
case 11:
success = parse_status_of_digital_outputs(buffer, size, data);
break;
case 12:
success = parse_reserved_byte(buffer, size, data);
break;
case 13:
success = parse_scan_frequency(buffer, size, data);
break;
case 14:
success = parse_measurement_frequency(buffer, size, data);
break;
case 15:
success = parse_encoders(buffer, size, data);
break;
case 16:
success = parse_amount_of_16_bit_channels(buffer, size, data);
break;
case 17:
success = parse_content(buffer, size, data);
break;
case 18:
success = parse_scale_factor(buffer, size, data);
break;
case 19:
success = parse_scale_factor_offset(buffer, size, data);
break;
case 20:
success = parse_start_angle(buffer, size, data);
break;
case 21:
success = parse_steps(buffer, size, data);
break;
case 22:
success = parse_amount_of_data(buffer, size, data);
break;
case 23:
success = parse_data(buffer, size, data);
break;
case 24:
success = parse_irrelevant_data(buffer, size);
break;
case 25:
success = parse_byte(buffer, size, lms100_cola::ETX_BYTE);
break;
default:
return false;
}
// method didn't have enough data to parse
if (!success) {
return false;
}
method_index += 1;
}
return true;
}
static struct jaylink_device *probe_device(struct jaylink_context *ctx,
struct libusb_device *usb_dev)
{
int ret;
struct libusb_device_descriptor desc;
struct libusb_device_handle *usb_devh;
struct jaylink_device *dev;
char buf[USB_SERIAL_NUMBER_LENGTH + 1];
uint8_t usb_address;
uint32_t serial_number;
bool valid_serial_number;
bool found_device;
size_t i;
ret = libusb_get_device_descriptor(usb_dev, &desc);
if (ret != LIBUSB_SUCCESS) {
log_warn(ctx, "Failed to get device descriptor: %s.",
libusb_error_name(ret));
return NULL;
}
if (desc.idVendor != USB_VENDOR_ID)
return NULL;
found_device = false;
for (i = 0; i < sizeof(pids) / sizeof(pids[0]); i++) {
if (pids[i][0] == desc.idProduct) {
found_device = true;
usb_address = pids[i][1];
break;
}
}
if (!found_device)
return NULL;
log_dbg(ctx, "Found device (VID:PID = %04x:%04x, bus:address = "
"%03u:%03u).", desc.idVendor, desc.idProduct,
libusb_get_bus_number(usb_dev),
libusb_get_device_address(usb_dev));
/*
* Search for an already allocated device instance for this device and
* if found return a reference to it.
*/
dev = find_device(ctx, usb_dev);
if (dev) {
log_dbg(ctx, "Device: USB address = %u.", dev->usb_address);
if (dev->valid_serial_number)
log_dbg(ctx, "Device: Serial number = %u.",
dev->serial_number);
else
log_dbg(ctx, "Device: Serial number = N/A.");
log_dbg(ctx, "Using existing device instance.");
return jaylink_ref_device(dev);
}
/* Open the device to be able to retrieve its serial number. */
ret = libusb_open(usb_dev, &usb_devh);
if (ret != LIBUSB_SUCCESS) {
log_warn(ctx, "Failed to open device: %s.",
libusb_error_name(ret));
return NULL;
}
valid_serial_number = true;
ret = libusb_get_string_descriptor_ascii(usb_devh, desc.iSerialNumber,
(unsigned char *)buf, USB_SERIAL_NUMBER_LENGTH + 1);
libusb_close(usb_devh);
if (ret < 0) {
log_warn(ctx, "Failed to retrieve serial number: %s.",
libusb_error_name(ret));
valid_serial_number = false;
}
if (valid_serial_number) {
if (!parse_serial_number(buf, &serial_number)) {
log_warn(ctx, "Failed to parse serial number.");
return NULL;
}
}
log_dbg(ctx, "Device: USB address = %u.", usb_address);
if (valid_serial_number)
log_dbg(ctx, "Device: Serial number = %u.", serial_number);
else
log_dbg(ctx, "Device: Serial number = N/A.");
log_dbg(ctx, "Allocating new device instance.");
dev = device_allocate(ctx);
if (!dev) {
log_warn(ctx, "Device instance malloc failed.");
return NULL;
}
dev->interface = JAYLINK_HIF_USB;
dev->usb_dev = libusb_ref_device(usb_dev);
dev->usb_address = usb_address;
dev->serial_number = serial_number;
dev->valid_serial_number = valid_serial_number;
return dev;
}
