From: Bert Vermeulen Date: Wed, 8 Jan 2014 20:18:19 +0000 (+0100) Subject: atten-pps3xxx: Full support for the PPS3203T-3S. X-Git-Tag: libsigrok-0.3.0~319 X-Git-Url: https://sigrok.org/gitweb/?p=libsigrok.git;a=commitdiff_plain;h=33c40990fd099c3230fdac51f84a1be7ce2e88e7 atten-pps3xxx: Full support for the PPS3203T-3S. --- diff --git a/hardware/atten-pps3xxx/api.c b/hardware/atten-pps3xxx/api.c index 0199acb2..1c7608de 100644 --- a/hardware/atten-pps3xxx/api.c +++ b/hardware/atten-pps3xxx/api.c @@ -17,33 +17,191 @@ * along with this program. If not, see . */ +#include +#include #include "protocol.h" -SR_PRIV struct sr_dev_driver atten_pps3xxx_driver_info; -static struct sr_dev_driver *di = &atten_pps3xxx_driver_info; +/* + * The default serial communication settings on the device are 9600 + * baud, 9 data bits. The 9th bit isn't actually used, and the vendor + * software uses Mark parity to absorb the extra bit. + * + * Since 9 data bits is not a standard available in POSIX, we use two + * stop bits to skip over the extra bit instead. + */ +#define SERIALCOMM "9600/8n2" + +static const int32_t hwopts[] = { + SR_CONF_CONN, + SR_CONF_SERIALCOMM, +}; + +static const int32_t devopts[] = { + SR_CONF_POWER_SUPPLY, + SR_CONF_CONTINUOUS, +}; + +static const int32_t devopts_sdi[] = { + SR_CONF_POWER_SUPPLY, + SR_CONF_CONTINUOUS, + SR_CONF_OUTPUT_CHANNEL, + SR_CONF_OVER_CURRENT_PROTECTION, +}; + +static const int32_t devopts_pg[] = { + SR_CONF_POWER_SUPPLY, + SR_CONF_CONTINUOUS, + SR_CONF_OUTPUT_VOLTAGE, + SR_CONF_OUTPUT_VOLTAGE_MAX, + SR_CONF_OUTPUT_CURRENT, + SR_CONF_OUTPUT_CURRENT_MAX, + SR_CONF_OUTPUT_ENABLED, +}; + +static const char *channel_modes[] = { + "Independent", + "Series", + "Parallel", +}; + +static struct pps_model models[] = { + { PPS_3203T_3S, "PPS3203T-3S", + CHANMODE_INDEPENDENT | CHANMODE_SERIES | CHANMODE_PARALLEL, + 3, + { + /* Channel 1 */ + { { 0, 32, 0.01 }, { 0, 3, 0.001 } }, + /* Channel 2 */ + { { 0, 32, 0.01 }, { 0, 3, 0.001 } }, + /* Channel 3 */ + { { 0, 6, 0.01 }, { 0, 3, 0.001 } }, + }, + }, +}; + + +SR_PRIV struct sr_dev_driver atten_pps3203_driver_info; +static struct sr_dev_driver *di = &atten_pps3203_driver_info; static int init(struct sr_context *sr_ctx) { return std_init(sr_ctx, di, LOG_PREFIX); } -static GSList *scan(GSList *options) +static GSList *scan(GSList *options, int modelid) { + struct sr_dev_inst *sdi; struct drv_context *drvc; - GSList *devices; - - (void)options; + struct dev_context *devc; + struct sr_config *src; + struct sr_probe *probe; + struct sr_probe_group *pg; + struct sr_serial_dev_inst *serial; + GSList *l, *devices; + struct pps_model *model; + uint8_t packet[PACKET_SIZE]; + unsigned int i; + int ret; + const char *conn, *serialcomm; + char channel[10]; devices = NULL; drvc = di->priv; drvc->instances = NULL; - /* TODO: scan for devices, either based on a SR_CONF_CONN option - * or on a USB scan. */ + conn = serialcomm = NULL; + for (l = options; l; l = l->next) { + src = l->data; + switch (src->key) { + case SR_CONF_CONN: + conn = g_variant_get_string(src->data, NULL); + break; + case SR_CONF_SERIALCOMM: + serialcomm = g_variant_get_string(src->data, NULL); + break; + } + } + if (!conn) + return NULL; + if (!serialcomm) + serialcomm = SERIALCOMM; + + if (!(serial = sr_serial_dev_inst_new(conn, serialcomm))) + return NULL; + + if (serial_open(serial, SERIAL_RDWR | SERIAL_NONBLOCK) != SR_OK) + return NULL; + serial_flush(serial); + + /* This is how the vendor software probes for hardware. */ + memset(packet, 0, PACKET_SIZE); + packet[0] = 0xaa; + packet[1] = 0xaa; + if (serial_write(serial, packet, PACKET_SIZE) == -1) { + sr_err("Unable to write while probing for hardware: %s", + strerror(errno)); + return NULL; + } + /* The device responds with a 24-byte packet when it receives a packet. + * At 9600 baud, 300ms is long enough for it to have arrived. */ + g_usleep(300 * 1000); + memset(packet, 0, PACKET_SIZE); + if ((ret = serial_read_nonblocking(serial, packet, PACKET_SIZE)) < 0) { + sr_err("Unable to read while probing for hardware: %s", + strerror(errno)); + return NULL; + } + if (ret != PACKET_SIZE || packet[0] != 0xaa || packet[1] != 0xaa) { + /* Doesn't look like an Atten PPS. */ + return NULL; + } + + model = NULL; + for (i = 0; i < ARRAY_SIZE(models); i++) { + if (models[i].modelid == modelid) { + model = &models[i]; + break; + } + } + if (!model) { + sr_err("Unknown modelid %d", modelid); + return NULL; + } + + sdi = sr_dev_inst_new(0, SR_ST_INACTIVE, "Atten", model->name, NULL); + sdi->driver = di; + sdi->inst_type = SR_INST_SERIAL; + sdi->conn = serial; + for (i = 0; i < MAX_CHANNELS; i++) { + snprintf(channel, 10, "CH%d", i + 1); + probe = sr_probe_new(i, SR_PROBE_ANALOG, TRUE, channel); + sdi->probes = g_slist_append(sdi->probes, probe); + pg = g_malloc(sizeof(struct sr_probe_group)); + pg->name = g_strdup(channel); + pg->probes = g_slist_append(NULL, probe); + pg->priv = NULL; + sdi->probe_groups = g_slist_append(sdi->probe_groups, pg); + } + + devc = g_malloc0(sizeof(struct dev_context)); + devc->model = model; + devc->config = g_malloc0(sizeof(struct per_channel_config) * model->num_channels); + sdi->priv = devc; + drvc->instances = g_slist_append(drvc->instances, sdi); + devices = g_slist_append(devices, sdi); + + serial_close(serial); + if (!devices) + sr_serial_dev_inst_free(serial); return devices; } +static GSList *scan_3203(GSList *options) +{ + return scan(options, PPS_3203T_3S); +} + static GSList *dev_list(void) { return ((struct drv_context *)(di->priv))->instances; @@ -54,137 +212,317 @@ static int dev_clear(void) return std_dev_clear(di, NULL); } -static int dev_open(struct sr_dev_inst *sdi) -{ - (void)sdi; - - /* TODO: get handle from sdi->conn and open it. */ - - sdi->status = SR_ST_ACTIVE; - - return SR_OK; -} - -static int dev_close(struct sr_dev_inst *sdi) -{ - (void)sdi; - - /* TODO: get handle from sdi->conn and close it. */ - - sdi->status = SR_ST_INACTIVE; - - return SR_OK; -} - static int cleanup(void) { - dev_clear(); - - /* TODO: free other driver resources, if any. */ - - return SR_OK; + return dev_clear(); } static int config_get(int key, GVariant **data, const struct sr_dev_inst *sdi, const struct sr_probe_group *probe_group) { - int ret; + struct dev_context *devc; + struct sr_probe *probe; + int channel, ret; + + if (!sdi) + return SR_ERR_ARG; - (void)sdi; - (void)data; - (void)probe_group; + devc = sdi->priv; ret = SR_OK; - switch (key) { - /* TODO */ - default: - return SR_ERR_NA; + if (!probe_group) { + /* No probe group: global options. */ + switch (key) { + case SR_CONF_OUTPUT_CHANNEL: + *data = g_variant_new_string(channel_modes[devc->channel_mode - 1]); + break; + case SR_CONF_OVER_CURRENT_PROTECTION: + *data = g_variant_new_boolean(devc->over_current_protection); + break; + default: + return SR_ERR_NA; + } + } else { + /* We only ever have one channel per probe group in this driver. */ + probe = probe_group->probes->data; + channel = probe->index; + + switch (key) { + case SR_CONF_OUTPUT_VOLTAGE: + *data = g_variant_new_double(devc->config[channel].output_voltage_last); + break; + case SR_CONF_OUTPUT_VOLTAGE_MAX: + *data = g_variant_new_double(devc->config[channel].output_voltage_max); + break; + case SR_CONF_OUTPUT_CURRENT: + *data = g_variant_new_double(devc->config[channel].output_current_last); + break; + case SR_CONF_OUTPUT_CURRENT_MAX: + *data = g_variant_new_double(devc->config[channel].output_current_max); + break; + case SR_CONF_OUTPUT_ENABLED: + *data = g_variant_new_boolean(devc->config[channel].output_enabled); + break; + default: + return SR_ERR_NA; + } } return ret; } +static int find_str(const char *str, const char **strings, int array_size) +{ + int idx, i; + + idx = -1; + for (i = 0; i < array_size; i++) { + if (!strcmp(str, strings[i])) { + idx = i; + break; + } + } + + return idx; +} + static int config_set(int key, GVariant *data, const struct sr_dev_inst *sdi, const struct sr_probe_group *probe_group) { - int ret; - - (void)data; - (void)probe_group; + struct dev_context *devc; + struct sr_probe *probe; + gdouble dval; + int channel, ret, ival; + const char *sval; + gboolean bval; if (sdi->status != SR_ST_ACTIVE) return SR_ERR_DEV_CLOSED; ret = SR_OK; - switch (key) { - /* TODO */ - default: - ret = SR_ERR_NA; + devc = sdi->priv; + if (!probe_group) { + /* No probe group: global options. */ + switch (key) { + case SR_CONF_OUTPUT_CHANNEL: + sval = g_variant_get_string(data, NULL); + if ((ival = find_str(sval, channel_modes, + ARRAY_SIZE(channel_modes))) == -1) { + ret = SR_ERR_ARG; + break; + } + if (devc->model->channel_modes && (1 << ival) == 0) { + /* Not supported on this model. */ + ret = SR_ERR_ARG; + } + if (ival == devc->channel_mode_set) + /* Nothing to do. */ + break; + devc->channel_mode_set = ival; + if (devc->acquisition_running) + send_config(sdi); + break; + case SR_CONF_OVER_CURRENT_PROTECTION: + bval = g_variant_get_boolean(data); + if (bval == devc->over_current_protection_set) + /* Nothing to do. */ + break; + devc->over_current_protection_set = bval; + if (devc->acquisition_running) + send_config(sdi); + break; + default: + return SR_ERR_NA; + } + } else { + /* Probe group specified: per-channel options. */ + /* We only ever have one channel per probe group in this driver. */ + probe = probe_group->probes->data; + channel = probe->index; + + switch (key) { + case SR_CONF_OUTPUT_VOLTAGE_MAX: + dval = g_variant_get_double(data); + if (dval < 0 || dval > devc->model->channels[channel].voltage[1]) + ret = SR_ERR_ARG; + devc->config[channel].output_voltage_max = dval; + if (devc->acquisition_running) + send_config(sdi); + break; + case SR_CONF_OUTPUT_CURRENT_MAX: + dval = g_variant_get_double(data); + if (dval < 0 || dval > devc->model->channels[channel].current[1]) + ret = SR_ERR_ARG; + devc->config[channel].output_current_max = dval; + if (devc->acquisition_running) + send_config(sdi); + break; + case SR_CONF_OUTPUT_ENABLED: + bval = g_variant_get_boolean(data); + if (bval == devc->config[channel].output_enabled_set) + /* Nothing to do. */ + break; + devc->config[channel].output_enabled_set = bval; + if (devc->acquisition_running) + send_config(sdi); + break; + default: + ret = SR_ERR_NA; + } } + return ret; } static int config_list(int key, GVariant **data, const struct sr_dev_inst *sdi, const struct sr_probe_group *probe_group) { - int ret; + struct dev_context *devc; + struct sr_probe *probe; + GVariant *gvar; + GVariantBuilder gvb; + int channel, ret, i; + + /* Always available, even without sdi. */ + if (key == SR_CONF_SCAN_OPTIONS) { + *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32, + hwopts, ARRAY_SIZE(hwopts), sizeof(int32_t)); + return SR_OK; + } + + if (!sdi) { + if (key == SR_CONF_DEVICE_OPTIONS) { + *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32, + devopts, ARRAY_SIZE(devopts), sizeof(int32_t)); + return SR_OK; - (void)sdi; - (void)data; - (void)probe_group; + } else { + /* Everything else needs an sdi. */ + return SR_ERR_ARG; + } + } + devc = sdi->priv; ret = SR_OK; - switch (key) { - /* TODO */ - default: - return SR_ERR_NA; + if (!probe_group) { + /* No probe group: global options. */ + switch (key) { + case SR_CONF_DEVICE_OPTIONS: + *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32, + devopts_sdi, ARRAY_SIZE(devopts_sdi), sizeof(int32_t)); + break; + case SR_CONF_OUTPUT_CHANNEL: + if (devc->model->channel_modes == CHANMODE_INDEPENDENT) { + /* The 1-channel models. */ + *data = g_variant_new_strv(channel_modes, 1); + } else { + /* The other models support all modes. */ + *data = g_variant_new_strv(channel_modes, ARRAY_SIZE(channel_modes)); + } + break; + default: + return SR_ERR_NA; + } + } else { + /* Probe group specified: per-channel options. */ + if (!sdi) + return SR_ERR_ARG; + /* We only ever have one channel per probe group in this driver. */ + probe = probe_group->probes->data; + channel = probe->index; + + switch (key) { + case SR_CONF_DEVICE_OPTIONS: + *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32, + devopts_pg, ARRAY_SIZE(devopts_pg), sizeof(int32_t)); + break; + case SR_CONF_OUTPUT_VOLTAGE_MAX: + g_variant_builder_init(&gvb, G_VARIANT_TYPE_ARRAY); + /* Min, max, step. */ + for (i = 0; i < 3; i++) { + gvar = g_variant_new_double(devc->model->channels[channel].voltage[i]); + g_variant_builder_add_value(&gvb, gvar); + } + *data = g_variant_builder_end(&gvb); + break; + case SR_CONF_OUTPUT_CURRENT_MAX: + g_variant_builder_init(&gvb, G_VARIANT_TYPE_ARRAY); + /* Min, max, step. */ + for (i = 0; i < 3; i++) { + gvar = g_variant_new_double(devc->model->channels[channel].current[i]); + g_variant_builder_add_value(&gvb, gvar); + } + *data = g_variant_builder_end(&gvb); + break; + default: + return SR_ERR_NA; + } } return ret; } static int dev_acquisition_start(const struct sr_dev_inst *sdi, - void *cb_data) + void *cb_data) { - (void)sdi; + struct dev_context *devc; + struct sr_serial_dev_inst *serial; + uint8_t packet[PACKET_SIZE]; + (void)cb_data; if (sdi->status != SR_ST_ACTIVE) return SR_ERR_DEV_CLOSED; - /* TODO: configure hardware, reset acquisition state, set up - * callbacks and send header packet. */ + devc = sdi->priv; + memset(devc->packet, 0x44, PACKET_SIZE); + devc->packet_size = 0; + + devc->acquisition_running = TRUE; + + serial = sdi->conn; + serial_source_add(serial, G_IO_IN, 50, atten_pps3xxx_receive_data, (void *)sdi); + std_session_send_df_header(cb_data, LOG_PREFIX); + + /* Send a "probe" configuration packet now. */ + memset(packet, 0, PACKET_SIZE); + packet[0] = 0xaa; + packet[1] = 0xaa; + send_packet(sdi, packet); return SR_OK; } static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data) { + struct dev_context *devc; + (void)cb_data; if (sdi->status != SR_ST_ACTIVE) return SR_ERR_DEV_CLOSED; - /* TODO: stop acquisition. */ + devc = sdi->priv; + devc->acquisition_running = FALSE; return SR_OK; } -SR_PRIV struct sr_dev_driver atten_pps3xxx_driver_info = { - .name = "atten-pps3xxx", - .longname = "Atten PPS3xxx", +SR_PRIV struct sr_dev_driver atten_pps3203_driver_info = { + .name = "atten-pps3203", + .longname = "Atten PPS3203T-3S", .api_version = 1, .init = init, .cleanup = cleanup, - .scan = scan, + .scan = scan_3203, .dev_list = dev_list, .dev_clear = dev_clear, .config_get = config_get, .config_set = config_set, .config_list = config_list, - .dev_open = dev_open, - .dev_close = dev_close, + .dev_open = std_serial_dev_open, + .dev_close = std_serial_dev_close, .dev_acquisition_start = dev_acquisition_start, .dev_acquisition_stop = dev_acquisition_stop, .priv = NULL, diff --git a/hardware/atten-pps3xxx/protocol.c b/hardware/atten-pps3xxx/protocol.c index e7a45847..d4ba6f9a 100644 --- a/hardware/atten-pps3xxx/protocol.c +++ b/hardware/atten-pps3xxx/protocol.c @@ -17,12 +17,121 @@ * along with this program. If not, see . */ +#include +#include #include "protocol.h" +static void dump_packet(char *msg, uint8_t *packet) +{ + int i; + char str[128]; + + str[0] = 0; + for (i = 0; i < PACKET_SIZE; i++) + sprintf(str + strlen(str), "%.2x ", packet[i]); + sr_dbg("%s: %s", msg, str); + +} + +static void handle_packet(const struct sr_dev_inst *sdi) +{ + struct dev_context *devc; + struct sr_datafeed_packet packet; + struct sr_datafeed_analog analog; + float value, data[MAX_CHANNELS]; + int offset, i; + + devc = sdi->priv; + dump_packet("received", devc->packet); + packet.type = SR_DF_ANALOG; + packet.payload = &analog; + analog.probes = sdi->probes; + analog.num_samples = 1; + + analog.mq = SR_MQ_VOLTAGE; + analog.unit = SR_UNIT_VOLT; + analog.mqflags = SR_MQFLAG_DC; + analog.data = data; + for (i = 0; i < devc->model->num_channels; i++) { + offset = 2 + i * 4; + value = ((devc->packet[offset] << 8) + devc->packet[offset + 1]) / 100.0; + analog.data[i] = value; + devc->config[i].output_voltage_last = value; + } + sr_session_send(sdi, &packet); + + analog.mq = SR_MQ_CURRENT; + analog.unit = SR_UNIT_AMPERE; + analog.mqflags = 0; + analog.data = data; + for (i = 0; i < devc->model->num_channels; i++) { + offset = 4 + i * 4; + value = ((devc->packet[offset] << 8) + devc->packet[offset + 1]) / 1000.0; + analog.data[i] = value; + devc->config[i].output_current_last = value; + } + sr_session_send(sdi, &packet); + + for (i = 0; i < devc->model->num_channels; i++) + devc->config[i].output_enabled = (devc->packet[15] & (1 << i)) ? TRUE : FALSE; + + devc->over_current_protection = devc->packet[18] ? TRUE : FALSE; + if (devc->packet[19] < 3) + devc->channel_mode = devc->packet[19]; + +} + +SR_PRIV void send_packet(const struct sr_dev_inst *sdi, uint8_t *packet) +{ + struct sr_serial_dev_inst *serial; + + serial = sdi->conn; + if (serial_write(serial, packet, PACKET_SIZE) == -1) + sr_dbg("Failed to send packet: %s", strerror(errno)); + dump_packet("sent", packet); +} + +SR_PRIV void send_config(const struct sr_dev_inst *sdi) +{ + struct dev_context *devc; + uint8_t packet[PACKET_SIZE]; + int value, offset, i; + + devc = sdi->priv; + memset(packet, 0, PACKET_SIZE); + packet[0] = 0xaa; + packet[1] = 0x20; + packet[14] = 0x01; + packet[16] = 0x01; + for (i = 0; i < devc->model->num_channels; i++) { + offset = 2 + i * 4; + value = devc->config[i].output_voltage_max * 100; + packet[offset] = (value >> 8) & 0xff; + packet[offset + 1] = value & 0xff; + value = devc->config[i].output_current_max * 1000; + packet[offset + 2] = (value >> 8) & 0xff; + packet[offset + 3] = value & 0xff; + if (devc->config[i].output_enabled) + packet[15] |= 1 << i; + } + packet[18] = devc->over_current_protection ? 1 : 0; + packet[19] = devc->channel_mode; + /* Checksum. */ + value = 0; + for (i = 0; i < PACKET_SIZE - 1; i++) + value += packet[i]; + packet[i] = value & 0xff; + send_packet(sdi, packet); + +} + SR_PRIV int atten_pps3xxx_receive_data(int fd, int revents, void *cb_data) { - const struct sr_dev_inst *sdi; struct dev_context *devc; + const struct sr_dev_inst *sdi; + struct sr_serial_dev_inst *serial; + struct sr_datafeed_packet packet; + unsigned char c; (void)fd; @@ -32,9 +141,24 @@ SR_PRIV int atten_pps3xxx_receive_data(int fd, int revents, void *cb_data) if (!(devc = sdi->priv)) return TRUE; + serial = sdi->conn; if (revents == G_IO_IN) { - /* TODO */ + if (serial_read_nonblocking(serial, &c, 1) < 0) + return TRUE; + devc->packet[devc->packet_size++] = c; + if (devc->packet_size == PACKET_SIZE) { + handle_packet(sdi); + devc->packet_size = 0; + if (devc->acquisition_running) + send_config(sdi); + else { + serial_source_remove(serial); + packet.type = SR_DF_END; + sr_session_send(sdi, &packet); + } + } } return TRUE; } + diff --git a/hardware/atten-pps3xxx/protocol.h b/hardware/atten-pps3xxx/protocol.h index a049c7d8..45b6fea4 100644 --- a/hardware/atten-pps3xxx/protocol.h +++ b/hardware/atten-pps3xxx/protocol.h @@ -28,18 +28,75 @@ /* Message logging helpers with subsystem-specific prefix string. */ #define LOG_PREFIX "atten-pps3xxx" +/* Packets to/from the device. */ +#define PACKET_SIZE 24 + +enum { + PPS_3203T_3S, + PPS_3203T_2S, + PPS_3205T_3S, + PPS_3205T_2S, + PPS_3003S, + PPS_3005S, +}; + +/* Maximum number of output channels handled by this driver. */ +#define MAX_CHANNELS 3 + +#define CHANMODE_INDEPENDENT 1 << 0 +#define CHANMODE_SERIES 1 << 1 +#define CHANMODE_PARALLEL 1 << 2 + +struct channel_spec { + /* Min, max, step. */ + gdouble voltage[3]; + gdouble current[3]; +}; + +struct pps_model { + int modelid; + char *name; + int channel_modes; + int num_channels; + struct channel_spec channels[MAX_CHANNELS]; +}; + +struct per_channel_config { + /* Received from device. */ + gdouble output_voltage_last; + gdouble output_current_last; + gboolean output_enabled; + /* Set by frontend. */ + gdouble output_voltage_max; + gdouble output_current_max; + gboolean output_enabled_set; +}; + /** Private, per-device-instance driver context. */ struct dev_context { /* Model-specific information */ + struct pps_model *model; - /* Acquisition settings */ + /* Acquisition state */ + gboolean acquisition_running; /* Operational state */ + struct per_channel_config *config; + /* Received from device. */ + int channel_mode; + gboolean over_current_protection; + /* Set by frontend. */ + int channel_mode_set; + gboolean over_current_protection_set; /* Temporary state across callbacks */ + uint8_t packet[PACKET_SIZE]; + int packet_size; }; SR_PRIV int atten_pps3xxx_receive_data(int fd, int revents, void *cb_data); +SR_PRIV void send_packet(const struct sr_dev_inst *sdi, uint8_t *packet); +SR_PRIV void send_config(const struct sr_dev_inst *sdi); #endif diff --git a/hwdriver.c b/hwdriver.c index eb0ac3d2..37edf415 100644 --- a/hwdriver.c +++ b/hwdriver.c @@ -126,7 +126,7 @@ static struct sr_config_info sr_config_info_data[] = { extern SR_PRIV struct sr_dev_driver appa_55ii_driver_info; #endif #ifdef HAVE_HW_ATTEN_PPS3XXX -extern SR_PRIV struct sr_dev_driver atten_pps3xxx_driver_info; +extern SR_PRIV struct sr_dev_driver atten_pps3203_driver_info; #endif #ifdef HAVE_HW_BRYMEN_DMM extern SR_PRIV struct sr_dev_driver brymen_bm857_driver_info; @@ -272,7 +272,7 @@ static struct sr_dev_driver *drivers_list[] = { &appa_55ii_driver_info, #endif #ifdef HAVE_HW_ATTEN_PPS3XXX - &atten_pps3xxx_driver_info, + &atten_pps3203_driver_info, #endif #ifdef HAVE_HW_BRYMEN_DMM &brymen_bm857_driver_info,