SR_CONF_SERIALCOMM,
};
+static const uint32_t devopts_driver[] = {
+ SR_CONF_POWER_SUPPLY,
+ SR_CONF_CONTINUOUS,
+};
+
static struct pps_channel_instance pci[] = {
{ SR_MQ_VOLTAGE, SCPI_CMD_GET_MEAS_VOLTAGE, "V" },
{ SR_MQ_CURRENT, SCPI_CMD_GET_MEAS_CURRENT, "I" },
struct sr_channel *ch;
const struct scpi_pps *device;
struct pps_channel *pch;
- const struct channel_group_spec *cgs;
+ struct channel_spec *channels;
+ struct channel_group_spec *channel_groups, *cgs;
struct pps_channel_group *pcg;
GRegex *model_re;
GMatchInfo *model_mi;
GSList *l;
uint64_t mask;
- unsigned int ch_num, ch_idx, i, j;
+ unsigned int num_channels, num_channel_groups, ch_num, ch_idx, i, j;
+ int ret;
const char *vendor;
char ch_name[16];
return NULL;
}
- sdi = sr_dev_inst_new(SR_ST_ACTIVE, vendor, hw_info->model,
- hw_info->firmware_version);
+ sdi = sr_dev_inst_new();
+ sdi->status = SR_ST_ACTIVE;
+ sdi->vendor = g_strdup(vendor);
+ sdi->model = g_strdup(hw_info->model);
+ sdi->version = g_strdup(hw_info->firmware_version);
sdi->conn = scpi;
sdi->driver = di;
sdi->inst_type = SR_INST_SCPI;
+ sdi->serial_num = g_strdup(hw_info->serial_number);
+
devc = g_malloc0(sizeof(struct dev_context));
devc->device = device;
sdi->priv = devc;
+ if (device->num_channels) {
+ /* Static channels and groups. */
+ channels = device->channels;
+ num_channels = device->num_channels;
+ channel_groups = device->channel_groups;
+ num_channel_groups = device->num_channel_groups;
+ } else {
+ /* Channels and groups need to be probed. */
+ ret = device->probe_channels(sdi, hw_info, &channels, &num_channels,
+ &channel_groups, &num_channel_groups);
+ if (ret != SR_OK) {
+ sr_err("Failed to probe for channels.");
+ return NULL;
+ }
+ /*
+ * Since these were dynamically allocated, we'll need to free them
+ * later.
+ */
+ devc->channels = channels;
+ devc->channel_groups = channel_groups;
+ }
+
ch_idx = 0;
- for (ch_num = 0; ch_num < device->num_channels; ch_num++) {
+ for (ch_num = 0; ch_num < num_channels; ch_num++) {
/* Create one channel per measurable output unit. */
for (i = 0; i < ARRAY_SIZE(pci); i++) {
if (!scpi_cmd_get(sdi, pci[i].command))
continue;
g_snprintf(ch_name, 16, "%s%s", pci[i].prefix,
- device->channels[ch_num].name);
+ channels[ch_num].name);
ch = sr_channel_new(ch_idx++, SR_CHANNEL_ANALOG, TRUE, ch_name);
pch = g_malloc0(sizeof(struct pps_channel));
pch->hw_output_idx = ch_num;
- pch->hwname = device->channels[ch_num].name;
+ pch->hwname = channels[ch_num].name;
pch->mq = pci[i].mq;
ch->priv = pch;
sdi->channels = g_slist_append(sdi->channels, ch);
}
}
- for (i = 0; i < device->num_channel_groups; i++) {
- cgs = &device->channel_groups[i];
+ for (i = 0; i < num_channel_groups; i++) {
+ cgs = &channel_groups[i];
cg = g_malloc0(sizeof(struct sr_channel_group));
cg->name = g_strdup(cgs->name);
for (j = 0, mask = 1; j < 64; j++, mask <<= 1) {
sdi->channel_groups = g_slist_append(sdi->channel_groups, cg);
}
+ sr_scpi_hw_info_free(hw_info);
+ hw_info = NULL;
+
scpi_cmd(sdi, SCPI_CMD_LOCAL);
sr_scpi_close(scpi);
static int dev_open(struct sr_dev_inst *sdi)
{
+ struct dev_context *devc;
struct sr_scpi_dev_inst *scpi;
+ GVariant *beeper;
if (sdi->status != SR_ST_ACTIVE)
return SR_ERR;
sdi->status = SR_ST_ACTIVE;
scpi_cmd(sdi, SCPI_CMD_REMOTE);
+ devc = sdi->priv;
+ devc->beeper_was_set = FALSE;
+ if (scpi_cmd_resp(sdi, &beeper, G_VARIANT_TYPE_BOOLEAN, SCPI_CMD_BEEPER) == SR_OK) {
+ if (g_variant_get_boolean(beeper)) {
+ devc->beeper_was_set = TRUE;
+ scpi_cmd(sdi, SCPI_CMD_BEEPER_DISABLE);
+ }
+ g_variant_unref(beeper);
+ }
return SR_OK;
}
static int dev_close(struct sr_dev_inst *sdi)
{
struct sr_scpi_dev_inst *scpi;
+ struct dev_context *devc;
if (sdi->status != SR_ST_ACTIVE)
return SR_ERR_DEV_CLOSED;
+ devc = sdi->priv;
scpi = sdi->conn;
if (scpi) {
+ if (devc->beeper_was_set)
+ scpi_cmd(sdi, SCPI_CMD_BEEPER_ENABLE);
scpi_cmd(sdi, SCPI_CMD_LOCAL);
sr_scpi_close(scpi);
sdi->status = SR_ST_INACTIVE;
return SR_OK;
}
+static void clear_helper(void *priv)
+{
+ struct dev_context *devc;
+
+ devc = priv;
+ g_free(devc->channels);
+ g_free(devc->channel_groups);
+ g_free(devc);
+}
+
static int cleanup(void)
{
- return SR_OK;
+ return std_dev_clear(di, clear_helper);
}
static int config_get(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
const GVariantType *gvtype;
unsigned int i;
int cmd, ret;
- const char *s;
if (!sdi)
return SR_ERR_ARG;
if (cg)
select_channel(sdi, cg->channels->data);
ret = scpi_cmd_resp(sdi, data, gvtype, cmd);
-
- if (gvtype == G_VARIANT_TYPE_STRING && ret == SR_OK) {
- /* Non-standard data type responses. */
- switch (key) {
- case SCPI_CMD_GET_OUTPUT_REGULATION:
- /*
- * This is specific to the Rigol DP800 series.
- * We return the same string for now until more
- * models with this key are supported. Do a check
- * just for the hell of it.
- */
- s = g_variant_get_string(*data, NULL);
- if (strcmp(s, "CC") && strcmp(s, "CV") && strcmp(s, "UR")) {
- sr_dbg("Unknown response to SCPI_CMD_GET_OUTPUT_REGULATION: %s", s);
- ret = SR_ERR_DATA;
- }
- break;
- }
- }
} else
ret = SR_ERR_NA;
*data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
scanopts, ARRAY_SIZE(scanopts), sizeof(uint32_t));
return SR_OK;
+ } else if (key == SR_CONF_DEVICE_OPTIONS && !sdi) {
+ *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
+ devopts_driver, ARRAY_SIZE(devopts_driver), sizeof(uint32_t));
+ return SR_OK;
}
if (!sdi)
std_session_send_df_header(sdi, LOG_PREFIX);
/* Prime the pipe with the first channel's fetch. */
- ch = sdi->channels->data;
+ ch = next_enabled_channel(sdi, NULL);
pch = ch->priv;
- select_channel(sdi, ch);
+ if ((ret = select_channel(sdi, ch)) != SR_OK)
+ return ret;
if (pch->mq == SR_MQ_VOLTAGE)
cmd = SCPI_CMD_GET_MEAS_VOLTAGE;
else if (pch->mq == SR_MQ_CURRENT)
static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
{
+ struct sr_datafeed_packet packet;
struct sr_scpi_dev_inst *scpi;
float f;
sr_scpi_get_float(scpi, NULL, &f);
sr_scpi_source_remove(sdi->session, scpi);
+ packet.type = SR_DF_END;
+ sr_session_send(sdi, &packet);
+
return SR_OK;
}
projects / libsigrok.git / blobdiff