SR_PRIV struct sr_channel *sr_probe_new(int index, int type,
gboolean enabled, const char *name)
{
- struct sr_channel *probe;
+ struct sr_channel *ch;
- if (!(probe = g_try_malloc0(sizeof(struct sr_channel)))) {
- sr_err("Probe malloc failed.");
+ if (!(ch = g_try_malloc0(sizeof(struct sr_channel)))) {
+ sr_err("Channel malloc failed.");
return NULL;
}
- probe->index = index;
- probe->type = type;
- probe->enabled = enabled;
+ ch->index = index;
+ ch->type = type;
+ ch->enabled = enabled;
if (name)
- probe->name = g_strdup(name);
+ ch->name = g_strdup(name);
- return probe;
+ return ch;
}
/**
- * Set the name of the specified probe in the specified device.
+ * Set the name of the specified channel in the specified device.
*
- * If the probe already has a different name assigned to it, it will be
+ * If the channel already has a different name assigned to it, it will be
* removed, and the new name will be saved instead.
*
- * @param sdi The device instance the probe is connected to.
- * @param[in] probenum The number of the probe whose name to set.
- * Note that the probe numbers start at 0.
- * @param[in] name The new name that the specified probe should get. A copy
+ * @param sdi The device instance the channel is connected to.
+ * @param[in] channelnum The number of the channel whose name to set.
+ * Note that the channel numbers start at 0.
+ * @param[in] name The new name that the specified channel should get. A copy
* of the string is made.
*
* @return SR_OK on success, or SR_ERR_ARG on invalid arguments.
* @since 0.2.0
*/
SR_API int sr_dev_probe_name_set(const struct sr_dev_inst *sdi,
- int probenum, const char *name)
+ int channelnum, const char *name)
{
GSList *l;
- struct sr_channel *probe;
+ struct sr_channel *ch;
int ret;
if (!sdi) {
}
ret = SR_ERR_ARG;
- for (l = sdi->probes; l; l = l->next) {
- probe = l->data;
- if (probe->index == probenum) {
- g_free(probe->name);
- probe->name = g_strdup(name);
+ for (l = sdi->channels; l; l = l->next) {
+ ch = l->data;
+ if (ch->index == channelnum) {
+ g_free(ch->name);
+ ch->name = g_strdup(name);
ret = SR_OK;
break;
}
}
/**
- * Enable or disable a probe on the specified device.
+ * Enable or disable a channel on the specified device.
*
- * @param sdi The device instance the probe is connected to.
- * @param probenum The probe number, starting from 0.
- * @param state TRUE to enable the probe, FALSE to disable.
+ * @param sdi The device instance the channel is connected to.
+ * @param channelnum The channel number, starting from 0.
+ * @param state TRUE to enable the channel, FALSE to disable.
*
* @return SR_OK on success or SR_ERR on failure. In case of invalid
- * arguments, SR_ERR_ARG is returned and the probe enabled state
+ * arguments, SR_ERR_ARG is returned and the channel enabled state
* remains unchanged.
*
* @since 0.2.0
*/
-SR_API int sr_dev_probe_enable(const struct sr_dev_inst *sdi, int probenum,
+SR_API int sr_dev_probe_enable(const struct sr_dev_inst *sdi, int channelnum,
gboolean state)
{
GSList *l;
- struct sr_channel *probe;
+ struct sr_channel *ch;
int ret;
gboolean was_enabled;
return SR_ERR_ARG;
ret = SR_ERR_ARG;
- for (l = sdi->probes; l; l = l->next) {
- probe = l->data;
- if (probe->index == probenum) {
- was_enabled = probe->enabled;
- probe->enabled = state;
+ for (l = sdi->channels; l; l = l->next) {
+ ch = l->data;
+ if (ch->index == channelnum) {
+ was_enabled = ch->enabled;
+ ch->enabled = state;
ret = SR_OK;
if (!state != !was_enabled && sdi->driver
&& sdi->driver->config_probe_set) {
ret = sdi->driver->config_probe_set(
- sdi, probe, SR_PROBE_SET_ENABLED);
+ sdi, ch, SR_PROBE_SET_ENABLED);
/* Roll back change if it wasn't applicable. */
if (ret == SR_ERR_ARG)
- probe->enabled = was_enabled;
+ ch->enabled = was_enabled;
}
break;
}
}
/**
- * Add a trigger to the specified device (and the specified probe).
+ * Add a trigger to the specified device (and the specified channel).
*
- * If the specified probe of this device already has a trigger, it will
+ * If the specified channel of this device already has a trigger, it will
* be silently replaced.
*
* @param[in,out] sdi Pointer to the device instance; must not be NULL.
- * @param[in] probenum Number of probe, starting at 0.
+ * @param[in] channelnum Number of channel, starting at 0.
* @param[in] trigger Trigger string, in the format used by sigrok-cli
*
* @return SR_OK on success or SR_ERR on failure. In case of invalid
*
* @since 0.2.0
*/
-SR_API int sr_dev_trigger_set(const struct sr_dev_inst *sdi, int probenum,
+SR_API int sr_dev_trigger_set(const struct sr_dev_inst *sdi, int channelnum,
const char *trigger)
{
GSList *l;
- struct sr_channel *probe;
+ struct sr_channel *ch;
char *old_trigger;
int ret;
return SR_ERR_ARG;
ret = SR_ERR_ARG;
- for (l = sdi->probes; l; l = l->next) {
- probe = l->data;
- if (probe->index == probenum) {
- old_trigger = probe->trigger;
+ for (l = sdi->channels; l; l = l->next) {
+ ch = l->data;
+ if (ch->index == channelnum) {
+ old_trigger = ch->trigger;
ret = SR_OK;
if (g_strcmp0(trigger, old_trigger) == 0)
break;
/* Set new trigger if it has changed. */
- probe->trigger = g_strdup(trigger);
+ ch->trigger = g_strdup(trigger);
if (sdi->driver && sdi->driver->config_probe_set) {
ret = sdi->driver->config_probe_set(
- sdi, probe, SR_PROBE_SET_TRIGGER);
+ sdi, ch, SR_PROBE_SET_TRIGGER);
/* Roll back change if it wasn't applicable. */
if (ret == SR_ERR_ARG) {
- g_free(probe->trigger);
- probe->trigger = old_trigger;
+ g_free(ch->trigger);
+ ch->trigger = old_trigger;
break;
}
}
sdi->vendor = vendor ? g_strdup(vendor) : NULL;
sdi->model = model ? g_strdup(model) : NULL;
sdi->version = version ? g_strdup(version) : NULL;
- sdi->probes = NULL;
+ sdi->channels = NULL;
sdi->channel_groups = NULL;
sdi->conn = NULL;
sdi->priv = NULL;
*/
SR_PRIV void sr_dev_inst_free(struct sr_dev_inst *sdi)
{
- struct sr_channel *probe;
+ struct sr_channel *ch;
GSList *l;
- for (l = sdi->probes; l; l = l->next) {
- probe = l->data;
- g_free(probe->name);
- g_free(probe->trigger);
- g_free(probe);
+ for (l = sdi->channels; l; l = l->next) {
+ ch = l->data;
+ g_free(ch->name);
+ g_free(ch->trigger);
+ g_free(ch);
}
- g_slist_free(sdi->probes);
+ g_slist_free(sdi->channels);
if (sdi->channel_groups)
g_slist_free(sdi->channel_groups);
struct drv_context *drvc;
struct dev_context *devc;
struct sr_config *src;
- struct sr_channel *probe;
+ struct sr_channel *ch;
struct sr_serial_dev_inst *serial;
GSList *l, *devices;
int len, i;
sdi->conn = serial;
sdi->priv = devc;
sdi->driver = di;
- if (!(probe = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "P1")))
+ if (!(ch = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "P1")))
return NULL;
- sdi->probes = g_slist_append(sdi->probes, probe);
+ sdi->channels = g_slist_append(sdi->channels, ch);
drvc->instances = g_slist_append(drvc->instances, sdi);
devices = g_slist_append(devices, sdi);
break;
analog.mq = devc->cur_mq;
analog.unit = devc->cur_unit;
analog.mqflags = devc->cur_mqflags;
- analog.probes = sdi->probes;
+ analog.channels = sdi->channels;
analog.num_samples = 1;
analog.data = &fvalue;
packet.type = SR_DF_ANALOG;
return SR_ERR;
}
- sr_dbg("Setting audio channel count to %d.", devc->num_probes);
+ sr_dbg("Setting audio channel count to %d.", devc->num_channels);
ret = snd_pcm_hw_params_set_channels(devc->capture_handle,
- devc->hw_params, devc->num_probes);
+ devc->hw_params, devc->num_channels);
if (ret < 0) {
sr_err("Can't set channel count: %s.", snd_strerror(ret));
return SR_ERR;
struct drv_context *drvc = NULL;
struct sr_dev_inst *sdi = NULL;
struct dev_context *devc = NULL;
- struct sr_channel *probe;
+ struct sr_channel *ch;
int ret;
unsigned int i, offset, channels, minrate, maxrate, rate;
uint64_t hwrates[ARRAY_SIZE(rates)];
/*
* Get hardware parameters:
- * The number of channels, for example, are our sigrok probes. Getting
+ * The number of channels, for example, are our sigrok channels. Getting
* this information needs a detour. We need to open the device, then
* query it and/or test different parameters. A side-effect of is that
* we create a snd_pcm_hw_params_t object. We take advantage of the
}
devc->hwdev = g_strdup(alsaname);
- devc->num_probes = channels;
+ devc->num_channels = channels;
devc->hw_params = hw_params;
memcpy(devrates, hwrates, offset * sizeof(uint64_t));
devc->samplerates = devrates;
sdi->priv = devc;
sdi->driver = di;
- for (i = 0; i < devc->num_probes; i++) {
+ for (i = 0; i < devc->num_channels; i++) {
snprintf(p_name, sizeof(p_name), "Ch_%d", i);
- if (!(probe = sr_probe_new(i, SR_PROBE_ANALOG, TRUE, p_name)))
+ if (!(ch = sr_probe_new(i, SR_PROBE_ANALOG, TRUE, p_name)))
goto scan_error_cleanup;
- sdi->probes = g_slist_append(sdi->probes, probe);
+ sdi->channels = g_slist_append(sdi->channels, ch);
}
drvc->instances = g_slist_append(drvc->instances, sdi);
*
* We don't currently look at alsa subdevices. We only use subdevice 0.
* Every input device will have its own channels (left, right, etc). Each of
- * those channels gets mapped to a different sigrok probe. A device with 4
- * channels will have 4 probes from sigrok's perspective.
+ * those channels gets mapped to a different sigrok channel. A device with 4
+ * channels will have 4 channels from sigrok's perspective.
*/
SR_PRIV GSList *alsa_scan(GSList *options, struct sr_dev_driver *di)
{
sr_spew("Only got %d/%d samples.", count, samples_to_get);
}
- analog.data = g_try_malloc0(count * sizeof(float) * devc->num_probes);
+ analog.data = g_try_malloc0(count * sizeof(float) * devc->num_channels);
if (!analog.data) {
sr_err("Failed to malloc sample buffer.");
return FALSE;
* audio data as a normalized float, and let the frontend or user worry
* about the calibration.
*/
- for (i = 0; i < count; i += devc->num_probes) {
- for (x = 0; x < devc->num_probes; x++) {
+ for (i = 0; i < count; i += devc->num_channels) {
+ for (x = 0; x < devc->num_channels; x++) {
tmp16 = inbuf[i + x];
analog.data[offset++] = tmp16 * s16norm;
}
}
/* Send a sample packet with the analog values. */
- analog.probes = sdi->probes;
+ analog.channels = sdi->channels;
analog.num_samples = count;
analog.mq = SR_MQ_VOLTAGE; /* FIXME */
analog.unit = SR_UNIT_VOLT; /* FIXME */
uint64_t cur_samplerate;
uint64_t limit_samples;
uint64_t num_samples;
- uint8_t num_probes;
+ uint8_t num_channels;
uint64_t *samplerates;
char *hwdev;
snd_pcm_t *capture_handle;
struct dev_context *devc;
struct sr_serial_dev_inst *serial;
struct sr_dev_inst *sdi;
- struct sr_channel *probe;
+ struct sr_channel *ch;
struct sr_config *src;
GSList *devices, *l;
const char *conn, *serialcomm;
sdi->priv = devc;
sdi->driver = di;
- if (!(probe = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "T1")))
+ if (!(ch = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "T1")))
goto scan_cleanup;
- sdi->probes = g_slist_append(sdi->probes, probe);
- if (!(probe = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "T2")))
+ sdi->channels = g_slist_append(sdi->channels, ch);
+ if (!(ch = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "T2")))
goto scan_cleanup;
- sdi->probes = g_slist_append(sdi->probes, probe);
+ sdi->channels = g_slist_append(sdi->channels, ch);
drvc->instances = g_slist_append(drvc->instances, sdi);
devices = g_slist_append(devices, sdi);
return flags;
}
-static float appa_55ii_temp(const uint8_t *buf, int probe)
+static float appa_55ii_temp(const uint8_t *buf, int ch)
{
const uint8_t *ptr;
int16_t temp;
uint8_t flags;
- ptr = buf + 4 + 14 + 3 * probe;
+ ptr = buf + 4 + 14 + 3 * ch;
temp = RL16(ptr);
flags = ptr[2];
struct dev_context *devc;
struct sr_datafeed_packet packet;
struct sr_datafeed_analog analog;
- struct sr_channel *probe;
+ struct sr_channel *ch;
float values[APPA_55II_NUM_PROBES], *val_ptr;
int i;
analog.data = values;
for (i = 0; i < APPA_55II_NUM_PROBES; i++) {
- probe = g_slist_nth_data(sdi->probes, i);
- if (!probe->enabled)
+ ch = g_slist_nth_data(sdi->channels, i);
+ if (!ch->enabled)
continue;
- analog.probes = g_slist_append(analog.probes, probe);
+ analog.channels = g_slist_append(analog.channels, ch);
*val_ptr++ = appa_55ii_temp(buf, i);
}
packet.type = SR_DF_ANALOG;
packet.payload = &analog;
sr_session_send(devc->session_cb_data, &packet);
- g_slist_free(analog.probes);
+ g_slist_free(analog.channels);
devc->num_samples++;
}
struct dev_context *devc;
struct sr_datafeed_packet packet;
struct sr_datafeed_analog analog;
- struct sr_channel *probe;
+ struct sr_channel *ch;
float values[APPA_55II_NUM_PROBES], *val_ptr;
const uint8_t *buf;
int16_t temp;
for (i = 0; i < APPA_55II_NUM_PROBES; i++) {
temp = RL16(buf + 12 + 2 * i);
- probe = g_slist_nth_data(sdi->probes, i);
- if (!probe->enabled)
+ ch = g_slist_nth_data(sdi->channels, i);
+ if (!ch->enabled)
continue;
- analog.probes = g_slist_append(analog.probes, probe);
+ analog.channels = g_slist_append(analog.channels, ch);
*val_ptr++ = temp == 0x7FFF ? INFINITY : (float)temp / 10;
}
packet.type = SR_DF_ANALOG;
packet.payload = &analog;
sr_session_send(devc->session_cb_data, &packet);
- g_slist_free(analog.probes);
+ g_slist_free(analog.channels);
devc->num_samples++;
devc->log_buf_len -= 20;
};
/*
- * Probe numbers seem to go from 1-16, according to this image:
+ * Channel numbers seem to go from 1-16, according to this image:
* http://tools.asix.net/img/sigma_sigmacab_pins_720.jpg
* (the cable has two additional GND pins, and a TI and TO pin)
*/
-static const char *probe_names[NUM_PROBES + 1] = {
+static const char *channel_names[NUM_PROBES + 1] = {
"1", "2", "3", "4", "5", "6", "7", "8",
"9", "10", "11", "12", "13", "14", "15", "16",
NULL,
static GSList *scan(GSList *options)
{
struct sr_dev_inst *sdi;
- struct sr_channel *probe;
+ struct sr_channel *ch;
struct drv_context *drvc;
struct dev_context *devc;
GSList *devices;
devc->period_ps = 0;
devc->limit_msec = 0;
devc->cur_firmware = -1;
- devc->num_probes = 0;
+ devc->num_channels = 0;
devc->samples_per_event = 0;
devc->capture_ratio = 50;
devc->use_triggers = 0;
}
sdi->driver = di;
- for (i = 0; probe_names[i]; i++) {
- if (!(probe = sr_probe_new(i, SR_PROBE_LOGIC, TRUE,
- probe_names[i])))
+ for (i = 0; channel_names[i]; i++) {
+ if (!(ch = sr_probe_new(i, SR_PROBE_LOGIC, TRUE,
+ channel_names[i])))
return NULL;
- sdi->probes = g_slist_append(sdi->probes, probe);
+ sdi->channels = g_slist_append(sdi->channels, ch);
}
devices = g_slist_append(devices, sdi);
if (samplerate <= SR_MHZ(50)) {
ret = upload_firmware(0, devc);
- devc->num_probes = 16;
+ devc->num_channels = 16;
}
if (samplerate == SR_MHZ(100)) {
ret = upload_firmware(1, devc);
- devc->num_probes = 8;
+ devc->num_channels = 8;
}
else if (samplerate == SR_MHZ(200)) {
ret = upload_firmware(2, devc);
- devc->num_probes = 4;
+ devc->num_channels = 4;
}
devc->cur_samplerate = samplerate;
devc->period_ps = 1000000000000ULL / samplerate;
- devc->samples_per_event = 16 / devc->num_probes;
+ devc->samples_per_event = 16 / devc->num_channels;
devc->state.state = SIGMA_IDLE;
return ret;
/*
* In 100 and 200 MHz mode, only a single pin rising/falling can be
* set as trigger. In other modes, two rising/falling triggers can be set,
- * in addition to value/mask trigger for any number of probes.
+ * in addition to value/mask trigger for any number of channels.
*
* The Sigma supports complex triggers using boolean expressions, but this
* has not been implemented yet.
*/
-static int configure_probes(const struct sr_dev_inst *sdi)
+static int configure_channels(const struct sr_dev_inst *sdi)
{
struct dev_context *devc = sdi->priv;
- const struct sr_channel *probe;
+ const struct sr_channel *ch;
const GSList *l;
int trigger_set = 0;
- int probebit;
+ int channelbit;
memset(&devc->trigger, 0, sizeof(struct sigma_trigger));
- for (l = sdi->probes; l; l = l->next) {
- probe = (struct sr_channel *)l->data;
- probebit = 1 << (probe->index);
+ for (l = sdi->channels; l; l = l->next) {
+ ch = (struct sr_channel *)l->data;
+ channelbit = 1 << (ch->index);
- if (!probe->enabled || !probe->trigger)
+ if (!ch->enabled || !ch->trigger)
continue;
if (devc->cur_samplerate >= SR_MHZ(100)) {
"200MHz mode is supported.");
return SR_ERR;
}
- if (probe->trigger[0] == 'f')
- devc->trigger.fallingmask |= probebit;
- else if (probe->trigger[0] == 'r')
- devc->trigger.risingmask |= probebit;
+ if (ch->trigger[0] == 'f')
+ devc->trigger.fallingmask |= channelbit;
+ else if (ch->trigger[0] == 'r')
+ devc->trigger.risingmask |= channelbit;
else {
sr_err("Only rising/falling trigger in 100 "
"and 200MHz mode is supported.");
++trigger_set;
} else {
/* Simple trigger support (event). */
- if (probe->trigger[0] == '1') {
- devc->trigger.simplevalue |= probebit;
- devc->trigger.simplemask |= probebit;
+ if (ch->trigger[0] == '1') {
+ devc->trigger.simplevalue |= channelbit;
+ devc->trigger.simplemask |= channelbit;
}
- else if (probe->trigger[0] == '0') {
- devc->trigger.simplevalue &= ~probebit;
- devc->trigger.simplemask |= probebit;
+ else if (ch->trigger[0] == '0') {
+ devc->trigger.simplevalue &= ~channelbit;
+ devc->trigger.simplemask |= channelbit;
}
- else if (probe->trigger[0] == 'f') {
- devc->trigger.fallingmask |= probebit;
+ else if (ch->trigger[0] == 'f') {
+ devc->trigger.fallingmask |= channelbit;
++trigger_set;
}
- else if (probe->trigger[0] == 'r') {
- devc->trigger.risingmask |= probebit;
+ else if (ch->trigger[0] == 'r') {
+ devc->trigger.risingmask |= channelbit;
++trigger_set;
}
for (k = 0; k < devc->samples_per_event; ++k) {
cur_sample = 0;
- /* For each probe. */
- for (l = 0; l < devc->num_probes; ++l)
+ /* For each channel. */
+ for (l = 0; l < devc->num_channels; ++l)
cur_sample |= (!!(event[j] & (1 << (l *
devc->samples_per_event + k)))) << l;
{
int i, j, k, bit;
- /* For each quad probe. */
+ /* For each quad channel. */
for (i = 0; i < 4; ++i) {
entry[i] = 0xffff;
/* For each bit in LUT. */
for (j = 0; j < 16; ++j)
- /* For each probe in quad. */
+ /* For each channel in quad. */
for (k = 0; k < 4; ++k) {
bit = 1 << (i * 4 + k);
devc = sdi->priv;
- if (configure_probes(sdi) != SR_OK) {
- sr_err("Failed to configure probes.");
+ if (configure_channels(sdi) != SR_OK) {
+ sr_err("Failed to configure channels.");
return SR_ERR;
}
/* Set clock select register. */
if (devc->cur_samplerate == SR_MHZ(200))
- /* Enable 4 probes. */
+ /* Enable 4 channels. */
sigma_set_register(WRITE_CLOCK_SELECT, 0xf0, devc);
else if (devc->cur_samplerate == SR_MHZ(100))
- /* Enable 8 probes. */
+ /* Enable 8 channels. */
sigma_set_register(WRITE_CLOCK_SELECT, 0x00, devc);
else {
/*
clockselect.async = 0;
clockselect.fraction = frac;
- clockselect.disabled_probes = 0;
+ clockselect.disabled_channels = 0;
sigma_write_register(WRITE_CLOCK_SELECT,
(uint8_t *) &clockselect,
struct clockselect_50 {
uint8_t async;
uint8_t fraction;
- uint16_t disabled_probes;
+ uint16_t disabled_channels;
};
/* The effect of all these are still a bit unclear. */
/* Trigger configuration */
struct sigma_trigger {
- /* Only two probes can be used in mask. */
+ /* Only two channels can be used in mask. */
uint16_t risingmask;
uint16_t fallingmask;
uint64_t limit_msec;
struct timeval start_tv;
int cur_firmware;
- int num_probes;
+ int num_channels;
int samples_per_event;
int capture_ratio;
struct sigma_trigger trigger;
struct drv_context *drvc;
struct dev_context *devc;
struct sr_config *src;
- struct sr_channel *probe;
+ struct sr_channel *ch;
struct sr_channel_group *cg;
struct sr_serial_dev_inst *serial;
GSList *l, *devices;
return NULL;
serial_flush(serial);
- /* This is how the vendor software probes for hardware. */
+ /* This is how the vendor software channels for hardware. */
memset(packet, 0, PACKET_SIZE);
packet[0] = 0xaa;
packet[1] = 0xaa;
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);
+ ch = sr_probe_new(i, SR_PROBE_ANALOG, TRUE, channel);
+ sdi->channels = g_slist_append(sdi->channels, ch);
cg = g_malloc(sizeof(struct sr_channel_group));
cg->name = g_strdup(channel);
- cg->channels = g_slist_append(NULL, probe);
+ cg->channels = g_slist_append(NULL, ch);
cg->priv = NULL;
sdi->channel_groups = g_slist_append(sdi->channel_groups, cg);
}
const struct sr_channel_group *cg)
{
struct dev_context *devc;
- struct sr_channel *probe;
+ struct sr_channel *ch;
int channel, ret;
if (!sdi)
}
} else {
/* We only ever have one channel per channel group in this driver. */
- probe = cg->channels->data;
- channel = probe->index;
+ ch = cg->channels->data;
+ channel = ch->index;
switch (key) {
case SR_CONF_OUTPUT_VOLTAGE:
const struct sr_channel_group *cg)
{
struct dev_context *devc;
- struct sr_channel *probe;
+ struct sr_channel *ch;
gdouble dval;
int channel, ret, ival;
const char *sval;
} else {
/* Channel group specified: per-channel options. */
/* We only ever have one channel per channel group in this driver. */
- probe = cg->channels->data;
- channel = probe->index;
+ ch = cg->channels->data;
+ channel = ch->index;
switch (key) {
case SR_CONF_OUTPUT_VOLTAGE_MAX:
const struct sr_channel_group *cg)
{
struct dev_context *devc;
- struct sr_channel *probe;
+ struct sr_channel *ch;
GVariant *gvar;
GVariantBuilder gvb;
int channel, ret, i;
if (!sdi)
return SR_ERR_ARG;
/* We only ever have one channel per channel group in this driver. */
- probe = cg->channels->data;
- channel = probe->index;
+ ch = cg->channels->data;
+ channel = ch->index;
switch (key) {
case SR_CONF_DEVICE_OPTIONS:
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. */
+ /* Send a "channel" configuration packet now. */
memset(packet, 0, PACKET_SIZE);
packet[0] = 0xaa;
packet[1] = 0xaa;
dump_packet("received", devc->packet);
packet.type = SR_DF_ANALOG;
packet.payload = &analog;
- analog.probes = sdi->probes;
+ analog.channels = sdi->channels;
analog.num_samples = 1;
analog.mq = SR_MQ_VOLTAGE;
struct sr_dev_inst *sdi;
struct sr_usb_dev_inst *usb;
struct sr_config *src;
- struct sr_channel *probe;
+ struct sr_channel *ch;
const char *conn;
drvc = di->priv;
sdi->priv = devc;
sdi->driver = di;
- if (!(probe = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "P1")))
+ if (!(ch = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "P1")))
return NULL;
- sdi->probes = g_slist_append(sdi->probes, probe);
- if (!(probe = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "P2")))
+ sdi->channels = g_slist_append(sdi->channels, ch);
+ if (!(ch = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "P2")))
return NULL;
- sdi->probes = g_slist_append(sdi->probes, probe);
+ sdi->channels = g_slist_append(sdi->channels, ch);
sdi->inst_type = SR_INST_USB;
sdi->conn = usb;
/* Got a measurement. */
analog[0].num_samples = 1;
analog[0].data = &floatval[0];
- analog[0].probes = g_slist_append(NULL, sdi->probes->data);
+ analog[0].channels = g_slist_append(NULL, sdi->channels->data);
packet.type = SR_DF_ANALOG;
packet.payload = &analog[0];
sr_session_send(devc->session_cb_data, &packet);
- g_slist_free(analog[0].probes);
+ g_slist_free(analog[0].channels);
}
if (analog[1].mq != -1) {
/* Got a measurement. */
analog[1].num_samples = 1;
analog[1].data = &floatval[1];
- analog[1].probes = g_slist_append(NULL, sdi->probes->next->data);
+ analog[1].channels = g_slist_append(NULL, sdi->channels->next->data);
packet.type = SR_DF_ANALOG;
packet.payload = &analog[1];
sr_session_send(devc->session_cb_data, &packet);
- g_slist_free(analog[1].probes);
+ g_slist_free(analog[1].channels);
}
if (analog[0].mq != -1 || analog[1].mq != -1)
struct sr_dev_inst *sdi;
struct dev_context *devc;
struct drv_context *drvc;
- struct sr_channel *probe;
+ struct sr_channel *ch;
struct sr_serial_dev_inst *serial;
GSList *devices;
int ret;
sdi->priv = devc;
sdi->driver = di;
- if (!(probe = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "P1")))
+ if (!(ch = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "P1")))
goto scan_cleanup;
- sdi->probes = g_slist_append(sdi->probes, probe);
+ sdi->channels = g_slist_append(sdi->channels, ch);
drvc->instances = g_slist_append(drvc->instances, sdi);
devices = g_slist_append(devices, sdi);
return;
analog.data = &floatval;
- analog.probes = sdi->probes;
+ analog.channels = sdi->channels;
if (analog.mq != -1) {
/* Got a measurement. */
struct sr_config *src;
struct sr_serial_dev_inst *serial;
struct sr_dev_inst *sdi;
- struct sr_channel *probe;
+ struct sr_channel *ch;
GSList *l, *devices;
gint64 start;
const char *conn;
sdi->inst_type = SR_INST_SERIAL;
sdi->priv = devc;
sdi->driver = di;
- if (!(probe = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "SPL")))
+ if (!(ch = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "SPL")))
return NULL;
- sdi->probes = g_slist_append(sdi->probes, probe);
+ sdi->channels = g_slist_append(sdi->channels, ch);
drvc->instances = g_slist_append(drvc->instances, sdi);
devices = g_slist_append(devices, sdi);
break;
analog.mq = SR_MQ_SOUND_PRESSURE_LEVEL;
analog.mqflags = devc->cur_mqflags;
analog.unit = SR_UNIT_DECIBEL_SPL;
- analog.probes = sdi->probes;
+ analog.channels = sdi->channels;
analog.num_samples = 1;
analog.data = &devc->last_spl;
packet.type = SR_DF_ANALOG;
analog.mq = SR_MQ_SOUND_PRESSURE_LEVEL;
analog.mqflags = devc->cur_mqflags;
analog.unit = SR_UNIT_DECIBEL_SPL;
- analog.probes = sdi->probes;
+ analog.channels = sdi->channels;
analog.num_samples = num_samples;
analog.data = fbuf;
packet.type = SR_DF_ANALOG;
SR_CONF_CONTINUOUS,
};
-static const char *probe_names[] = {
+static const char *channel_names[] = {
"T1", "T2", "T3", "T4",
NULL,
};
struct sr_dev_inst *sdi;
struct drv_context *drvc;
struct dev_context *devc;
- struct sr_channel *probe;
+ struct sr_channel *ch;
struct sr_serial_dev_inst *serial;
GSList *devices;
sdi->driver = center_devs[idx].di;
for (i = 0; i < center_devs[idx].num_channels; i++) {
- if (!(probe = sr_probe_new(i, SR_PROBE_ANALOG,
- TRUE, probe_names[i])))
+ if (!(ch = sr_probe_new(i, SR_PROBE_ANALOG,
+ TRUE, channel_names[i])))
goto scan_cleanup;
- sdi->probes = g_slist_append(sdi->probes, probe);
+ sdi->channels = g_slist_append(sdi->channels, ch);
}
drvc->instances = g_slist_append(drvc->instances, sdi);
return SR_ERR;
}
- /* Common values for all 4 probes. */
+ /* Common values for all 4 channels. */
packet.type = SR_DF_ANALOG;
packet.payload = &analog;
analog.mq = SR_MQ_TEMPERATURE;
/* Send the values for T1 - T4. */
for (i = 0; i < 4; i++) {
l = NULL;
- l = g_slist_append(l, g_slist_nth_data(sdi->probes, i));
- analog.probes = l;
+ l = g_slist_append(l, g_slist_nth_data(sdi->channels, i));
+ analog.channels = l;
analog.data = &(info.temp[i]);
sr_session_send(devc->cb_data, &packet);
g_slist_free(l);
static GSList *scan(GSList *options)
{
struct sr_dev_inst *sdi;
- struct sr_channel *probe;
+ struct sr_channel *ch;
struct drv_context *drvc;
struct dev_context *devc;
GSList *devices;
memset(devc->mangled_buf, 0, BS);
devc->final_buf = NULL;
devc->trigger_pattern = 0x00; /* Value irrelevant, see trigger_mask. */
- devc->trigger_mask = 0x00; /* All probes are "don't care". */
+ devc->trigger_mask = 0x00; /* All channels are "don't care". */
devc->trigger_timeout = 10; /* Default to 10s trigger timeout. */
devc->trigger_found = 0;
devc->done = 0;
sdi->driver = di;
sdi->priv = devc;
- for (i = 0; chronovu_la8_probe_names[i]; i++) {
- if (!(probe = sr_probe_new(i, SR_PROBE_LOGIC, TRUE,
- chronovu_la8_probe_names[i])))
+ for (i = 0; chronovu_la8_channel_names[i]; i++) {
+ if (!(ch = sr_probe_new(i, SR_PROBE_LOGIC, TRUE,
+ chronovu_la8_channel_names[i])))
return NULL;
- sdi->probes = g_slist_append(sdi->probes, probe);
+ sdi->channels = g_slist_append(sdi->channels, ch);
}
devices = g_slist_append(devices, sdi);
return SR_ERR;
}
- if (configure_probes(sdi) != SR_OK) {
- sr_err("Failed to configure probes.");
+ if (configure_channels(sdi) != SR_OK) {
+ sr_err("Failed to configure channels.");
return SR_ERR;
}
#include "protocol.h"
/* Probes are numbered 0-7. */
-SR_PRIV const char *chronovu_la8_probe_names[NUM_PROBES + 1] = {
+SR_PRIV const char *chronovu_la8_channel_names[NUM_PROBES + 1] = {
"0", "1", "2", "3", "4", "5", "6", "7",
NULL,
};
return SR_OK;
}
-SR_PRIV int configure_probes(const struct sr_dev_inst *sdi)
+SR_PRIV int configure_channels(const struct sr_dev_inst *sdi)
{
struct dev_context *devc;
- const struct sr_channel *probe;
+ const struct sr_channel *ch;
const GSList *l;
- uint8_t probe_bit;
+ uint8_t channel_bit;
char *tc;
devc = sdi->priv;
devc->trigger_pattern = 0;
- devc->trigger_mask = 0; /* Default to "don't care" for all probes. */
+ devc->trigger_mask = 0; /* Default to "don't care" for all channels. */
- for (l = sdi->probes; l; l = l->next) {
- probe = (struct sr_channel *)l->data;
+ for (l = sdi->channels; l; l = l->next) {
+ ch = (struct sr_channel *)l->data;
- if (!probe) {
- sr_err("%s: probe was NULL.", __func__);
+ if (!ch) {
+ sr_err("%s: channel was NULL.", __func__);
return SR_ERR;
}
- /* Skip disabled probes. */
- if (!probe->enabled)
+ /* Skip disabled channels. */
+ if (!ch->enabled)
continue;
- /* Skip (enabled) probes with no configured trigger. */
- if (!probe->trigger)
+ /* Skip (enabled) channels with no configured trigger. */
+ if (!ch->trigger)
continue;
- /* Note: Must only be run if probe->trigger != NULL. */
- if (probe->index < 0 || probe->index > 7) {
- sr_err("%s: Invalid probe index %d, must be "
- "between 0 and 7.", __func__, probe->index);
+ /* Note: Must only be run if ch->trigger != NULL. */
+ if (ch->index < 0 || ch->index > 7) {
+ sr_err("%s: Invalid channel index %d, must be "
+ "between 0 and 7.", __func__, ch->index);
return SR_ERR;
}
- probe_bit = (1 << (probe->index));
+ channel_bit = (1 << (ch->index));
- /* Configure the probe's trigger mask and trigger pattern. */
- for (tc = probe->trigger; tc && *tc; tc++) {
- devc->trigger_mask |= probe_bit;
+ /* Configure the channel's trigger mask and trigger pattern. */
+ for (tc = ch->trigger; tc && *tc; tc++) {
+ devc->trigger_mask |= channel_bit;
/* Sanity check, LA8 only supports low/high trigger. */
if (*tc != '0' && *tc != '1') {
}
if (*tc == '1')
- devc->trigger_pattern |= probe_bit;
+ devc->trigger_pattern |= channel_bit;
}
}
/**
* Trigger pattern (MSB = channel 7, LSB = channel 0).
- * A 1 bit matches a high signal, 0 matches a low signal on a probe.
+ * A 1 bit matches a high signal, 0 matches a low signal on a channel.
* Only low/high triggers (but not e.g. rising/falling) are supported.
*/
uint8_t trigger_pattern;
/* protocol.c */
extern const int32_t chronovu_la8_hwcaps[];
extern uint64_t chronovu_la8_samplerates[];
-extern SR_PRIV const char *chronovu_la8_probe_names[];
+extern SR_PRIV const char *chronovu_la8_channel_names[];
SR_PRIV void fill_supported_samplerates_if_needed(void);
SR_PRIV int is_valid_samplerate(uint64_t samplerate);
SR_PRIV uint8_t samplerate_to_divcount(uint64_t samplerate);
SR_PRIV int la8_close(struct dev_context *devc);
SR_PRIV int la8_close_usb_reset_sequencer(struct dev_context *devc);
SR_PRIV int la8_reset(struct dev_context *devc);
-SR_PRIV int configure_probes(const struct sr_dev_inst *sdi);
+SR_PRIV int configure_channels(const struct sr_dev_inst *sdi);
SR_PRIV int set_samplerate(const struct sr_dev_inst *sdi, uint64_t samplerate);
SR_PRIV int la8_read_block(struct dev_context *devc);
SR_PRIV void send_block_to_session_bus(struct dev_context *devc, int block);
struct dev_context *devc;
struct sr_dev_inst *sdi;
struct sr_config *src;
- struct sr_channel *probe;
+ struct sr_channel *ch;
GSList *devices, *l;
const char *conn, *serialcomm;
sdi->inst_type = SR_INST_SERIAL;
sdi->priv = devc;
sdi->driver = di;
- if (!(probe = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "P1")))
+ if (!(ch = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "P1")))
return NULL;
- sdi->probes = g_slist_append(sdi->probes, probe);
+ sdi->channels = g_slist_append(sdi->channels, ch);
drvc->instances = g_slist_append(drvc->instances, sdi);
devices = g_slist_append(devices, sdi);
memset(&analog, 0, sizeof(struct sr_datafeed_analog));
analog.mq = SR_MQ_SOUND_PRESSURE_LEVEL;
analog.unit = SR_UNIT_DECIBEL_SPL;
- analog.probes = sdi->probes;
+ analog.channels = sdi->channels;
analog.num_samples = 1;
analog.data = &fvalue;
struct sr_dev_inst *sdi;
struct drv_context *drvc;
struct sr_config *src;
- struct sr_channel *probe;
+ struct sr_channel *ch;
struct sr_serial_dev_inst *serial;
GSList *l, *devices;
const char *conn, *serialcomm;
sdi->conn = serial;
sdi->priv = NULL;
sdi->driver = di;
- if (!(probe = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "CH1")))
+ if (!(ch = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "CH1")))
return NULL;
- sdi->probes = g_slist_append(sdi->probes, probe);
+ sdi->channels = g_slist_append(sdi->channels, ch);
drvc->instances = g_slist_append(drvc->instances, sdi);
devices = g_slist_append(devices, sdi);
/* Logic patterns we can generate. */
enum {
/**
- * Spells "sigrok" across 8 probes using '0's (with '1's as
+ * Spells "sigrok" across 8 channels using '0's (with '1's as
* "background") when displayed using the 'bits' output format.
- * The pattern is repeasted every 8 probes, shifted to the right
+ * The pattern is repeasted every 8 channels, shifted to the right
* in time by one bit.
*/
PATTERN_SIGROK,
- /** Pseudo-random values on all probes. */
+ /** Pseudo-random values on all channels. */
PATTERN_RANDOM,
/**
- * Incrementing number across 8 probes. The pattern is repeasted
- * every 8 probes, shifted to the right in time by one bit.
+ * Incrementing number across 8 channels. The pattern is repeasted
+ * every 8 channels, shifted to the right in time by one bit.
*/
PATTERN_INC,
- /** All probes have a low logic state. */
+ /** All channels have a low logic state. */
PATTERN_ALL_LOW,
- /** All probes have a high logic state. */
+ /** All channels have a high logic state. */
PATTERN_ALL_HIGH,
};
int64_t starttime;
uint64_t step;
/* Logic */
- int32_t num_logic_probes;
+ int32_t num_logic_channels;
unsigned int logic_unitsize;
/* There is only ever one logic channel group, so its pattern goes here. */
uint8_t logic_pattern;
unsigned char logic_data[LOGIC_BUFSIZE];
/* Analog */
- int32_t num_analog_probes;
+ int32_t num_analog_channels;
GSList *analog_channel_groups;
};
struct drv_context *drvc;
struct dev_context *devc;
struct sr_dev_inst *sdi;
- struct sr_channel *probe;
+ struct sr_channel *ch;
struct sr_channel_group *cg;
struct sr_config *src;
struct analog_gen *ag;
GSList *devices, *l;
- int num_logic_probes, num_analog_probes, pattern, i;
- char probe_name[16];
+ int num_logic_channels, num_analog_channels, pattern, i;
+ char channel_name[16];
drvc = di->priv;
- num_logic_probes = DEFAULT_NUM_LOGIC_PROBES;
- num_analog_probes = DEFAULT_NUM_ANALOG_PROBES;
+ num_logic_channels = DEFAULT_NUM_LOGIC_PROBES;
+ num_analog_channels = DEFAULT_NUM_ANALOG_PROBES;
for (l = options; l; l = l->next) {
src = l->data;
switch (src->key) {
case SR_CONF_NUM_LOGIC_PROBES:
- num_logic_probes = g_variant_get_int32(src->data);
+ num_logic_channels = g_variant_get_int32(src->data);
break;
case SR_CONF_NUM_ANALOG_PROBES:
- num_analog_probes = g_variant_get_int32(src->data);
+ num_analog_channels = g_variant_get_int32(src->data);
break;
}
}
devc->limit_samples = 0;
devc->limit_msec = 0;
devc->step = 0;
- devc->num_logic_probes = num_logic_probes;
- devc->logic_unitsize = (devc->num_logic_probes + 7) / 8;
+ devc->num_logic_channels = num_logic_channels;
+ devc->logic_unitsize = (devc->num_logic_channels + 7) / 8;
devc->logic_pattern = PATTERN_SIGROK;
- devc->num_analog_probes = num_analog_probes;
+ devc->num_analog_channels = num_analog_channels;
devc->analog_channel_groups = NULL;
- /* Logic probes, all in one channel group. */
+ /* Logic channels, all in one channel group. */
if (!(cg = g_try_malloc(sizeof(struct sr_channel_group))))
return NULL;
cg->name = g_strdup("Logic");
cg->channels = NULL;
cg->priv = NULL;
- for (i = 0; i < num_logic_probes; i++) {
- sprintf(probe_name, "D%d", i);
- if (!(probe = sr_probe_new(i, SR_PROBE_LOGIC, TRUE, probe_name)))
+ for (i = 0; i < num_logic_channels; i++) {
+ sprintf(channel_name, "D%d", i);
+ if (!(ch = sr_probe_new(i, SR_PROBE_LOGIC, TRUE, channel_name)))
return NULL;
- sdi->probes = g_slist_append(sdi->probes, probe);
- cg->channels = g_slist_append(cg->channels, probe);
+ sdi->channels = g_slist_append(sdi->channels, ch);
+ cg->channels = g_slist_append(cg->channels, ch);
}
sdi->channel_groups = g_slist_append(NULL, cg);
- /* Analog probes, channel groups and pattern generators. */
+ /* Analog channels, channel groups and pattern generators. */
pattern = 0;
- for (i = 0; i < num_analog_probes; i++) {
- sprintf(probe_name, "A%d", i);
- if (!(probe = sr_probe_new(i + num_logic_probes,
- SR_PROBE_ANALOG, TRUE, probe_name)))
+ for (i = 0; i < num_analog_channels; i++) {
+ sprintf(channel_name, "A%d", i);
+ if (!(ch = sr_probe_new(i + num_logic_channels,
+ SR_PROBE_ANALOG, TRUE, channel_name)))
return NULL;
- sdi->probes = g_slist_append(sdi->probes, probe);
+ sdi->channels = g_slist_append(sdi->channels, ch);
- /* Every analog probe gets its own channel group. */
+ /* Every analog channel gets its own channel group. */
if (!(cg = g_try_malloc(sizeof(struct sr_channel_group))))
return NULL;
- cg->name = g_strdup(probe_name);
- cg->channels = g_slist_append(NULL, probe);
+ cg->name = g_strdup(channel_name);
+ cg->channels = g_slist_append(NULL, ch);
/* Every channel group gets a generator struct. */
if (!(ag = g_try_malloc(sizeof(struct analog_gen))))
return NULL;
- ag->packet.probes = cg->channels;
+ ag->packet.channels = cg->channels;
ag->packet.mq = 0;
ag->packet.mqflags = 0;
ag->packet.unit = SR_UNIT_VOLT;
const struct sr_channel_group *cg)
{
struct dev_context *devc;
- struct sr_channel *probe;
+ struct sr_channel *ch;
struct analog_gen *ag;
int pattern;
case SR_CONF_PATTERN_MODE:
if (!cg)
return SR_ERR_CHANNEL_GROUP;
- probe = cg->channels->data;
- if (probe->type == SR_PROBE_LOGIC) {
+ ch = cg->channels->data;
+ if (ch->type == SR_PROBE_LOGIC) {
pattern = devc->logic_pattern;
*data = g_variant_new_string(logic_pattern_str[pattern]);
- } else if (probe->type == SR_PROBE_ANALOG) {
+ } else if (ch->type == SR_PROBE_ANALOG) {
ag = cg->priv;
pattern = ag->pattern;
*data = g_variant_new_string(analog_pattern_str[pattern]);
return SR_ERR_BUG;
break;
case SR_CONF_NUM_LOGIC_PROBES:
- *data = g_variant_new_int32(devc->num_logic_probes);
+ *data = g_variant_new_int32(devc->num_logic_channels);
break;
case SR_CONF_NUM_ANALOG_PROBES:
- *data = g_variant_new_int32(devc->num_analog_probes);
+ *data = g_variant_new_int32(devc->num_analog_channels);
break;
default:
return SR_ERR_NA;
{
struct dev_context *devc;
struct analog_gen *ag;
- struct sr_channel *probe;
+ struct sr_channel *ch;
int pattern, ret;
unsigned int i;
const char *stropt;
if (!cg)
return SR_ERR_CHANNEL_GROUP;
stropt = g_variant_get_string(data, NULL);
- probe = cg->channels->data;
+ ch = cg->channels->data;
pattern = -1;
- if (probe->type == SR_PROBE_LOGIC) {
+ if (ch->type == SR_PROBE_LOGIC) {
for (i = 0; i < ARRAY_SIZE(logic_pattern_str); i++) {
if (!strcmp(stropt, logic_pattern_str[i])) {
pattern = i;
memset(devc->logic_data, 0xff, LOGIC_BUFSIZE);
sr_dbg("Setting logic pattern to %s",
logic_pattern_str[pattern]);
- } else if (probe->type == SR_PROBE_ANALOG) {
+ } else if (ch->type == SR_PROBE_ANALOG) {
for (i = 0; i < ARRAY_SIZE(analog_pattern_str); i++) {
if (!strcmp(stropt, analog_pattern_str[i])) {
pattern = i;
static int config_list(int key, GVariant **data, const struct sr_dev_inst *sdi,
const struct sr_channel_group *cg)
{
- struct sr_channel *probe;
+ struct sr_channel *ch;
GVariant *gvar;
GVariantBuilder gvb;
return SR_ERR_NA;
}
} else {
- probe = cg->channels->data;
+ ch = cg->channels->data;
switch (key) {
case SR_CONF_DEVICE_OPTIONS:
*data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
devopts_cg, ARRAY_SIZE(devopts_cg), sizeof(int32_t));
break;
case SR_CONF_PATTERN_MODE:
- if (probe->type == SR_PROBE_LOGIC)
+ if (ch->type == SR_PROBE_LOGIC)
*data = g_variant_new_strv(logic_pattern_str,
ARRAY_SIZE(logic_pattern_str));
- else if (probe->type == SR_PROBE_ANALOG)
+ else if (ch->type == SR_PROBE_ANALOG)
*data = g_variant_new_strv(analog_pattern_str,
ARRAY_SIZE(analog_pattern_str));
else
while (logic_todo || analog_todo) {
/* Logic */
- if (devc->num_logic_probes > 0 && logic_todo > 0) {
+ if (devc->num_logic_channels > 0 && logic_todo > 0) {
sending_now = MIN(logic_todo,
LOGIC_BUFSIZE / devc->logic_unitsize);
logic_generator(sdi, sending_now * devc->logic_unitsize);
devc->logic_counter += sending_now;
}
- /* Analog, one probe at a time */
- if (devc->num_analog_probes > 0 && analog_todo > 0) {
+ /* Analog, one channel at a time */
+ if (devc->num_analog_channels > 0 && analog_todo > 0) {
sending_now = 0;
for (l = devc->analog_channel_groups; l; l = l->next) {
cg = l->data;
struct sr_dev_inst *sdi;
struct drv_context *drvc;
struct dev_context *devc;
- struct sr_channel *probe;
+ struct sr_channel *ch;
struct sr_serial_dev_inst *serial;
GSList *devices;
int retry, len, i, s;
sdi->conn = serial;
sdi->priv = devc;
sdi->driver = di;
- if (!(probe = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "P1")))
+ if (!(ch = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "P1")))
return NULL;
- sdi->probes = g_slist_append(sdi->probes, probe);
+ sdi->channels = g_slist_append(sdi->channels, ch);
drvc->instances = g_slist_append(drvc->instances, sdi);
devices = g_slist_append(devices, sdi);
break;
return NULL;
if (!(analog->data = g_try_malloc(sizeof(float))))
return NULL;
- analog->probes = sdi->probes;
+ analog->channels = sdi->channels;
analog->num_samples = 1;
if (is_oor)
*analog->data = NAN;
return NULL;
if (!(analog->data = g_try_malloc(sizeof(float))))
return NULL;
- analog->probes = sdi->probes;
+ analog->channels = sdi->channels;
analog->num_samples = 1;
*analog->data = fvalue;
analog->mq = -1;
fvalue = 1.0;
}
- analog.probes = sdi->probes;
+ analog.channels = sdi->channels;
analog.num_samples = 1;
analog.data = &fvalue;
analog.mq = devc->mq;
SR_CONF_CONTINUOUS,
};
-static const char *probe_names[] = {
+static const char *channel_names[] = {
"0", "1", "2", "3", "4", "5", "6", "7",
"8", "9", "10", "11", "12", "13", "14", "15",
NULL,
struct dev_context *devc;
struct sr_dev_inst *sdi;
struct sr_usb_dev_inst *usb;
- struct sr_channel *probe;
+ struct sr_channel *ch;
struct sr_config *src;
const struct fx2lafw_profile *prof;
GSList *l, *devices, *conn_devices;
struct libusb_device_descriptor des;
libusb_device **devlist;
- int devcnt, num_logic_probes, ret, i, j;
+ int devcnt, num_logic_channels, ret, i, j;
const char *conn;
drvc = di->priv;
return NULL;
sdi->driver = di;
- /* Fill in probelist according to this device's profile. */
- num_logic_probes = prof->dev_caps & DEV_CAPS_16BIT ? 16 : 8;
- for (j = 0; j < num_logic_probes; j++) {
- if (!(probe = sr_probe_new(j, SR_PROBE_LOGIC, TRUE,
- probe_names[j])))
+ /* Fill in channellist according to this device's profile. */
+ num_logic_channels = prof->dev_caps & DEV_CAPS_16BIT ? 16 : 8;
+ for (j = 0; j < num_logic_channels; j++) {
+ if (!(ch = sr_probe_new(j, SR_PROBE_LOGIC, TRUE,
+ channel_names[j])))
return NULL;
- sdi->probes = g_slist_append(sdi->probes, probe);
+ sdi->channels = g_slist_append(sdi->channels, ch);
}
devc = fx2lafw_dev_new();
usb = sdi->conn;
/* Configures devc->trigger_* and devc->sample_wide */
- if (fx2lafw_configure_probes(sdi) != SR_OK) {
- sr_err("Failed to configure probes.");
+ if (fx2lafw_configure_channels(sdi) != SR_OK) {
+ sr_err("Failed to configure channels.");
return SR_ERR;
}
return SR_OK;
}
-SR_PRIV int fx2lafw_configure_probes(const struct sr_dev_inst *sdi)
+SR_PRIV int fx2lafw_configure_channels(const struct sr_dev_inst *sdi)
{
struct dev_context *devc;
- struct sr_channel *probe;
+ struct sr_channel *ch;
GSList *l;
- int probe_bit, stage, i;
+ int channel_bit, stage, i;
char *tc;
devc = sdi->priv;
}
stage = -1;
- for (l = sdi->probes; l; l = l->next) {
- probe = (struct sr_channel *)l->data;
- if (probe->enabled == FALSE)
+ for (l = sdi->channels; l; l = l->next) {
+ ch = (struct sr_channel *)l->data;
+ if (ch->enabled == FALSE)
continue;
- if (probe->index > 7)
+ if (ch->index > 7)
devc->sample_wide = TRUE;
- probe_bit = 1 << (probe->index);
- if (!(probe->trigger))
+ channel_bit = 1 << (ch->index);
+ if (!(ch->trigger))
continue;
stage = 0;
- for (tc = probe->trigger; *tc; tc++) {
- devc->trigger_mask[stage] |= probe_bit;
+ for (tc = ch->trigger; *tc; tc++) {
+ devc->trigger_mask[stage] |= channel_bit;
if (*tc == '1')
- devc->trigger_value[stage] |= probe_bit;
+ devc->trigger_value[stage] |= channel_bit;
stage++;
if (stage > NUM_TRIGGER_STAGES)
return SR_ERR;
uint64_t samplerate, gboolean samplewide);
SR_PRIV gboolean fx2lafw_check_conf_profile(libusb_device *dev);
SR_PRIV int fx2lafw_dev_open(struct sr_dev_inst *sdi, struct sr_dev_driver *di);
-SR_PRIV int fx2lafw_configure_probes(const struct sr_dev_inst *sdi);
+SR_PRIV int fx2lafw_configure_channels(const struct sr_dev_inst *sdi);
SR_PRIV struct dev_context *fx2lafw_dev_new(void);
SR_PRIV void fx2lafw_abort_acquisition(struct dev_context *devc);
SR_PRIV void fx2lafw_receive_transfer(struct libusb_transfer *transfer);
struct drv_context *drvc;
struct dev_context *devc;
struct sr_config *src;
- struct sr_channel *probe;
+ struct sr_channel *ch;
struct sr_serial_dev_inst *serial;
GSList *l, *devices;
const char *conn, *serialcomm;
sdi->conn = serial;
sdi->priv = devc;
sdi->driver = &gmc_mh_1x_2x_rs232_driver_info;
- if (!(probe = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "P1")))
+ if (!(ch = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "P1")))
return NULL;
- sdi->probes = g_slist_append(sdi->probes, probe);
+ sdi->channels = g_slist_append(sdi->channels, ch);
drvc->instances = g_slist_append(drvc->instances, sdi);
devices = g_slist_append(devices, sdi);
}
struct drv_context *drvc;
struct dev_context *devc;
struct sr_config *src;
- struct sr_channel *probe;
+ struct sr_channel *ch;
struct sr_serial_dev_inst *serial;
GSList *l, *devices;
const char *conn, *serialcomm;
sdi->conn = serial;
sdi->priv = devc;
sdi->driver = &gmc_mh_2x_bd232_driver_info;
- if (!(probe = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "P1")))
+ if (!(ch = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "P1")))
goto exit_err;
- sdi->probes = g_slist_append(sdi->probes, probe);
+ sdi->channels = g_slist_append(sdi->channels, ch);
drvc->instances = g_slist_append(drvc->instances, sdi);
devices = g_slist_append(devices, sdi);
devc = sdi->priv;
memset(&analog, 0, sizeof(analog));
- analog.probes = sdi->probes;
+ analog.channels = sdi->channels;
analog.num_samples = 1;
analog.mq = devc->mq;
analog.unit = devc->unit;
SR_PRIV int hmo_request_data(const struct sr_dev_inst *sdi)
{
char command[MAX_COMMAND_SIZE];
- struct sr_channel *probe;
+ struct sr_channel *ch;
struct dev_context *devc;
struct scope_config *model;
devc = sdi->priv;
model = devc->model_config;
- probe = devc->current_probe->data;
+ ch = devc->current_channel->data;
- switch (probe->type) {
+ switch (ch->type) {
case SR_PROBE_ANALOG:
g_snprintf(command, sizeof(command),
(*model->scpi_dialect)[SCPI_CMD_GET_ANALOG_DATA],
- probe->index + 1);
+ ch->index + 1);
break;
case SR_PROBE_LOGIC:
g_snprintf(command, sizeof(command),
(*model->scpi_dialect)[SCPI_CMD_GET_DIG_DATA],
- probe->index < 8 ? 1 : 2);
+ ch->index < 8 ? 1 : 2);
break;
default:
- sr_err("Invalid probe type.");
+ sr_err("Invalid channel type.");
break;
}
return sr_scpi_send(sdi->conn, command);
}
-static int hmo_check_probes(GSList *probes)
+static int hmo_check_channels(GSList *channels)
{
GSList *l;
- struct sr_channel *probe;
+ struct sr_channel *ch;
gboolean enabled_pod1, enabled_pod2, enabled_chan3, enabled_chan4;
enabled_pod1 = enabled_pod2 = enabled_chan3 = enabled_chan4 = FALSE;
- for (l = probes; l; l = l->next) {
- probe = l->data;
- switch (probe->type) {
+ for (l = channels; l; l = l->next) {
+ ch = l->data;
+ switch (ch->type) {
case SR_PROBE_ANALOG:
- if (probe->index == 2)
+ if (ch->index == 2)
enabled_chan3 = TRUE;
- else if (probe->index == 3)
+ else if (ch->index == 3)
enabled_chan4 = TRUE;
break;
case SR_PROBE_LOGIC:
- if (probe->index < 8)
+ if (ch->index < 8)
enabled_pod1 = TRUE;
else
enabled_pod2 = TRUE;
return SR_OK;
}
-static int hmo_setup_probes(const struct sr_dev_inst *sdi)
+static int hmo_setup_channels(const struct sr_dev_inst *sdi)
{
GSList *l;
unsigned int i;
char command[MAX_COMMAND_SIZE];
struct scope_state *state;
struct scope_config *model;
- struct sr_channel *probe;
+ struct sr_channel *ch;
struct dev_context *devc;
struct sr_scpi_dev_inst *scpi;
pod_enabled = g_try_malloc0(sizeof(gboolean) * model->digital_pods);
- for (l = sdi->probes; l; l = l->next) {
- probe = l->data;
- switch (probe->type) {
+ for (l = sdi->channels; l; l = l->next) {
+ ch = l->data;
+ switch (ch->type) {
case SR_PROBE_ANALOG:
- if (probe->enabled == state->analog_channels[probe->index].state)
+ if (ch->enabled == state->analog_channels[ch->index].state)
break;
g_snprintf(command, sizeof(command),
(*model->scpi_dialect)[SCPI_CMD_SET_ANALOG_CHAN_STATE],
- probe->index + 1, probe->enabled);
+ ch->index + 1, ch->enabled);
if (sr_scpi_send(scpi, command) != SR_OK)
return SR_ERR;
- state->analog_channels[probe->index].state = probe->enabled;
+ state->analog_channels[ch->index].state = ch->enabled;
setup_changed = TRUE;
break;
case SR_PROBE_LOGIC:
/*
* A digital POD needs to be enabled for every group of
- * 8 probes.
+ * 8 channels.
*/
- if (probe->enabled)
- pod_enabled[probe->index < 8 ? 0 : 1] = TRUE;
+ if (ch->enabled)
+ pod_enabled[ch->index < 8 ? 0 : 1] = TRUE;
- if (probe->enabled == state->digital_channels[probe->index])
+ if (ch->enabled == state->digital_channels[ch->index])
break;
g_snprintf(command, sizeof(command),
(*model->scpi_dialect)[SCPI_CMD_SET_DIG_CHAN_STATE],
- probe->index, probe->enabled);
+ ch->index, ch->enabled);
if (sr_scpi_send(scpi, command) != SR_OK)
return SR_ERR;
- state->digital_channels[probe->index] = probe->enabled;
+ state->digital_channels[ch->index] = ch->enabled;
setup_changed = TRUE;
break;
default:
{
GSList *l;
gboolean digital_added;
- struct sr_channel *probe;
+ struct sr_channel *ch;
struct dev_context *devc;
struct sr_scpi_dev_inst *scpi;
devc = sdi->priv;
digital_added = FALSE;
- for (l = sdi->probes; l; l = l->next) {
- probe = l->data;
- if (!probe->enabled)
+ for (l = sdi->channels; l; l = l->next) {
+ ch = l->data;
+ if (!ch->enabled)
continue;
- /* Only add a single digital probe. */
- if (probe->type != SR_PROBE_LOGIC || !digital_added) {
- devc->enabled_probes = g_slist_append(
- devc->enabled_probes, probe);
- if (probe->type == SR_PROBE_LOGIC)
+ /* Only add a single digital channel. */
+ if (ch->type != SR_PROBE_LOGIC || !digital_added) {
+ devc->enabled_channels = g_slist_append(
+ devc->enabled_channels, ch);
+ if (ch->type == SR_PROBE_LOGIC)
digital_added = TRUE;
}
}
- if (!devc->enabled_probes)
+ if (!devc->enabled_channels)
return SR_ERR;
- if (hmo_check_probes(devc->enabled_probes) != SR_OK) {
- sr_err("Invalid probe configuration specified!");
+ if (hmo_check_channels(devc->enabled_channels) != SR_OK) {
+ sr_err("Invalid channel configuration specified!");
return SR_ERR_NA;
}
- if (hmo_setup_probes(sdi) != SR_OK) {
- sr_err("Failed to setup probe configuration!");
+ if (hmo_setup_channels(sdi) != SR_OK) {
+ sr_err("Failed to setup channel configuration!");
return SR_ERR;
}
/* Send header packet to the session bus. */
std_session_send_df_header(cb_data, LOG_PREFIX);
- devc->current_probe = devc->enabled_probes;
+ devc->current_channel = devc->enabled_channels;
return hmo_request_data(sdi);
}
devc = sdi->priv;
devc->num_frames = 0;
- g_slist_free(devc->enabled_probes);
- devc->enabled_probes = NULL;
+ g_slist_free(devc->enabled_channels);
+ devc->enabled_channels = NULL;
scpi = sdi->conn;
sr_scpi_source_remove(scpi);
{ 10, 1 },
};
-static const char *scope_analog_probe_names[] = {
+static const char *scope_analog_channel_names[] = {
"CH1",
"CH2",
"CH3",
"CH4",
};
-static const char *scope_digital_probe_names[] = {
+static const char *scope_digital_channel_names[] = {
"D0",
"D1",
"D2",
.digital_channels = 8,
.digital_pods = 1,
- .analog_names = &scope_analog_probe_names,
- .digital_names = &scope_digital_probe_names,
+ .analog_names = &scope_analog_channel_names,
+ .digital_names = &scope_digital_channel_names,
.hw_caps = &hmo_hwcaps,
.num_hwcaps = ARRAY_SIZE(hmo_hwcaps),
.digital_channels = 8,
.digital_pods = 1,
- .analog_names = &scope_analog_probe_names,
- .digital_names = &scope_digital_probe_names,
+ .analog_names = &scope_analog_channel_names,
+ .digital_names = &scope_digital_channel_names,
.hw_caps = &hmo_hwcaps,
.num_hwcaps = ARRAY_SIZE(hmo_hwcaps),
char tmp[25];
int model_index;
unsigned int i, j;
- struct sr_channel *probe;
+ struct sr_channel *ch;
struct dev_context *devc;
devc = sdi->priv;
/* Add analog channels. */
for (i = 0; i < scope_models[model_index].analog_channels; i++) {
- if (!(probe = sr_probe_new(i, SR_PROBE_ANALOG, TRUE,
+ if (!(ch = sr_probe_new(i, SR_PROBE_ANALOG, TRUE,
(*scope_models[model_index].analog_names)[i])))
return SR_ERR_MALLOC;
- sdi->probes = g_slist_append(sdi->probes, probe);
+ sdi->channels = g_slist_append(sdi->channels, ch);
devc->analog_groups[i].name =
(char *)(*scope_models[model_index].analog_names)[i];
- devc->analog_groups[i].channels = g_slist_append(NULL, probe);
+ devc->analog_groups[i].channels = g_slist_append(NULL, ch);
sdi->channel_groups = g_slist_append(sdi->channel_groups,
&devc->analog_groups[i]);
/* Add digital channels. */
for (i = 0; i < scope_models[model_index].digital_channels; i++) {
- if (!(probe = sr_probe_new(i, SR_PROBE_LOGIC, TRUE,
+ if (!(ch = sr_probe_new(i, SR_PROBE_LOGIC, TRUE,
(*scope_models[model_index].digital_names)[i])))
return SR_ERR_MALLOC;
- sdi->probes = g_slist_append(sdi->probes, probe);
+ sdi->channels = g_slist_append(sdi->channels, ch);
devc->digital_groups[i < 8 ? 0 : 1].channels = g_slist_append(
- devc->digital_groups[i < 8 ? 0 : 1].channels, probe);
+ devc->digital_groups[i < 8 ? 0 : 1].channels, ch);
}
devc->model_config = &scope_models[model_index];
SR_PRIV int hmo_receive_data(int fd, int revents, void *cb_data)
{
- struct sr_channel *probe;
+ struct sr_channel *ch;
struct sr_dev_inst *sdi;
struct dev_context *devc;
struct sr_datafeed_packet packet;
return TRUE;
if (revents == G_IO_IN) {
- probe = devc->current_probe->data;
+ ch = devc->current_channel->data;
- switch (probe->type) {
+ switch (ch->type) {
case SR_PROBE_ANALOG:
if (sr_scpi_get_floatv(sdi->conn, NULL, &data) != SR_OK) {
if (data)
packet.type = SR_DF_FRAME_BEGIN;
sr_session_send(sdi, &packet);
- analog.probes = g_slist_append(NULL, probe);
+ analog.channels = g_slist_append(NULL, ch);
analog.num_samples = data->len;
analog.data = (float *) data->data;
analog.mq = SR_MQ_VOLTAGE;
packet.type = SR_DF_ANALOG;
packet.payload = &analog;
sr_session_send(cb_data, &packet);
- g_slist_free(analog.probes);
+ g_slist_free(analog.channels);
g_array_free(data, TRUE);
break;
case SR_PROBE_LOGIC:
g_array_free(data, TRUE);
break;
default:
- sr_err("Invalid probe type.");
+ sr_err("Invalid channel type.");
break;
}
packet.type = SR_DF_FRAME_END;
sr_session_send(sdi, &packet);
- if (devc->current_probe->next) {
- devc->current_probe = devc->current_probe->next;
+ if (devc->current_channel->next) {
+ devc->current_channel = devc->current_channel->next;
hmo_request_data(sdi);
} else if (++devc->num_frames == devc->frame_limit) {
sdi->driver->dev_acquisition_stop(sdi, cb_data);
} else {
- devc->current_probe = devc->enabled_probes;
+ devc->current_channel = devc->enabled_channels;
hmo_request_data(sdi);
}
}
struct sr_channel_group *analog_groups;
struct sr_channel_group *digital_groups;
- GSList *enabled_probes;
- GSList *current_probe;
+ GSList *enabled_channels;
+ GSList *current_channel;
uint64_t num_frames;
uint64_t frame_limit;
SR_CONF_NUM_VDIV,
};
-static const char *probe_names[] = {
+static const char *channel_names[] = {
"CH1", "CH2",
NULL,
};
static struct sr_dev_inst *dso_dev_new(int index, const struct dso_profile *prof)
{
struct sr_dev_inst *sdi;
- struct sr_channel *probe;
+ struct sr_channel *ch;
struct drv_context *drvc;
struct dev_context *devc;
int i;
sdi->driver = di;
/*
- * Add only the real probes -- EXT isn't a source of data, only
+ * Add only the real channels -- EXT isn't a source of data, only
* a trigger source internal to the device.
*/
- for (i = 0; probe_names[i]; i++) {
- if (!(probe = sr_probe_new(i, SR_PROBE_ANALOG, TRUE,
- probe_names[i])))
+ for (i = 0; channel_names[i]; i++) {
+ if (!(ch = sr_probe_new(i, SR_PROBE_ANALOG, TRUE,
+ channel_names[i])))
return NULL;
- sdi->probes = g_slist_append(sdi->probes, probe);
+ sdi->channels = g_slist_append(sdi->channels, ch);
}
if (!(devc = g_try_malloc0(sizeof(struct dev_context)))) {
return sdi;
}
-static int configure_probes(const struct sr_dev_inst *sdi)
+static int configure_channels(const struct sr_dev_inst *sdi)
{
struct dev_context *devc;
- struct sr_channel *probe;
+ struct sr_channel *ch;
const GSList *l;
int p;
devc = sdi->priv;
- g_slist_free(devc->enabled_probes);
+ g_slist_free(devc->enabled_channels);
devc->ch1_enabled = devc->ch2_enabled = FALSE;
- for (l = sdi->probes, p = 0; l; l = l->next, p++) {
- probe = l->data;
+ for (l = sdi->channels, p = 0; l; l = l->next, p++) {
+ ch = l->data;
if (p == 0)
- devc->ch1_enabled = probe->enabled;
+ devc->ch1_enabled = ch->enabled;
else
- devc->ch2_enabled = probe->enabled;
- if (probe->enabled)
- devc->enabled_probes = g_slist_append(devc->enabled_probes, probe);
+ devc->ch2_enabled = ch->enabled;
+ if (ch->enabled)
+ devc->enabled_channels = g_slist_append(devc->enabled_channels, ch);
}
return SR_OK;
devc = priv;
g_free(devc->triggersource);
- g_slist_free(devc->enabled_probes);
+ g_slist_free(devc->enabled_channels);
}
struct sr_datafeed_analog analog;
struct dev_context *devc;
float ch1, ch2, range;
- int num_probes, data_offset, i;
+ int num_channels, data_offset, i;
devc = sdi->priv;
- num_probes = (devc->ch1_enabled && devc->ch2_enabled) ? 2 : 1;
+ num_channels = (devc->ch1_enabled && devc->ch2_enabled) ? 2 : 1;
packet.type = SR_DF_ANALOG;
packet.payload = &analog;
/* TODO: support for 5xxx series 9-bit samples */
- analog.probes = devc->enabled_probes;
+ analog.channels = devc->enabled_channels;
analog.num_samples = num_samples;
analog.mq = SR_MQ_VOLTAGE;
analog.unit = SR_UNIT_VOLT;
/* TODO: Check malloc return value. */
- analog.data = g_try_malloc(analog.num_samples * sizeof(float) * num_probes);
+ analog.data = g_try_malloc(analog.num_samples * sizeof(float) * num_channels);
data_offset = 0;
for (i = 0; i < analog.num_samples; i++) {
/*
struct timeval tv;
struct dev_context *devc;
struct drv_context *drvc = di->priv;
- int num_probes;
+ int num_channels;
uint32_t trigger_offset;
uint8_t capturestate;
/* Remember where in the captured frame the trigger is. */
devc->trigger_offset = trigger_offset;
- num_probes = (devc->ch1_enabled && devc->ch2_enabled) ? 2 : 1;
+ num_channels = (devc->ch1_enabled && devc->ch2_enabled) ? 2 : 1;
/* TODO: Check malloc return value. */
- devc->framebuf = g_try_malloc(devc->framesize * num_probes * 2);
+ devc->framebuf = g_try_malloc(devc->framesize * num_channels * 2);
devc->samp_buffered = devc->samp_received = 0;
/* Tell the scope to send us the first frame. */
devc = sdi->priv;
devc->cb_data = cb_data;
- if (configure_probes(sdi) != SR_OK) {
- sr_err("Failed to configure probes.");
+ if (configure_channels(sdi) != SR_OK) {
+ sr_err("Failed to configure channels.");
return SR_ERR;
}
void *cb_data;
uint64_t limit_frames;
uint64_t num_frames;
- GSList *enabled_probes;
+ GSList *enabled_channels;
/* We can't keep track of an FX2-based device after upgrading
* the firmware (it re-enumerates into a different device address
* after the upgrade) this is like a global lock. No device will open
SR_MHZ(20),
};
-static const char *probe_names[NUM_PROBES + 1] = {
+static const char *channel_names[NUM_PROBES + 1] = {
"0", "1", "2", "3",
NULL,
};
GSList *usb_devices, *devices, *l;
struct drv_context *drvc;
struct sr_dev_inst *sdi;
- struct sr_channel *probe;
+ struct sr_channel *ch;
struct dev_context *devc;
struct sr_usb_dev_inst *usb;
struct device_info dev_info;
sdi->inst_type = SR_INST_USB;
sdi->conn = usb;
- for (i = 0; probe_names[i]; i++) {
- probe = sr_probe_new(i, SR_PROBE_LOGIC, TRUE,
- probe_names[i]);
- sdi->probes = g_slist_append(sdi->probes, probe);
- devc->probes[i] = probe;
+ for (i = 0; channel_names[i]; i++) {
+ ch = sr_probe_new(i, SR_PROBE_LOGIC, TRUE,
+ channel_names[i]);
+ sdi->channels = g_slist_append(sdi->channels, ch);
+ devc->channels[i] = ch;
}
devc->state = STATE_IDLE;
if (trigger_bytes % PACKET_NUM_SAMPLE_BYTES != 0)
devc->num_sample_packets++;
- devc->num_enabled_probes = 0;
+ devc->num_enabled_channels = 0;
/*
- * Count the number of enabled probes and number them for a sequential
+ * Count the number of enabled channels and number them for a sequential
* access.
*/
for (i = 0, j = 0; i < NUM_PROBES; i++) {
- if (devc->probes[i]->enabled) {
- devc->num_enabled_probes++;
- devc->probe_map[j] = i;
+ if (devc->channels[i]->enabled) {
+ devc->num_enabled_channels++;
+ devc->channel_map[j] = i;
j++;
}
}
- sr_dbg("Number of enabled probes: %i.", devc->num_enabled_probes);
+ sr_dbg("Number of enabled channels: %i.", devc->num_enabled_channels);
/* Set up the transfer buffer for the acquisition. */
devc->xfer_data_out[0] = CMD_SAMPLE;
devc = sdi->priv;
- if (devc->probes[devc->channel]->enabled) {
+ if (devc->channels[devc->channel]->enabled) {
offset = devc->sample_packet * PACKET_NUM_SAMPLE_BYTES;
/*
* enabled one for an uniform access to them. Note that the currently
* received samples always belong to the last enabled channel.
*/
- for (i = 0; i < devc->num_enabled_probes - 1; i++)
- ptr[i] = devc->sample_buffer[devc->probe_map[i]] + offset;
+ for (i = 0; i < devc->num_enabled_channels - 1; i++)
+ ptr[i] = devc->sample_buffer[devc->channel_map[i]] + offset;
/*
* Skip the first 4 bytes of the buffer because they contain channel
* Extract the current sample for each enabled channel
* and store them in the buffer.
*/
- for (j = 0; j < devc->num_enabled_probes; j++) {
+ for (j = 0; j < devc->num_enabled_channels; j++) {
tmp = (ptr[j][i] & (1 << k)) >> k;
- buffer[n] |= tmp << devc->probe_map[j];
+ buffer[n] |= tmp << devc->channel_map[j];
}
n++;
devc->wait_data_ready_time = g_get_monotonic_time();
}
} else if (devc->state == STATE_RECEIVE_DATA) {
- last_channel = devc->probe_map[devc->num_enabled_probes - 1];
+ last_channel = devc->channel_map[devc->num_enabled_channels - 1];
if (devc->channel < last_channel) {
buffer_sample_data(sdi);
} else {
/*
* Stop acquisition because all samples of enabled
- * probes are processed.
+ * channels are processed.
*/
devc->next_state = STATE_RESET_AND_IDLE;
}
SR_PRIV void sl2_configure_trigger(const struct sr_dev_inst *sdi)
{
struct dev_context *devc;
- struct sr_channel *probe;
+ struct sr_channel *ch;
uint8_t trigger_type;
- int probe_index, num_triggers_anyedge;
+ int channel_index, num_triggers_anyedge;
char *trigger;
GSList *l;
num_triggers_anyedge = 0;
- for (l = sdi->probes, probe_index = 0; l; l = l->next, probe_index++) {
- probe = l->data;
- trigger = probe->trigger;
+ for (l = sdi->channels, channel_index = 0; l; l = l->next, channel_index++) {
+ ch = l->data;
+ trigger = ch->trigger;
- if (!trigger || !probe->enabled)
+ if (!trigger || !ch->enabled)
continue;
switch (*trigger) {
continue;
}
- devc->trigger_channel = probe_index + 1;
+ devc->trigger_channel = channel_index + 1;
devc->trigger_type = trigger_type;
}
void *cb_data;
- /* Array to provide an index based access to all probes. */
- const struct sr_channel *probes[NUM_PROBES];
+ /* Array to provide an index based access to all channels. */
+ const struct sr_channel *channels[NUM_PROBES];
struct libusb_transfer *xfer_in, *xfer_out;
/* Channel number that is currently processed. */
uint8_t channel;
- /* Number of enabled probes. */
- unsigned int num_enabled_probes;
+ /* Number of enabled channels. */
+ unsigned int num_enabled_channels;
- /* Array to provide a sequential access to all enabled probe indices. */
- uint8_t probe_map[NUM_PROBES];
+ /* Array to provide a sequential access to all enabled channel indices. */
+ uint8_t channel_map[NUM_PROBES];
/* Indicates whether a transfer failed. */
gboolean transfer_error;
SR_CONF_CONTINUOUS, // TODO?
};
-/* Probes are numbered 1-9. */
-static const char *probe_names[] = {
+/* Channels are numbered 1-9. */
+static const char *channel_names[] = {
"1", "2", "3", "4", "5", "6", "7", "8", "9",
NULL,
};
static GSList *scan(GSList *options)
{
struct sr_dev_inst *sdi;
- struct sr_channel *probe;
+ struct sr_channel *ch;
struct drv_context *drvc;
struct dev_context *devc;
GSList *devices;
sdi->driver = di;
sdi->priv = devc;
- for (i = 0; probe_names[i]; i++) {
- if (!(probe = sr_probe_new(i, SR_PROBE_LOGIC, TRUE,
- probe_names[i])))
+ for (i = 0; channel_names[i]; i++) {
+ if (!(ch = sr_probe_new(i, SR_PROBE_LOGIC, TRUE,
+ channel_names[i])))
return NULL;
- sdi->probes = g_slist_append(sdi->probes, probe);
+ sdi->channels = g_slist_append(sdi->channels, ch);
}
devices = g_slist_append(devices, sdi);
if (!devc->ftdic)
return SR_ERR_BUG;
- /* TODO: Configure probes later (thresholds etc.). */
+ /* TODO: Configure channels later (thresholds etc.). */
devc->cb_data = cb_data;
packet.type = SR_DF_LOGIC;
packet.payload = &logic;
logic.length = samples_to_send * 2;
- logic.unitsize = 2; /* We need 2 bytes for 9 probes. */
+ logic.unitsize = 2; /* We need 2 bytes for 9 channels. */
logic.data = devc->sample_buf;
sr_session_send(devc->cb_data, &packet);
{
uint8_t buf[4];
- /* Threshold and differential probe settings not yet implemented. */
+ /* Threshold and differential channel settings not yet implemented. */
buf[0] = 0x89;
- buf[1] = 0x7f; /* Logic level threshold for probes 1-4. */
+ buf[1] = 0x7f; /* Logic level threshold for channels 1-4. */
buf[2] = 0x8a;
- buf[3] = 0x7f; /* Logic level threshold for probes 5-9. */
+ buf[3] = 0x7f; /* Logic level threshold for channels 5-9. */
if (scanaplus_write(devc, (uint8_t *)&buf, 4) < 0)
return SR_ERR;
buf[0] = 0x88;
- buf[1] = 0x40; /* Special config of probes 5/6 and 7/8. */
+ buf[1] = 0x40; /* Special config of channels 5/6 and 7/8. */
/* 0x40: normal, 0x50: ch56 diff, 0x48: ch78 diff, 0x58: ch5678 diff */
if (scanaplus_write(devc, (uint8_t *)&buf, 2) < 0)
return SR_ERR;
/*
* After a ScanaPLUS acquisition starts, a bunch of samples will be
* returned as all-zero, no matter which signals are actually present
- * on the probes. This is probably due to the FPGA reconfiguring some
+ * on the channels. This is probably due to the FPGA reconfiguring some
* of its internal state/config during this time.
*
* As far as we know there is apparently no way for the PC-side to
struct drv_context *drvc;
struct dev_context *devc;
struct sr_dev_inst *sdi;
- struct sr_channel *probe;
+ struct sr_channel *ch;
GSList *usb_devices, *devices, *l;
char *model;
sdi->driver = di;
sdi->inst_type = SR_INST_USB;
sdi->conn = l->data;
- if (!(probe = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "SPL")))
+ if (!(ch = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "SPL")))
return NULL;
- sdi->probes = g_slist_append(sdi->probes, probe);
+ sdi->channels = g_slist_append(sdi->channels, ch);
if (!(devc = g_try_malloc(sizeof(struct dev_context)))) {
sr_dbg("Device context malloc failed.");
analog.mq = SR_MQ_SOUND_PRESSURE_LEVEL;
analog.mqflags = devc->mqflags;
analog.unit = SR_UNIT_DECIBEL_SPL;
- analog.probes = sdi->probes;
+ analog.channels = sdi->channels;
analog.num_samples = buf_len;
analog.data = buf;
packet.type = SR_DF_ANALOG;
struct dev_context *devc;
const struct elusb_profile *profile;
struct sr_dev_inst *sdi;
- struct sr_channel *probe;
+ struct sr_channel *ch;
int modelid, i;
char firmware[5];
sdi->driver = di;
if (profile->logformat == LOG_TEMP_RH) {
- /* Model this as two probes: temperature and humidity. */
- if (!(probe = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "Temp")))
+ /* Model this as two channels: temperature and humidity. */
+ if (!(ch = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "Temp")))
return NULL;
- sdi->probes = g_slist_append(NULL, probe);
- if (!(probe = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "Hum")))
+ sdi->channels = g_slist_append(NULL, ch);
+ if (!(ch = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "Hum")))
return NULL;
- sdi->probes = g_slist_append(sdi->probes, probe);
+ sdi->channels = g_slist_append(sdi->channels, ch);
} else if (profile->logformat == LOG_CO) {
- if (!(probe = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "CO")))
+ if (!(ch = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "CO")))
return NULL;
- sdi->probes = g_slist_append(NULL, probe);
+ sdi->channels = g_slist_append(NULL, ch);
} else {
- if (!(probe = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "P1")))
+ if (!(ch = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "P1")))
return NULL;
- sdi->probes = g_slist_append(NULL, probe);
+ sdi->channels = g_slist_append(NULL, ch);
}
if (!(devc = g_try_malloc0(sizeof(struct dev_context))))
struct dev_context *devc;
struct sr_datafeed_packet packet;
struct sr_datafeed_analog analog;
- struct sr_channel *probe;
+ struct sr_channel *ch;
float *temp, *rh;
uint16_t s;
int samples, samples_left, i, j;
}
analog.num_samples = j;
- probe = sdi->probes->data;
- if (probe->enabled) {
- analog.probes = g_slist_append(NULL, probe);
+ ch = sdi->channels->data;
+ if (ch->enabled) {
+ analog.channels = g_slist_append(NULL, ch);
analog.mq = SR_MQ_TEMPERATURE;
if (devc->temp_unit == 1)
analog.unit = SR_UNIT_FAHRENHEIT;
sr_session_send(devc->cb_data, &packet);
}
- probe = sdi->probes->next->data;
- if (probe->enabled) {
- analog.probes = g_slist_append(NULL, probe);
+ ch = sdi->channels->next->data;
+ if (ch->enabled) {
+ analog.channels = g_slist_append(NULL, ch);
analog.mq = SR_MQ_RELATIVE_HUMIDITY;
analog.unit = SR_UNIT_PERCENTAGE;
analog.data = rh;
case LOG_CO:
packet.type = SR_DF_ANALOG;
packet.payload = &analog;
- analog.probes = sdi->probes;
+ analog.channels = sdi->channels;
analog.num_samples = samples;
analog.mq = SR_MQ_CARBON_MONOXIDE;
analog.unit = SR_UNIT_CONCENTRATION;
};
/*
- * Probes are numbered 0 to 7.
+ * Channels are numbered 0 to 7.
*
* See also: http://www.linkinstruments.com/images/mso19_1113.gif
*/
-SR_PRIV const char *mso19_probe_names[NUM_PROBES + 1] = {
+SR_PRIV const char *mso19_channel_names[NUM_PROBES + 1] = {
/* Note: DSO needs to be first. */
"DSO", "0", "1", "2", "3", "4", "5", "6", "7", NULL,
};
sdi->priv = devc;
for (i = 0; i < NUM_PROBES; i++) {
- struct sr_channel *probe;
+ struct sr_channel *ch;
ptype = (i == 0) ? SR_PROBE_ANALOG : SR_PROBE_LOGIC;
- if (!(probe = sr_probe_new(i, ptype, TRUE,
- mso19_probe_names[i])))
+ if (!(ch = sr_probe_new(i, ptype, TRUE,
+ mso19_channel_names[i])))
return 0;
- sdi->probes = g_slist_append(sdi->probes, probe);
+ sdi->channels = g_slist_append(sdi->channels, ch);
}
//Add the driver
devc = sdi->priv;
- if (mso_configure_probes(sdi) != SR_OK) {
- sr_err("Failed to configure probes.");
+ if (mso_configure_channels(sdi) != SR_OK) {
+ sr_err("Failed to configure channels.");
return SR_ERR;
}
/* Send header packet to the session bus. */
std_session_send_df_header(cb_data, LOG_PREFIX);
- /* Our first probe is analog, the other 8 are of type 'logic'. */
+ /* Our first channel is analog, the other 8 are of type 'logic'. */
/* TODO. */
serial_source_add(devc->serial, G_IO_IN, -1, mso_receive_data, cb_data);
return TRUE;
}
-SR_PRIV int mso_configure_probes(const struct sr_dev_inst *sdi)
+SR_PRIV int mso_configure_channels(const struct sr_dev_inst *sdi)
{
struct dev_context *devc;
- struct sr_channel *probe;
+ struct sr_channel *ch;
GSList *l;
char *tc;
devc->trigger_chan = 3; //LA combination trigger
devc->use_trigger = FALSE;
- for (l = sdi->probes; l; l = l->next) {
- probe = (struct sr_channel *)l->data;
- if (probe->enabled == FALSE)
+ for (l = sdi->channels; l; l = l->next) {
+ ch = (struct sr_channel *)l->data;
+ if (ch->enabled == FALSE)
continue;
- int probe_bit = 1 << (probe->index);
- if (!(probe->trigger))
+ int channel_bit = 1 << (ch->index);
+ if (!(ch->trigger))
continue;
devc->use_trigger = TRUE;
//Configure trigger mask and value.
- for (tc = probe->trigger; *tc; tc++) {
- devc->la_trigger_mask &= ~probe_bit;
+ for (tc = ch->trigger; *tc; tc++) {
+ devc->la_trigger_mask &= ~channel_bit;
if (*tc == '1')
- devc->la_trigger |= probe_bit;
+ devc->la_trigger |= channel_bit;
}
}
SR_PRIV int mso_reset_fsm(struct sr_dev_inst *sdi);
SR_PRIV int mso_toggle_led(struct sr_dev_inst *sdi, int state);
-SR_PRIV int mso_configure_probes(const struct sr_dev_inst *sdi);
+SR_PRIV int mso_configure_channels(const struct sr_dev_inst *sdi);
SR_PRIV void stop_acquisition(const struct sr_dev_inst *sdi);
/* bank agnostic registers */
struct sr_dev_inst *sdi;
struct drv_context *drvc;
struct dev_context *devc;
- struct sr_channel *probe;
+ struct sr_channel *ch;
struct sr_serial_dev_inst *serial;
GSList *devices;
sdi->priv = devc;
sdi->driver = mic_devs[idx].di;
- if (!(probe = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "Temperature")))
+ if (!(ch = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "Temperature")))
goto scan_cleanup;
- sdi->probes = g_slist_append(sdi->probes, probe);
+ sdi->channels = g_slist_append(sdi->channels, ch);
if (mic_devs[idx].has_humidity) {
- if (!(probe = sr_probe_new(1, SR_PROBE_ANALOG, TRUE, "Humidity")))
+ if (!(ch = sr_probe_new(1, SR_PROBE_ANALOG, TRUE, "Humidity")))
goto scan_cleanup;
- sdi->probes = g_slist_append(sdi->probes, probe);
+ sdi->channels = g_slist_append(sdi->channels, ch);
}
drvc->instances = g_slist_append(drvc->instances, sdi);
/* Clear 'analog', otherwise it'll contain random garbage. */
memset(&analog, 0, sizeof(struct sr_datafeed_analog));
- /* Common values for both probes. */
+ /* Common values for both channels. */
packet.type = SR_DF_ANALOG;
packet.payload = &analog;
analog.num_samples = 1;
/* Temperature. */
- l = g_slist_copy(sdi->probes);
+ l = g_slist_copy(sdi->channels);
l = g_slist_remove_link(l, g_slist_nth(l, 1));
- analog.probes = l;
+ analog.channels = l;
analog.mq = SR_MQ_TEMPERATURE;
analog.unit = SR_UNIT_CELSIUS; /* TODO: Use C/F correctly. */
analog.data = &temperature;
/* Humidity. */
if (mic_devs[idx].has_humidity) {
- l = g_slist_copy(sdi->probes);
+ l = g_slist_copy(sdi->channels);
l = g_slist_remove_link(l, g_slist_nth(l, 0));
- analog.probes = l;
+ analog.channels = l;
analog.mq = SR_MQ_RELATIVE_HUMIDITY;
analog.unit = SR_UNIT_PERCENTAGE;
analog.data = &humidity;
struct drv_context *drvc;
struct dev_context *devc;
struct sr_config *src;
- struct sr_channel *probe;
+ struct sr_channel *ch;
struct sr_serial_dev_inst *serial;
GSList *l, *devices;
int len, cnt;
sdi->conn = serial;
sdi->priv = devc;
sdi->driver = di;
- if (!(probe = sr_probe_new(0, SR_PROBE_ANALOG, TRUE,
+ if (!(ch = sr_probe_new(0, SR_PROBE_ANALOG, TRUE,
"P1")))
return NULL;
- sdi->probes = g_slist_append(sdi->probes, probe);
+ sdi->channels = g_slist_append(sdi->channels, ch);
drvc->instances = g_slist_append(drvc->instances, sdi);
devices = g_slist_append(devices, sdi);
break;
(double)scale, (double)value);
/* Finish and send packet. */
- analog.probes = sdi->probes;
+ analog.channels = sdi->channels;
analog.num_samples = 1;
analog.data = &value;
STR_PATTERN_INTERNAL,
};
-/* Probes are numbered 0-31 (on the PCB silkscreen). */
-SR_PRIV const char *ols_probe_names[NUM_PROBES + 1] = {
+/* Channels are numbered 0-31 (on the PCB silkscreen). */
+SR_PRIV const char *ols_channel_names[NUM_PROBES + 1] = {
"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12",
"13", "14", "15", "16", "17", "18", "19", "20", "21", "22", "23",
"24", "25", "26", "27", "28", "29", "30", "31",
struct sr_dev_inst *sdi;
struct drv_context *drvc;
struct dev_context *devc;
- struct sr_channel *probe;
+ struct sr_channel *ch;
struct sr_serial_dev_inst *serial;
GPollFD probefd;
GSList *l, *devices;
"Sump", "Logic Analyzer", "v1.0");
sdi->driver = di;
for (i = 0; i < 32; i++) {
- if (!(probe = sr_probe_new(i, SR_PROBE_LOGIC, TRUE,
- ols_probe_names[i])))
+ if (!(ch = sr_probe_new(i, SR_PROBE_LOGIC, TRUE,
+ ols_channel_names[i])))
return 0;
- sdi->probes = g_slist_append(sdi->probes, probe);
+ sdi->channels = g_slist_append(sdi->channels, ch);
}
devc = ols_dev_new();
sdi->priv = devc;
sr_dbg("Failed to set default samplerate (%"PRIu64").",
DEFAULT_SAMPLERATE);
/* Clear trigger masks, values and stages. */
- ols_configure_probes(sdi);
+ ols_configure_channels(sdi);
sdi->inst_type = SR_INST_SERIAL;
sdi->conn = serial;
/* Device didn't specify sample memory size in metadata. */
return SR_ERR_NA;
/*
- * Channel groups are turned off if no probes in that group are
+ * Channel groups are turned off if no channels in that group are
* enabled, making more room for samples for the enabled group.
*/
- ols_configure_probes(sdi);
+ ols_configure_channels(sdi);
num_channels = 0;
for (i = 0; i < 4; i++) {
- if (devc->probe_mask & (0xff << (i * 8)))
+ if (devc->channel_mask & (0xff << (i * 8)))
num_channels++;
}
grange[0] = g_variant_new_uint64(MIN_NUM_SAMPLES);
devc = sdi->priv;
serial = sdi->conn;
- if (ols_configure_probes(sdi) != SR_OK) {
- sr_err("Failed to configure probes.");
+ if (ols_configure_channels(sdi) != SR_OK) {
+ sr_err("Failed to configure channels.");
return SR_ERR;
}
/*
* Enable/disable channel groups in the flag register according to the
- * probe mask. Calculate this here, because num_channels is needed
+ * channel mask. Calculate this here, because num_channels is needed
* to limit readcount.
*/
changrp_mask = 0;
num_channels = 0;
for (i = 0; i < 4; i++) {
- if (devc->probe_mask & (0xff << (i * 8))) {
+ if (devc->channel_mask & (0xff << (i * 8))) {
changrp_mask |= (1 << i);
num_channels++;
}
/* Basic triggers. */
if (devc->trigger_mask[0] != 0x00000000) {
- /* At least one probe has a trigger on it. */
+ /* At least one channel has a trigger on it. */
delaycount = readcount * (1 - devc->capture_ratio / 100.0);
devc->trigger_at = (readcount - delaycount) * 4 - devc->num_stages;
for (i = 0; i <= devc->num_stages; i++) {
return SR_OK;
}
-SR_PRIV int ols_configure_probes(const struct sr_dev_inst *sdi)
+SR_PRIV int ols_configure_channels(const struct sr_dev_inst *sdi)
{
struct dev_context *devc;
- const struct sr_channel *probe;
+ const struct sr_channel *ch;
const GSList *l;
- int probe_bit, stage, i;
+ int channel_bit, stage, i;
char *tc;
devc = sdi->priv;
- devc->probe_mask = 0;
+ devc->channel_mask = 0;
for (i = 0; i < NUM_TRIGGER_STAGES; i++) {
devc->trigger_mask[i] = 0;
devc->trigger_value[i] = 0;
}
devc->num_stages = 0;
- for (l = sdi->probes; l; l = l->next) {
- probe = (const struct sr_channel *)l->data;
- if (!probe->enabled)
+ for (l = sdi->channels; l; l = l->next) {
+ ch = (const struct sr_channel *)l->data;
+ if (!ch->enabled)
continue;
- if (probe->index >= devc->max_probes) {
- sr_err("Channels over the limit of %d\n", devc->max_probes);
+ if (ch->index >= devc->max_channels) {
+ sr_err("Channels over the limit of %d\n", devc->max_channels);
return SR_ERR;
}
/*
- * Set up the probe mask for later configuration into the
+ * Set up the channel mask for later configuration into the
* flag register.
*/
- probe_bit = 1 << (probe->index);
- devc->probe_mask |= probe_bit;
+ channel_bit = 1 << (ch->index);
+ devc->channel_mask |= channel_bit;
- if (!probe->trigger)
+ if (!ch->trigger)
continue;
/* Configure trigger mask and value. */
stage = 0;
- for (tc = probe->trigger; tc && *tc; tc++) {
- devc->trigger_mask[stage] |= probe_bit;
+ for (tc = ch->trigger; tc && *tc; tc++) {
+ devc->trigger_mask[stage] |= channel_bit;
if (*tc == '1')
- devc->trigger_value[stage] |= probe_bit;
+ devc->trigger_value[stage] |= channel_bit;
stage++;
/* Only supporting parallel mode, with up to 4 stages. */
if (stage > 4)
/* Acquisition settings */
devc->limit_samples = devc->capture_ratio = 0;
devc->trigger_at = -1;
- devc->probe_mask = 0xffffffff;
+ devc->channel_mask = 0xffffffff;
devc->flag_reg = 0;
return devc;
{
struct sr_dev_inst *sdi;
struct dev_context *devc;
- struct sr_channel *probe;
+ struct sr_channel *ch;
uint32_t tmp_int, ui;
uint8_t key, type, token;
GString *tmp_str, *devname, *version;
key, tmp_int);
switch (token) {
case 0x00:
- /* Number of usable probes */
+ /* Number of usable channels */
for (ui = 0; ui < tmp_int; ui++) {
- if (!(probe = sr_probe_new(ui, SR_PROBE_LOGIC, TRUE,
- ols_probe_names[ui])))
+ if (!(ch = sr_probe_new(ui, SR_PROBE_LOGIC, TRUE,
+ ols_channel_names[ui])))
return 0;
- sdi->probes = g_slist_append(sdi->probes, probe);
+ sdi->channels = g_slist_append(sdi->channels, ch);
}
break;
case 0x01:
key, tmp_c);
switch (token) {
case 0x00:
- /* Number of usable probes */
+ /* Number of usable channels */
for (ui = 0; ui < tmp_c; ui++) {
- if (!(probe = sr_probe_new(ui, SR_PROBE_LOGIC, TRUE,
- ols_probe_names[ui])))
+ if (!(ch = sr_probe_new(ui, SR_PROBE_LOGIC, TRUE,
+ ols_channel_names[ui])))
return 0;
- sdi->probes = g_slist_append(sdi->probes, probe);
+ sdi->channels = g_slist_append(sdi->channels, ch);
}
break;
case 0x01:
sr_info("Enabling demux mode.");
devc->flag_reg |= FLAG_DEMUX;
devc->flag_reg &= ~FLAG_FILTER;
- devc->max_probes = NUM_PROBES / 2;
+ devc->max_channels = NUM_PROBES / 2;
devc->cur_samplerate_divider = (CLOCK_RATE * 2 / samplerate) - 1;
} else {
sr_info("Disabling demux mode.");
devc->flag_reg &= ~FLAG_DEMUX;
devc->flag_reg |= FLAG_FILTER;
- devc->max_probes = NUM_PROBES;
+ devc->max_channels = NUM_PROBES;
devc->cur_samplerate_divider = (CLOCK_RATE / samplerate) - 1;
}
* submitting it over the session bus --
* whatever is listening on the bus will be
* expecting a full 32-bit sample, based on
- * the number of probes.
+ * the number of channels.
*/
j = 0;
memset(devc->tmp_sample, 0, 4);
/* Private, per-device-instance driver context. */
struct dev_context {
/* Fixed device settings */
- int max_probes;
+ int max_channels;
uint32_t max_samples;
uint32_t max_samplerate;
uint32_t protocol_version;
uint64_t limit_samples;
int capture_ratio;
int trigger_at;
- uint32_t probe_mask;
+ uint32_t channel_mask;
uint32_t trigger_mask[4];
uint32_t trigger_value[4];
int num_stages;
};
-SR_PRIV extern const char *ols_probe_names[NUM_PROBES + 1];
+SR_PRIV extern const char *ols_channel_names[NUM_PROBES + 1];
SR_PRIV int send_shortcommand(struct sr_serial_dev_inst *serial,
uint8_t command);
SR_PRIV int send_longcommand(struct sr_serial_dev_inst *serial,
uint8_t command, uint8_t *data);
-SR_PRIV int ols_configure_probes(const struct sr_dev_inst *sdi);
+SR_PRIV int ols_configure_channels(const struct sr_dev_inst *sdi);
SR_PRIV struct dev_context *ols_dev_new(void);
SR_PRIV struct sr_dev_inst *get_metadata(struct sr_serial_dev_inst *serial);
SR_PRIV int ols_set_samplerate(const struct sr_dev_inst *sdi,
struct dev_context *devc;
struct sr_dev_inst *sdi;
struct sr_scpi_hw_info *hw_info;
- struct sr_channel *probe;
+ struct sr_channel *ch;
long n[3];
unsigned int i;
const struct rigol_ds_model *model = NULL;
for (i = 0; i < model->analog_channels; i++) {
if (!(channel_name = g_strdup_printf("CH%d", i + 1)))
return NULL;
- probe = sr_probe_new(i, SR_PROBE_ANALOG, TRUE, channel_name);
- sdi->probes = g_slist_append(sdi->probes, probe);
+ ch = sr_probe_new(i, SR_PROBE_ANALOG, TRUE, channel_name);
+ sdi->channels = g_slist_append(sdi->channels, ch);
devc->analog_groups[i].name = channel_name;
- devc->analog_groups[i].channels = g_slist_append(NULL, probe);
+ devc->analog_groups[i].channels = g_slist_append(NULL, ch);
sdi->channel_groups = g_slist_append(sdi->channel_groups,
&devc->analog_groups[i]);
}
for (i = 0; i < 16; i++) {
if (!(channel_name = g_strdup_printf("D%d", i)))
return NULL;
- probe = sr_probe_new(i, SR_PROBE_LOGIC, TRUE, channel_name);
+ ch = sr_probe_new(i, SR_PROBE_LOGIC, TRUE, channel_name);
g_free(channel_name);
- if (!probe)
+ if (!ch)
return NULL;
- sdi->probes = g_slist_append(sdi->probes, probe);
+ sdi->channels = g_slist_append(sdi->channels, ch);
devc->digital_group.channels = g_slist_append(
- devc->digital_group.channels, probe);
+ devc->digital_group.channels, ch);
}
devc->digital_group.name = "LA";
sdi->channel_groups = g_slist_append(sdi->channel_groups,
static int analog_frame_size(const struct sr_dev_inst *sdi)
{
struct dev_context *devc = sdi->priv;
- struct sr_channel *probe;
- int analog_probes = 0;
+ struct sr_channel *ch;
+ int analog_channels = 0;
GSList *l;
- for (l = sdi->probes; l; l = l->next) {
- probe = l->data;
- if (probe->type == SR_PROBE_ANALOG && probe->enabled)
- analog_probes++;
+ for (l = sdi->channels; l; l = l->next) {
+ ch = l->data;
+ if (ch->type == SR_PROBE_ANALOG && ch->enabled)
+ analog_channels++;
}
- if (analog_probes == 0)
+ if (analog_channels == 0)
return 0;
switch (devc->data_source) {
case DATA_SOURCE_LIVE:
return devc->model->series->live_samples;
case DATA_SOURCE_MEMORY:
- return devc->model->series->buffer_samples / analog_probes;
+ return devc->model->series->buffer_samples / analog_channels;
default:
return 0;
}
const struct sr_channel_group *cg)
{
struct dev_context *devc;
- struct sr_channel *probe;
+ struct sr_channel *ch;
const char *tmp_str;
uint64_t samplerate;
int analog_channel = -1;
}
if (cg) {
- probe = g_slist_nth_data(cg->channels, 0);
- if (!probe)
+ ch = g_slist_nth_data(cg->channels, 0);
+ if (!ch)
return SR_ERR;
- if (probe->type == SR_PROBE_ANALOG) {
- if (probe->name[2] < '1' || probe->name[2] > '4')
+ if (ch->type == SR_PROBE_ANALOG) {
+ if (ch->name[2] < '1' || ch->name[2] > '4')
return SR_ERR;
- analog_channel = probe->name[2] - '1';
+ analog_channel = ch->name[2] - '1';
}
}
{
struct sr_scpi_dev_inst *scpi;
struct dev_context *devc;
- struct sr_channel *probe;
+ struct sr_channel *ch;
struct sr_datafeed_packet packet;
GSList *l;
devc->num_frames = 0;
- for (l = sdi->probes; l; l = l->next) {
- probe = l->data;
- sr_dbg("handling probe %s", probe->name);
- if (probe->type == SR_PROBE_ANALOG) {
- if (probe->enabled)
- devc->enabled_analog_probes = g_slist_append(
- devc->enabled_analog_probes, probe);
- if (probe->enabled != devc->analog_channels[probe->index]) {
+ for (l = sdi->channels; l; l = l->next) {
+ ch = l->data;
+ sr_dbg("handling channel %s", ch->name);
+ if (ch->type == SR_PROBE_ANALOG) {
+ if (ch->enabled)
+ devc->enabled_analog_channels = g_slist_append(
+ devc->enabled_analog_channels, ch);
+ if (ch->enabled != devc->analog_channels[ch->index]) {
/* Enabled channel is currently disabled, or vice versa. */
- if (rigol_ds_config_set(sdi, ":CHAN%d:DISP %s", probe->index + 1,
- probe->enabled ? "ON" : "OFF") != SR_OK)
+ if (rigol_ds_config_set(sdi, ":CHAN%d:DISP %s", ch->index + 1,
+ ch->enabled ? "ON" : "OFF") != SR_OK)
return SR_ERR;
- devc->analog_channels[probe->index] = probe->enabled;
+ devc->analog_channels[ch->index] = ch->enabled;
}
- } else if (probe->type == SR_PROBE_LOGIC) {
- if (probe->enabled) {
- devc->enabled_digital_probes = g_slist_append(
- devc->enabled_digital_probes, probe);
+ } else if (ch->type == SR_PROBE_LOGIC) {
+ if (ch->enabled) {
+ devc->enabled_digital_channels = g_slist_append(
+ devc->enabled_digital_channels, ch);
/* Turn on LA module if currently off. */
if (!devc->la_enabled) {
if (rigol_ds_config_set(sdi, ":LA:DISP ON") != SR_OK)
devc->la_enabled = TRUE;
}
}
- if (probe->enabled != devc->digital_channels[probe->index]) {
+ if (ch->enabled != devc->digital_channels[ch->index]) {
/* Enabled channel is currently disabled, or vice versa. */
- if (rigol_ds_config_set(sdi, ":DIG%d:TURN %s", probe->index,
- probe->enabled ? "ON" : "OFF") != SR_OK)
+ if (rigol_ds_config_set(sdi, ":DIG%d:TURN %s", ch->index,
+ ch->enabled ? "ON" : "OFF") != SR_OK)
return SR_ERR;
- devc->digital_channels[probe->index] = probe->enabled;
+ devc->digital_channels[ch->index] = ch->enabled;
}
}
}
- if (!devc->enabled_analog_probes && !devc->enabled_digital_probes)
+ if (!devc->enabled_analog_channels && !devc->enabled_digital_channels)
return SR_ERR;
- /* Turn off LA module if on and no digital probes selected. */
- if (devc->la_enabled && !devc->enabled_digital_probes)
+ /* Turn off LA module if on and no digital channels selected. */
+ if (devc->la_enabled && !devc->enabled_digital_channels)
if (rigol_ds_config_set(sdi, ":LA:DISP OFF") != SR_OK)
return SR_ERR;
/* Send header packet to the session bus. */
std_session_send_df_header(cb_data, LOG_PREFIX);
- if (devc->enabled_analog_probes)
- devc->channel_entry = devc->enabled_analog_probes;
+ if (devc->enabled_analog_channels)
+ devc->channel_entry = devc->enabled_analog_channels;
else
- devc->channel_entry = devc->enabled_digital_probes;
+ devc->channel_entry = devc->enabled_digital_channels;
if (rigol_ds_capture_start(sdi) != SR_OK)
return SR_ERR;
packet.type = SR_DF_END;
sr_session_send(sdi, &packet);
- g_slist_free(devc->enabled_analog_probes);
- g_slist_free(devc->enabled_digital_probes);
- devc->enabled_analog_probes = NULL;
- devc->enabled_digital_probes = NULL;
+ g_slist_free(devc->enabled_analog_channels);
+ g_slist_free(devc->enabled_digital_channels);
+ devc->enabled_analog_channels = NULL;
+ devc->enabled_digital_channels = NULL;
scpi = sdi->conn;
sr_scpi_source_remove(scpi);
static int rigol_ds_check_stop(const struct sr_dev_inst *sdi)
{
struct dev_context *devc;
- struct sr_channel *probe;
+ struct sr_channel *ch;
int tmp;
if (!(devc = sdi->priv))
return SR_ERR;
- probe = devc->channel_entry->data;
+ ch = devc->channel_entry->data;
if (devc->model->series->protocol <= PROTOCOL_V2)
return SR_OK;
if (rigol_ds_config_set(sdi, ":WAV:SOUR CHAN%d",
- probe->index + 1) != SR_OK)
+ ch->index + 1) != SR_OK)
return SR_ERR;
/* Check that the number of samples will be accepted */
if (rigol_ds_config_set(sdi, ":WAV:POIN %d", devc->analog_frame_size) != SR_OK)
SR_PRIV int rigol_ds_channel_start(const struct sr_dev_inst *sdi)
{
struct dev_context *devc;
- struct sr_channel *probe;
+ struct sr_channel *ch;
if (!(devc = sdi->priv))
return SR_ERR;
- probe = devc->channel_entry->data;
+ ch = devc->channel_entry->data;
- sr_dbg("Starting reading data from channel %d", probe->index + 1);
+ sr_dbg("Starting reading data from channel %d", ch->index + 1);
if (devc->model->series->protocol <= PROTOCOL_V2) {
- if (probe->type == SR_PROBE_LOGIC) {
+ if (ch->type == SR_PROBE_LOGIC) {
if (sr_scpi_send(sdi->conn, ":WAV:DATA? DIG") != SR_OK)
return SR_ERR;
} else {
if (sr_scpi_send(sdi->conn, ":WAV:DATA? CHAN%d",
- probe->index + 1) != SR_OK)
+ ch->index + 1) != SR_OK)
return SR_ERR;
}
rigol_ds_set_wait_event(devc, WAIT_NONE);
} else {
if (rigol_ds_config_set(sdi, ":WAV:SOUR CHAN%d",
- probe->index + 1) != SR_OK)
+ ch->index + 1) != SR_OK)
return SR_ERR;
if (devc->data_source != DATA_SOURCE_LIVE) {
if (rigol_ds_config_set(sdi, ":WAV:RES") != SR_OK)
struct sr_datafeed_logic logic;
double vdiv, offset;
int len, i, vref;
- struct sr_channel *probe;
+ struct sr_channel *ch;
gsize expected_data_bytes;
(void)fd;
sr_err("BUG: Unknown event target encountered");
}
- probe = devc->channel_entry->data;
+ ch = devc->channel_entry->data;
- expected_data_bytes = probe->type == SR_PROBE_ANALOG ?
+ expected_data_bytes = ch->type == SR_PROBE_ANALOG ?
devc->analog_frame_size : devc->digital_frame_size;
if (devc->num_block_bytes == 0) {
devc->num_block_read += len;
- if (probe->type == SR_PROBE_ANALOG) {
- vref = devc->vert_reference[probe->index];
- vdiv = devc->vdiv[probe->index] / 25.6;
- offset = devc->vert_offset[probe->index];
+ if (ch->type == SR_PROBE_ANALOG) {
+ vref = devc->vert_reference[ch->index];
+ vdiv = devc->vdiv[ch->index] / 25.6;
+ offset = devc->vert_offset[ch->index];
if (devc->model->series->protocol >= PROTOCOL_V3)
for (i = 0; i < len; i++)
devc->data[i] = ((int)devc->buffer[i] - vref) * vdiv - offset;
else
for (i = 0; i < len; i++)
devc->data[i] = (128 - devc->buffer[i]) * vdiv - offset;
- analog.probes = g_slist_append(NULL, probe);
+ analog.channels = g_slist_append(NULL, ch);
analog.num_samples = len;
analog.data = devc->data;
analog.mq = SR_MQ_VOLTAGE;
packet.type = SR_DF_ANALOG;
packet.payload = &analog;
sr_session_send(cb_data, &packet);
- g_slist_free(analog.probes);
+ g_slist_free(analog.channels);
} else {
logic.length = len;
logic.unitsize = 2;
rigol_ds_config_set(sdi, ":WAV:END");
}
- if (probe->type == SR_PROBE_ANALOG
+ if (ch->type == SR_PROBE_ANALOG
&& devc->channel_entry->next != NULL) {
/* We got the frame for this analog channel, but
* there's another analog channel. */
rigol_ds_channel_start(sdi);
} else {
/* Done with all analog channels in this frame. */
- if (devc->enabled_digital_probes
- && devc->channel_entry != devc->enabled_digital_probes) {
+ if (devc->enabled_digital_channels
+ && devc->channel_entry != devc->enabled_digital_channels) {
/* Now we need to get the digital data. */
- devc->channel_entry = devc->enabled_digital_probes;
+ devc->channel_entry = devc->enabled_digital_channels;
rigol_ds_channel_start(sdi);
} else {
/* Done with this frame. */
sdi->driver->dev_acquisition_stop(sdi, cb_data);
} else {
/* Get the next frame, starting with the first analog channel. */
- if (devc->enabled_analog_probes)
- devc->channel_entry = devc->enabled_analog_probes;
+ if (devc->enabled_analog_channels)
+ devc->channel_entry = devc->enabled_analog_channels;
else
- devc->channel_entry = devc->enabled_digital_probes;
+ devc->channel_entry = devc->enabled_digital_channels;
rigol_ds_capture_start(sdi);
struct sr_channel_group digital_group;
/* Acquisition settings */
- GSList *enabled_analog_probes;
- GSList *enabled_digital_probes;
+ GSList *enabled_analog_channels;
+ GSList *enabled_digital_channels;
uint64_t limit_frames;
void *cb_data;
enum data_source data_source;
SR_CONF_CONTINUOUS,
};
-static const char *probe_names[] = {
+static const char *channel_names[] = {
"0", "1", "2", "3", "4", "5", "6", "7", "8",
"9", "10", "11", "12", "13", "14", "15",
NULL,
struct dev_context *devc;
struct sr_dev_inst *sdi;
struct sr_usb_dev_inst *usb;
- struct sr_channel *probe;
+ struct sr_channel *ch;
struct sr_config *src;
GSList *l, *devices, *conn_devices;
struct libusb_device_descriptor des;
return NULL;
sdi->driver = di;
- for (j = 0; probe_names[j]; j++) {
- if (!(probe = sr_probe_new(j, SR_PROBE_LOGIC, TRUE,
- probe_names[j])))
+ for (j = 0; channel_names[j]; j++) {
+ if (!(ch = sr_probe_new(j, SR_PROBE_LOGIC, TRUE,
+ channel_names[j])))
return NULL;
- sdi->probes = g_slist_append(sdi->probes, probe);
+ sdi->channels = g_slist_append(sdi->channels, ch);
}
if (!(devc = g_try_malloc0(sizeof(struct dev_context))))
return timeout + timeout / 4; /* Leave a headroom of 25% percent. */
}
-static int configure_probes(const struct sr_dev_inst *sdi)
+static int configure_channels(const struct sr_dev_inst *sdi)
{
struct dev_context *devc;
- struct sr_channel *probe;
+ struct sr_channel *ch;
GSList *l;
- uint16_t probe_bit;
+ uint16_t channel_bit;
devc = sdi->priv;
devc->cur_channels = 0;
devc->num_channels = 0;
- for (l = sdi->probes; l; l = l->next) {
- probe = (struct sr_channel *)l->data;
- if (probe->enabled == FALSE)
+ for (l = sdi->channels; l; l = l->next) {
+ ch = (struct sr_channel *)l->data;
+ if (ch->enabled == FALSE)
continue;
- probe_bit = 1 << (probe->index);
+ channel_bit = 1 << (ch->index);
- devc->cur_channels |= probe_bit;
+ devc->cur_channels |= channel_bit;
#ifdef WORDS_BIGENDIAN
/*
* To speed things up during conversion, do the switcharoo
* here instead.
*/
- probe_bit = 1 << (probe->index ^ 8);
+ channel_bit = 1 << (ch->index ^ 8);
#endif
- devc->channel_masks[devc->num_channels++] = probe_bit;
+ devc->channel_masks[devc->num_channels++] = channel_bit;
}
return SR_OK;
usb = sdi->conn;
/* Configures devc->cur_channels. */
- if (configure_probes(sdi) != SR_OK) {
- sr_err("Failed to configure probes.");
+ if (configure_channels(sdi) != SR_OK) {
+ sr_err("Failed to configure channels.");
return SR_ERR;
}
struct sr_dev_inst *sdi;
struct drv_context *drvc;
struct dev_context *devc;
- struct sr_channel *probe;
+ struct sr_channel *ch;
struct sr_serial_dev_inst *serial;
GSList *devices;
int dropped, ret;
sdi->priv = devc;
sdi->driver = dmms[dmm].di;
- if (!(probe = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "P1")))
+ if (!(ch = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "P1")))
goto scan_cleanup;
- sdi->probes = g_slist_append(sdi->probes, probe);
+ sdi->channels = g_slist_append(sdi->channels, ch);
drvc->instances = g_slist_append(drvc->instances, sdi);
devices = g_slist_append(devices, sdi);
memset(&analog, 0, sizeof(struct sr_datafeed_analog));
- analog.probes = sdi->probes;
+ analog.channels = sdi->channels;
analog.num_samples = 1;
analog.mq = -1;
return std_init(sr_ctx, di, LOG_PREFIX);
}
-static GSList *gen_probe_list(int num_probes)
+static GSList *gen_channel_list(int num_channels)
{
GSList *list;
- struct sr_channel *probe;
+ struct sr_channel *ch;
int i;
char name[8];
list = NULL;
- for (i = num_probes; i > 0; --i) {
- /* The LWLA series simply number probes from CH1 to CHxx. */
+ for (i = num_channels; i > 0; --i) {
+ /* The LWLA series simply number channels from CH1 to CHxx. */
g_snprintf(name, sizeof(name), "CH%d", i);
- probe = sr_probe_new(i - 1, SR_PROBE_LOGIC, TRUE, name);
- list = g_slist_prepend(list, probe);
+ ch = sr_probe_new(i - 1, SR_PROBE_LOGIC, TRUE, name);
+ list = g_slist_prepend(list, ch);
}
return list;
return NULL;
}
- /* Enable all channels to match the default probe configuration. */
+ /* Enable all channels to match the default channel configuration. */
devc->channel_mask = ALL_CHANNELS_MASK;
devc->samplerate = DEFAULT_SAMPLERATE;
sdi->priv = devc;
- sdi->probes = gen_probe_list(NUM_PROBES);
+ sdi->channels = gen_channel_list(NUM_PROBES);
return sdi;
}
}
static int config_probe_set(const struct sr_dev_inst *sdi,
- struct sr_channel *probe, unsigned int changes)
+ struct sr_channel *ch, unsigned int changes)
{
- uint64_t probe_bit;
+ uint64_t channel_bit;
uint64_t trigger_mask;
uint64_t trigger_values;
uint64_t trigger_edge_mask;
if (!devc)
return SR_ERR_DEV_CLOSED;
- if (probe->index < 0 || probe->index >= NUM_PROBES) {
- sr_err("Probe index %d out of range.", probe->index);
+ if (ch->index < 0 || ch->index >= NUM_PROBES) {
+ sr_err("Channel index %d out of range.", ch->index);
return SR_ERR_BUG;
}
- probe_bit = (uint64_t)1 << probe->index;
+ channel_bit = (uint64_t)1 << ch->index;
if ((changes & SR_PROBE_SET_ENABLED) != 0) {
- /* Enable or disable input channel for this probe. */
- if (probe->enabled)
- devc->channel_mask |= probe_bit;
+ /* Enable or disable input channel for this channel. */
+ if (ch->enabled)
+ devc->channel_mask |= channel_bit;
else
- devc->channel_mask &= ~probe_bit;
+ devc->channel_mask &= ~channel_bit;
}
if ((changes & SR_PROBE_SET_TRIGGER) != 0) {
- trigger_mask = devc->trigger_mask & ~probe_bit;
- trigger_values = devc->trigger_values & ~probe_bit;
- trigger_edge_mask = devc->trigger_edge_mask & ~probe_bit;
+ trigger_mask = devc->trigger_mask & ~channel_bit;
+ trigger_values = devc->trigger_values & ~channel_bit;
+ trigger_edge_mask = devc->trigger_edge_mask & ~channel_bit;
- if (probe->trigger && probe->trigger[0] != '\0') {
- if (probe->trigger[1] != '\0') {
+ if (ch->trigger && ch->trigger[0] != '\0') {
+ if (ch->trigger[1] != '\0') {
sr_warn("Trigger configuration \"%s\" with "
"multiple stages is not supported.",
- probe->trigger);
+ ch->trigger);
return SR_ERR_ARG;
}
- /* Enable trigger for this probe. */
- trigger_mask |= probe_bit;
+ /* Enable trigger for this channel. */
+ trigger_mask |= channel_bit;
/* Configure edge mask and trigger value. */
- switch (probe->trigger[0]) {
- case '1': trigger_values |= probe_bit;
+ switch (ch->trigger[0]) {
+ case '1': trigger_values |= channel_bit;
case '0': break;
- case 'r': trigger_values |= probe_bit;
- case 'f': trigger_edge_mask |= probe_bit;
+ case 'r': trigger_values |= channel_bit;
+ case 'f': trigger_edge_mask |= channel_bit;
break;
default:
sr_warn("Trigger type '%c' is not supported.",
- probe->trigger[0]);
+ ch->trigger[0]);
return SR_ERR_ARG;
}
}
struct dev_context *devc;
struct sr_serial_dev_inst *serial;
struct sr_dev_inst *sdi;
- struct sr_channel *probe;
+ struct sr_channel *ch;
GSList *devices = NULL, *l;
const char *conn = NULL, *serialcomm = NULL;
uint8_t buf[292];
sdi->priv = devc;
sdi->driver = di;
- if (!(probe = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "P")))
+ if (!(ch = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "P")))
goto scan_cleanup;
- sdi->probes = g_slist_append(sdi->probes, probe);
+ sdi->channels = g_slist_append(sdi->channels, ch);
if (devc->optarif == OPTARIF_BASE) {
- if (!(probe = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "BASE")))
+ if (!(ch = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "BASE")))
goto scan_cleanup;
- sdi->probes = g_slist_append(sdi->probes, probe);
+ sdi->channels = g_slist_append(sdi->channels, ch);
} else if (devc->optarif == OPTARIF_HC) {
- if (!(probe = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "HP")))
+ if (!(ch = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "HP")))
goto scan_cleanup;
- sdi->probes = g_slist_append(sdi->probes, probe);
- if (!(probe = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "HC")))
+ sdi->channels = g_slist_append(sdi->channels, ch);
+ if (!(ch = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "HC")))
goto scan_cleanup;
- sdi->probes = g_slist_append(sdi->probes, probe);
+ sdi->channels = g_slist_append(sdi->channels, ch);
} else if (devc->optarif == OPTARIF_EJP) {
- if (!(probe = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "HN")))
+ if (!(ch = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "HN")))
goto scan_cleanup;
- sdi->probes = g_slist_append(sdi->probes, probe);
- if (!(probe = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "HPM")))
+ sdi->channels = g_slist_append(sdi->channels, ch);
+ if (!(ch = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "HPM")))
goto scan_cleanup;
- sdi->probes = g_slist_append(sdi->probes, probe);
+ sdi->channels = g_slist_append(sdi->channels, ch);
} else if (devc->optarif == OPTARIF_BBR) {
- if (!(probe = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "HPJB")))
+ if (!(ch = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "HPJB")))
goto scan_cleanup;
- sdi->probes = g_slist_append(sdi->probes, probe);
- if (!(probe = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "HPJW")))
+ sdi->channels = g_slist_append(sdi->channels, ch);
+ if (!(ch = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "HPJW")))
goto scan_cleanup;
- sdi->probes = g_slist_append(sdi->probes, probe);
- if (!(probe = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "HPJR")))
+ sdi->channels = g_slist_append(sdi->channels, ch);
+ if (!(ch = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "HPJR")))
goto scan_cleanup;
- sdi->probes = g_slist_append(sdi->probes, probe);
- if (!(probe = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "HCJB")))
+ sdi->channels = g_slist_append(sdi->channels, ch);
+ if (!(ch = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "HCJB")))
goto scan_cleanup;
- sdi->probes = g_slist_append(sdi->probes, probe);
- if (!(probe = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "HCJW")))
+ sdi->channels = g_slist_append(sdi->channels, ch);
+ if (!(ch = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "HCJW")))
goto scan_cleanup;
- sdi->probes = g_slist_append(sdi->probes, probe);
- if (!(probe = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "HCJR")))
+ sdi->channels = g_slist_append(sdi->channels, ch);
+ if (!(ch = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "HCJR")))
goto scan_cleanup;
- sdi->probes = g_slist_append(sdi->probes, probe);
+ sdi->channels = g_slist_append(sdi->channels, ch);
}
- if (!(probe = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "IINST")))
+ if (!(ch = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "IINST")))
goto scan_cleanup;
- sdi->probes = g_slist_append(sdi->probes, probe);
+ sdi->channels = g_slist_append(sdi->channels, ch);
- if (!(probe = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "PAPP")))
+ if (!(ch = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "PAPP")))
goto scan_cleanup;
- sdi->probes = g_slist_append(sdi->probes, probe);
+ sdi->channels = g_slist_append(sdi->channels, ch);
drvc->instances = g_slist_append(drvc->instances, sdi);
devices = g_slist_append(devices, sdi);
return ((sum & 0x3F) + ' ') == control;
}
-static gint teleinfo_probe_compare(gconstpointer a, gconstpointer b)
+static gint teleinfo_channel_compare(gconstpointer a, gconstpointer b)
{
- const struct sr_channel *probe = a;
+ const struct sr_channel *ch = a;
const char *name = b;
- return strcmp(probe->name, name);
+ return strcmp(ch->name, name);
}
-static struct sr_channel *teleinfo_find_probe(struct sr_dev_inst *sdi,
+static struct sr_channel *teleinfo_find_channel(struct sr_dev_inst *sdi,
const char *name)
{
- GSList *elem = g_slist_find_custom(sdi->probes, name,
- teleinfo_probe_compare);
+ GSList *elem = g_slist_find_custom(sdi->channels, name,
+ teleinfo_channel_compare);
return elem ? elem->data : NULL;
}
-static void teleinfo_send_value(struct sr_dev_inst *sdi, const char *probe_name,
+static void teleinfo_send_value(struct sr_dev_inst *sdi, const char *channel_name,
float value, int mq, int unit)
{
struct dev_context *devc;
struct sr_datafeed_packet packet;
struct sr_datafeed_analog analog;
- struct sr_channel *probe;
+ struct sr_channel *ch;
devc = sdi->priv;
- probe = teleinfo_find_probe(sdi, probe_name);
+ ch = teleinfo_find_channel(sdi, channel_name);
- if (!probe || !probe->enabled)
+ if (!ch || !ch->enabled)
return;
memset(&analog, 0, sizeof(struct sr_datafeed_analog));
- analog.probes = g_slist_append(analog.probes, probe);
+ analog.channels = g_slist_append(analog.channels, ch);
analog.num_samples = 1;
analog.mq = mq;
analog.unit = unit;
packet.type = SR_DF_ANALOG;
packet.payload = &analog;
sr_session_send(devc->session_cb_data, &packet);
- g_slist_free(analog.probes);
+ g_slist_free(analog.channels);
}
static void teleinfo_handle_mesurement(struct sr_dev_inst *sdi,
struct dev_context *devc;
struct sr_dev_inst *sdi;
struct sr_config *src;
- struct sr_channel *probe;
+ struct sr_channel *ch;
GSList *devices, *l;
const char *conn, *serialcomm;
struct sr_serial_dev_inst *serial;
sdi->priv = devc;
sdi->driver = di;
- probe = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "P1");
- if (!probe) {
- sr_err("Failed to create probe.");
+ ch = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "P1");
+ if (!ch) {
+ sr_err("Failed to create channel.");
return NULL;
}
- sdi->probes = g_slist_append(sdi->probes, probe);
+ sdi->channels = g_slist_append(sdi->channels, ch);
drvc->instances = g_slist_append(drvc->instances, sdi);
devices = g_slist_append(devices, sdi);
parse_packet(devc->buf, &floatval, &analog);
/* Send a sample packet with one analog value. */
- analog.probes = sdi->probes;
+ analog.channels = sdi->channels;
analog.num_samples = 1;
analog.data = &floatval;
packet.type = SR_DF_ANALOG;
struct drv_context *drvc;
struct sr_usb_dev_inst *usb;
struct sr_config *src;
- struct sr_channel *probe;
+ struct sr_channel *ch;
const char *conn;
drvc = udmms[dmm].di->priv;
}
sdi->priv = devc;
sdi->driver = udmms[dmm].di;
- if (!(probe = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "P1")))
+ if (!(ch = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "P1")))
return NULL;
- sdi->probes = g_slist_append(sdi->probes, probe);
+ sdi->channels = g_slist_append(sdi->channels, ch);
sdi->inst_type = SR_INST_USB;
sdi->conn = usb;
udmms[dmm].dmm_details(&analog, info);
/* Send a sample packet with one analog value. */
- analog.probes = sdi->probes;
+ analog.channels = sdi->channels;
analog.num_samples = 1;
analog.data = &floatval;
packet.type = SR_DF_ANALOG;
SR_CONF_DATA_SOURCE,
};
-static char *probes[] = {
+static char *channels[] = {
"T1",
"T2",
"T1-T2",
struct drv_context *drvc;
struct dev_context *devc;
struct sr_dev_inst *sdi;
- struct sr_channel *probe;
+ struct sr_channel *ch;
struct sr_config *src;
GSList *usb_devices, *devices, *l;
int i;
sdi->inst_type = SR_INST_USB;
sdi->conn = l->data;
for (i = 0; i < 3; i++) {
- if (!(probe = sr_probe_new(i, SR_PROBE_ANALOG, TRUE,
- probes[i]))) {
- sr_dbg("Probe malloc failed.");
+ if (!(ch = sr_probe_new(i, SR_PROBE_ANALOG, TRUE,
+ channels[i]))) {
+ sr_dbg("Channel malloc failed.");
return NULL;
}
- sdi->probes = g_slist_append(sdi->probes, probe);
+ sdi->channels = g_slist_append(sdi->channels, ch);
}
if (!(devc = g_try_malloc(sizeof(struct dev_context)))) {
is_valid = TRUE;
if (devc->packet[1] == 0x3b && devc->packet[2] == 0x3b
&& devc->packet[3] == 0x3b && devc->packet[4] == 0x3b)
- /* No measurement: missing probe, empty storage location, ... */
+ /* No measurement: missing channel, empty storage location, ... */
is_valid = FALSE;
temp = parse_temperature(devc->packet + 1);
}
switch (devc->packet[13] - 0x30) {
case 0:
- /* Probe T1. */
- analog.probes = g_slist_append(NULL, g_slist_nth_data(sdi->probes, 0));
+ /* Channel T1. */
+ analog.channels = g_slist_append(NULL, g_slist_nth_data(sdi->channels, 0));
break;
case 1:
- /* Probe T2. */
- analog.probes = g_slist_append(NULL, g_slist_nth_data(sdi->probes, 1));
+ /* Channel T2. */
+ analog.channels = g_slist_append(NULL, g_slist_nth_data(sdi->channels, 1));
break;
case 2:
case 3:
- /* Probe T1-T2. */
- analog.probes = g_slist_append(NULL, g_slist_nth_data(sdi->probes, 2));
+ /* Channel T1-T2. */
+ analog.channels = g_slist_append(NULL, g_slist_nth_data(sdi->channels, 2));
analog.mqflags |= SR_MQFLAG_RELATIVE;
break;
default:
- sr_err("Unknown probe 0x%.2x.", devc->packet[13]);
+ sr_err("Unknown channel 0x%.2x.", devc->packet[13]);
is_valid = FALSE;
}
if (is_valid) {
packet.type = SR_DF_ANALOG;
packet.payload = &analog;
sr_session_send(devc->cb_data, &packet);
- g_slist_free(analog.probes);
+ g_slist_free(analog.channels);
}
}
struct drv_context *drvc;
struct dev_context *devc;
struct sr_dev_inst *sdi;
- struct sr_channel *probe;
+ struct sr_channel *ch;
struct libusb_device_descriptor des;
libusb_device **devlist;
GSList *devices;
return NULL;
sdi->priv = devc;
- if (!(probe = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "P1")))
+ if (!(ch = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "P1")))
return NULL;
- sdi->probes = g_slist_append(NULL, probe);
+ sdi->channels = g_slist_append(NULL, ch);
if (!(sdi->conn = sr_usb_dev_inst_new(libusb_get_bus_number(devlist[i]),
libusb_get_device_address(devlist[i]), NULL)))
if (is_relative)
analog.mqflags |= SR_MQFLAG_RELATIVE;
- analog.probes = sdi->probes;
+ analog.channels = sdi->channels;
analog.num_samples = 1;
analog.data = &fvalue;
packet.type = SR_DF_ANALOG;
};
/*
- * ZEROPLUS LAP-C (16032) numbers the 16 probes A0-A7 and B0-B7.
+ * ZEROPLUS LAP-C (16032) numbers the 16 channels A0-A7 and B0-B7.
* We currently ignore other untested/unsupported devices here.
*/
-static const char *probe_names[] = {
+static const char *channel_names[] = {
"A0", "A1", "A2", "A3", "A4", "A5", "A6", "A7",
"B0", "B1", "B2", "B3", "B4", "B5", "B6", "B7",
"C0", "C1", "C2", "C3", "C4", "C5", "C6", "C7",
static int dev_close(struct sr_dev_inst *sdi);
#if 0
-static int configure_probes(const struct sr_dev_inst *sdi)
+static int configure_channels(const struct sr_dev_inst *sdi)
{
struct dev_context *devc;
- const struct sr_channel *probe;
+ const struct sr_channel *ch;
const GSList *l;
- int probe_bit, stage, i;
+ int channel_bit, stage, i;
char *tc;
/* Note: sdi and sdi->priv are non-NULL, the caller checked this. */
devc = sdi->priv;
- devc->probe_mask = 0;
+ devc->channel_mask = 0;
for (i = 0; i < NUM_TRIGGER_STAGES; i++) {
devc->trigger_mask[i] = 0;
devc->trigger_value[i] = 0;
}
stage = -1;
- for (l = sdi->probes; l; l = l->next) {
- probe = (struct sr_channel *)l->data;
- if (probe->enabled == FALSE)
+ for (l = sdi->channels; l; l = l->next) {
+ ch = (struct sr_channel *)l->data;
+ if (ch->enabled == FALSE)
continue;
- probe_bit = 1 << (probe->index);
- devc->probe_mask |= probe_bit;
+ channel_bit = 1 << (ch->index);
+ devc->channel_mask |= channel_bit;
- if (probe->trigger) {
+ if (ch->trigger) {
stage = 0;
- for (tc = probe->trigger; *tc; tc++) {
- devc->trigger_mask[stage] |= probe_bit;
+ for (tc = ch->trigger; *tc; tc++) {
+ devc->trigger_mask[stage] |= channel_bit;
if (*tc == '1')
- devc->trigger_value[stage] |= probe_bit;
+ devc->trigger_value[stage] |= channel_bit;
stage++;
if (stage > NUM_TRIGGER_STAGES)
return SR_ERR;
}
#endif
-static int configure_probes(const struct sr_dev_inst *sdi)
+static int configure_channels(const struct sr_dev_inst *sdi)
{
struct dev_context *devc;
const GSList *l;
- const struct sr_channel *probe;
+ const struct sr_channel *ch;
char *tc;
int type;
/* Note: sdi and sdi->priv are non-NULL, the caller checked this. */
devc = sdi->priv;
- for (l = sdi->probes; l; l = l->next) {
- probe = (struct sr_channel *)l->data;
- if (probe->enabled == FALSE)
+ for (l = sdi->channels; l; l = l->next) {
+ ch = (struct sr_channel *)l->data;
+ if (ch->enabled == FALSE)
continue;
- if ((tc = probe->trigger)) {
+ if ((tc = ch->trigger)) {
switch (*tc) {
case '1':
type = TRIGGER_HIGH;
default:
return SR_ERR;
}
- analyzer_add_trigger(probe->index, type);
+ analyzer_add_trigger(ch->index, type);
devc->trigger = 1;
}
}
static GSList *scan(GSList *options)
{
struct sr_dev_inst *sdi;
- struct sr_channel *probe;
+ struct sr_channel *ch;
struct drv_context *drvc;
struct dev_context *devc;
const struct zp_model *prof;
devc->memory_size = MEMORY_SIZE_8K;
// memset(devc->trigger_buffer, 0, NUM_TRIGGER_STAGES);
- /* Fill in probelist according to this device's profile. */
+ /* Fill in channellist according to this device's profile. */
for (j = 0; j < devc->num_channels; j++) {
- if (!(probe = sr_probe_new(j, SR_PROBE_LOGIC, TRUE,
- probe_names[j])))
+ if (!(ch = sr_probe_new(j, SR_PROBE_LOGIC, TRUE,
+ channel_names[j])))
return NULL;
- sdi->probes = g_slist_append(sdi->probes, probe);
+ sdi->channels = g_slist_append(sdi->channels, ch);
}
devices = g_slist_append(devices, sdi);
return SR_ERR_ARG;
}
- if (configure_probes(sdi) != SR_OK) {
- sr_err("Failed to configure probes.");
+ if (configure_channels(sdi) != SR_OK) {
+ sr_err("Failed to configure channels.");
return SR_ERR;
}
int num_channels;
int memory_size;
unsigned int max_sample_depth;
- //uint8_t probe_mask;
+ //uint8_t channel_mask;
//uint8_t trigger_mask[NUM_TRIGGER_STAGES];
//uint8_t trigger_value[NUM_TRIGGER_STAGES];
// uint8_t trigger_buffer[NUM_TRIGGER_STAGES];
static int init(struct sr_input *in, const char *filename)
{
- struct sr_channel *probe;
- int num_probes, i;
+ struct sr_channel *ch;
+ int num_channels, i;
char name[SR_MAX_PROBENAME_LEN + 1];
char *param;
struct context *ctx;
return SR_ERR_MALLOC;
}
- num_probes = DEFAULT_NUM_PROBES;
+ num_channels = DEFAULT_NUM_PROBES;
ctx->samplerate = 0;
if (in->param) {
- param = g_hash_table_lookup(in->param, "numprobes");
+ param = g_hash_table_lookup(in->param, "numchannels");
if (param) {
- num_probes = strtoul(param, NULL, 10);
- if (num_probes < 1)
+ num_channels = strtoul(param, NULL, 10);
+ if (num_channels < 1)
return SR_ERR;
}
in->sdi = sr_dev_inst_new(0, SR_ST_ACTIVE, NULL, NULL, NULL);
in->internal = ctx;
- for (i = 0; i < num_probes; i++) {
+ for (i = 0; i < num_channels; i++) {
snprintf(name, SR_MAX_PROBENAME_LEN, "%d", i);
/* TODO: Check return value. */
- if (!(probe = sr_probe_new(i, SR_PROBE_LOGIC, TRUE, name)))
+ if (!(ch = sr_probe_new(i, SR_PROBE_LOGIC, TRUE, name)))
return SR_ERR;
- in->sdi->probes = g_slist_append(in->sdi->probes, probe);
+ in->sdi->channels = g_slist_append(in->sdi->channels, ch);
}
return SR_OK;
struct sr_datafeed_logic logic;
struct sr_config *src;
unsigned char buffer[CHUNKSIZE];
- int fd, size, num_probes;
+ int fd, size, num_channels;
struct context *ctx;
ctx = in->internal;
if ((fd = open(filename, O_RDONLY)) == -1)
return SR_ERR;
- num_probes = g_slist_length(in->sdi->probes);
+ num_channels = g_slist_length(in->sdi->channels);
/* Send header packet to the session bus. */
std_session_send_df_header(in->sdi, LOG_PREFIX);
/* Chop up the input file into chunks & send it to the session bus. */
packet.type = SR_DF_LOGIC;
packet.payload = &logic;
- logic.unitsize = (num_probes + 7) / 8;
+ logic.unitsize = (num_channels + 7) / 8;
logic.data = buffer;
while ((size = read(fd, buffer, CHUNKSIZE)) > 0) {
logic.length = size;
static int init(struct sr_input *in, const char *filename)
{
- struct sr_channel *probe;
- int num_probes, i;
+ struct sr_channel *ch;
+ int num_channels, i;
char name[SR_MAX_PROBENAME_LEN + 1];
char *param;
(void)filename;
- num_probes = DEFAULT_NUM_PROBES;
+ num_channels = DEFAULT_NUM_PROBES;
if (in->param) {
- param = g_hash_table_lookup(in->param, "numprobes");
+ param = g_hash_table_lookup(in->param, "numchannels");
if (param) {
- num_probes = strtoul(param, NULL, 10);
- if (num_probes < 1) {
+ num_channels = strtoul(param, NULL, 10);
+ if (num_channels < 1) {
sr_err("%s: strtoul failed", __func__);
return SR_ERR;
}
/* Create a virtual device. */
in->sdi = sr_dev_inst_new(0, SR_ST_ACTIVE, NULL, NULL, NULL);
- for (i = 0; i < num_probes; i++) {
+ for (i = 0; i < num_channels; i++) {
snprintf(name, SR_MAX_PROBENAME_LEN, "%d", i);
/* TODO: Check return value. */
- if (!(probe = sr_probe_new(i, SR_PROBE_LOGIC, TRUE, name)))
+ if (!(ch = sr_probe_new(i, SR_PROBE_LOGIC, TRUE, name)))
return SR_ERR;
- in->sdi->probes = g_slist_append(in->sdi->probes, probe);
+ in->sdi->channels = g_slist_append(in->sdi->channels, ch);
}
return SR_OK;
struct sr_datafeed_logic logic;
struct sr_config *src;
uint8_t buf[PACKET_SIZE], divcount;
- int i, fd, size, num_probes;
+ int i, fd, size, num_channels;
uint64_t samplerate;
/* TODO: Use glib functions! GIOChannel, g_fopen, etc. */
return SR_ERR;
}
- num_probes = g_slist_length(in->sdi->probes);
+ num_channels = g_slist_length(in->sdi->channels);
/* Seek to the end of the file, and read the divcount byte. */
divcount = 0x00; /* TODO: Don't hardcode! */
sr_dbg("%s: sending SR_DF_LOGIC data packets", __func__);
packet.type = SR_DF_LOGIC;
packet.payload = &logic;
- logic.unitsize = (num_probes + 7) / 8;
+ logic.unitsize = (num_channels + 7) / 8;
logic.data = buf;
/* Send 8MB of total data to the session bus in small chunks. */
* single column mode and enables single column mode. Multi
* column mode is used if this parameter is omitted.
*
- * numprobes: Specifies the number of probes to use. In multi column mode
- * the number of probes are the number of columns and in single
+ * numchannels: Specifies the number of channels to use. In multi column mode
+ * the number of channels are the number of columns and in single
* column mode the number of bits (LSB first) beginning at
- * 'first-probe'.
+ * 'first-channel'.
*
* delimiter: Specifies the delimiter for columns. Must be at least one
* character. Comma is used as default delimiter.
* samplerate: Samplerate which the sample data was captured with. Default
* value is 0.
*
- * first-probe: Column number of the first probe in multi column mode and
- * position of the bit for the first probe in single column mode.
+ * first-channel: Column number of the first channel in multi column mode and
+ * position of the bit for the first channel in single column mode.
* Default value is 0.
*
* header: Determines if the first line should be treated as header
- * and used for probe names in multi column mode. Empty header
- * names will be replaced by the probe number. If enabled in
+ * and used for channel names in multi column mode. Empty header
+ * names will be replaced by the channel number. If enabled in
* single column mode the first line will be skipped. Usage of
* header is disabled by default.
*
/* Current selected samplerate. */
uint64_t samplerate;
- /* Number of probes. */
- gsize num_probes;
+ /* Number of channels. */
+ gsize num_channels;
/* Column delimiter character(s). */
GString *delimiter;
/*
* Number of the first column to parse. Equivalent to the number of the
- * first probe in multi column mode and the single column number in
+ * first channel in multi column mode and the single column number in
* single column mode.
*/
gsize first_column;
/*
- * Column number of the first probe in multi column mode and position of
- * the bit for the first probe in single column mode.
+ * Column number of the first channel in multi column mode and position of
+ * the bit for the first channel in single column mode.
*/
- gsize first_probe;
+ gsize first_channel;
/* Line number to start processing. */
gsize start_line;
/*
* Determines if the first line should be treated as header and used for
- * probe names in multi column mode.
+ * channel names in multi column mode.
*/
gboolean header;
}
/* Clear buffer in order to set bits only. */
- memset(ctx->sample_buffer, 0, (ctx->num_probes + 7) >> 3);
+ memset(ctx->sample_buffer, 0, (ctx->num_channels + 7) >> 3);
- i = ctx->first_probe;
+ i = ctx->first_channel;
- for (j = 0; i < length && j < ctx->num_probes; i++, j++) {
+ for (j = 0; i < length && j < ctx->num_channels; i++, j++) {
if (str[length - i - 1] == '1') {
ctx->sample_buffer[j / 8] |= (1 << (j % 8));
} else if (str[length - i - 1] != '0') {
}
/* Clear buffer in order to set bits only. */
- memset(ctx->sample_buffer, 0, (ctx->num_probes + 7) >> 3);
+ memset(ctx->sample_buffer, 0, (ctx->num_channels + 7) >> 3);
/* Calculate the position of the first hexadecimal digit. */
- i = ctx->first_probe / 4;
+ i = ctx->first_channel / 4;
- for (j = 0; i < length && j < ctx->num_probes; i++) {
+ for (j = 0; i < length && j < ctx->num_channels; i++) {
c = str[length - i - 1];
if (!g_ascii_isxdigit(c)) {
value = g_ascii_xdigit_value(c);
- k = (ctx->first_probe + j) % 4;
+ k = (ctx->first_channel + j) % 4;
- for (; j < ctx->num_probes && k < 4; k++) {
+ for (; j < ctx->num_channels && k < 4; k++) {
if (value & (1 << k))
ctx->sample_buffer[j / 8] |= (1 << (j % 8));
}
/* Clear buffer in order to set bits only. */
- memset(ctx->sample_buffer, 0, (ctx->num_probes + 7) >> 3);
+ memset(ctx->sample_buffer, 0, (ctx->num_channels + 7) >> 3);
/* Calculate the position of the first octal digit. */
- i = ctx->first_probe / 3;
+ i = ctx->first_channel / 3;
- for (j = 0; i < length && j < ctx->num_probes; i++) {
+ for (j = 0; i < length && j < ctx->num_channels; i++) {
c = str[length - i - 1];
if (c < '0' || c > '7') {
value = g_ascii_xdigit_value(c);
- k = (ctx->first_probe + j) % 3;
+ k = (ctx->first_channel + j) % 3;
- for (; j < ctx->num_probes && k < 3; k++) {
+ for (; j < ctx->num_channels && k < 3; k++) {
if (value & (1 << k))
ctx->sample_buffer[j / 8] |= (1 << (j % 8));
gsize i;
/* Clear buffer in order to set bits only. */
- memset(ctx->sample_buffer, 0, (ctx->num_probes + 7) >> 3);
+ memset(ctx->sample_buffer, 0, (ctx->num_channels + 7) >> 3);
- for (i = 0; i < ctx->num_probes; i++) {
+ for (i = 0; i < ctx->num_channels; i++) {
if (columns[i][0] == '1') {
ctx->sample_buffer[i / 8] |= (1 << (i % 8));
} else if (!strlen(columns[i])) {
sr_err("Column %zu in line %zu is empty.",
- ctx->first_probe + i, ctx->line_number);
+ ctx->first_channel + i, ctx->line_number);
return SR_ERR;
} else if (columns[i][0] != '0') {
sr_err("Invalid value '%s' in column %zu in line %zu.",
- columns[i], ctx->first_probe + i,
+ columns[i], ctx->first_channel + i,
ctx->line_number);
return SR_ERR;
}
const char *param;
GIOStatus status;
gsize i, term_pos;
- char probe_name[SR_MAX_PROBENAME_LEN + 1];
- struct sr_channel *probe;
+ char channel_name[SR_MAX_PROBENAME_LEN + 1];
+ struct sr_channel *ch;
char **columns;
gsize num_columns;
char *ptr;
ctx->samplerate = 0;
/*
- * Enable auto-detection of the number of probes in multi column mode
- * and enforce the specification of the number of probes in single
+ * Enable auto-detection of the number of channels in multi column mode
+ * and enforce the specification of the number of channels in single
* column mode.
*/
- ctx->num_probes = 0;
+ ctx->num_channels = 0;
/* Set default delimiter. */
if (!(ctx->delimiter = g_string_new(","))) {
* In multi column mode start parsing sample data at the first column
* and in single column mode at the first bit.
*/
- ctx->first_probe = 0;
+ ctx->first_channel = 0;
/* Start at the beginning of the file. */
ctx->start_line = 1;
}
}
- if ((param = g_hash_table_lookup(in->param, "numprobes")))
- ctx->num_probes = g_ascii_strtoull(param, NULL, 10);
+ if ((param = g_hash_table_lookup(in->param, "numchannels")))
+ ctx->num_channels = g_ascii_strtoull(param, NULL, 10);
if ((param = g_hash_table_lookup(in->param, "delimiter"))) {
if (!strlen(param)) {
}
}
- if ((param = g_hash_table_lookup(in->param, "first-probe")))
- ctx->first_probe = g_ascii_strtoull(param, NULL, 10);
+ if ((param = g_hash_table_lookup(in->param, "first-channel")))
+ ctx->first_channel = g_ascii_strtoull(param, NULL, 10);
if ((param = g_hash_table_lookup(in->param, "startline"))) {
ctx->start_line = g_ascii_strtoull(param, NULL, 10);
}
if (ctx->multi_column_mode)
- ctx->first_column = ctx->first_probe;
+ ctx->first_column = ctx->first_channel;
else
ctx->first_column = ctx->single_column;
- if (!ctx->multi_column_mode && !ctx->num_probes) {
- sr_err("Number of probes needs to be specified in single column mode.");
+ if (!ctx->multi_column_mode && !ctx->num_channels) {
+ sr_err("Number of channels needs to be specified in single column mode.");
free_context(ctx);
return SR_ERR;
}
if (ctx->multi_column_mode) {
/*
- * Detect the number of probes in multi column mode
+ * Detect the number of channels in multi column mode
* automatically if not specified.
*/
- if (!ctx->num_probes) {
- ctx->num_probes = num_columns;
- sr_info("Number of auto-detected probes: %zu.",
- ctx->num_probes);
+ if (!ctx->num_channels) {
+ ctx->num_channels = num_columns;
+ sr_info("Number of auto-detected channels: %zu.",
+ ctx->num_channels);
}
/*
- * Ensure that the number of probes does not exceed the number
+ * Ensure that the number of channels does not exceed the number
* of columns in multi column mode.
*/
- if (num_columns < ctx->num_probes) {
- sr_err("Not enough columns for desired number of probes in line %zu.",
+ if (num_columns < ctx->num_channels) {
+ sr_err("Not enough columns for desired number of channels in line %zu.",
ctx->line_number);
g_strfreev(columns);
free_context(ctx);
}
}
- for (i = 0; i < ctx->num_probes; i++) {
+ for (i = 0; i < ctx->num_channels; i++) {
if (ctx->header && ctx->multi_column_mode && strlen(columns[i]))
- snprintf(probe_name, sizeof(probe_name), "%s",
+ snprintf(channel_name, sizeof(channel_name), "%s",
columns[i]);
else
- snprintf(probe_name, sizeof(probe_name), "%zu", i);
+ snprintf(channel_name, sizeof(channel_name), "%zu", i);
- probe = sr_probe_new(i, SR_PROBE_LOGIC, TRUE, probe_name);
+ ch = sr_probe_new(i, SR_PROBE_LOGIC, TRUE, channel_name);
- if (!probe) {
- sr_err("Probe creation failed.");
+ if (!ch) {
+ sr_err("Channel creation failed.");
free_context(ctx);
g_strfreev(columns);
return SR_ERR;
}
- in->sdi->probes = g_slist_append(in->sdi->probes, probe);
+ in->sdi->channels = g_slist_append(in->sdi->channels, ch);
}
g_strfreev(columns);
/*
* Calculate the minimum buffer size to store the sample data of the
- * probes.
+ * channels.
*/
- ctx->sample_buffer_size = (ctx->num_probes + 7) >> 3;
+ ctx->sample_buffer_size = (ctx->num_channels + 7) >> 3;
if (!(ctx->sample_buffer = g_try_malloc(ctx->sample_buffer_size))) {
sr_err("Sample buffer malloc failed.");
/* Limit the number of columns to parse. */
if (ctx->multi_column_mode)
- max_columns = ctx->num_probes;
+ max_columns = ctx->num_channels;
else
max_columns = 1;
}
/*
- * Ensure that the number of probes does not exceed the number
+ * Ensure that the number of channels does not exceed the number
* of columns in multi column mode.
*/
- if (ctx->multi_column_mode && num_columns < ctx->num_probes) {
- sr_err("Not enough columns for desired number of probes in line %zu.",
+ if (ctx->multi_column_mode && num_columns < ctx->num_channels) {
+ sr_err("Not enough columns for desired number of channels in line %zu.",
ctx->line_number);
g_strfreev(columns);
free_context(ctx);
/* The VCD input module has the following options:
*
- * numprobes: Maximum number of probes to use. The probes are
+ * numchannels: Maximum number of channels to use. The channels are
* detected in the same order as they are listed
* in the $var sections of the VCD file.
*
* - analog, integer and real number variables
* - $dumpvars initial value declaration
* - $scope namespaces
- * - more than 64 probes
+ * - more than 64 channels
*/
#include <stdlib.h>
struct context {
uint64_t samplerate;
- int maxprobes;
- int probecount;
+ int maxchannels;
+ int channelcount;
int downsample;
unsigned compress;
int64_t skip;
- GSList *probes;
+ GSList *channels;
};
-struct probe {
+struct vcd_channel {
gchar *name;
gchar *identifier;
};
return status;
}
-static void free_probe(void *data)
+static void free_channel(void *data)
{
- struct probe *probe = data;
- g_free(probe->name);
- g_free(probe->identifier);
- g_free(probe);
+ struct vcd_channel *vcd_ch = data;
+ g_free(vcd_ch->name);
+ g_free(vcd_ch->identifier);
+ g_free(vcd_ch);
}
static void release_context(struct context *ctx)
{
- g_slist_free_full(ctx->probes, free_probe);
+ g_slist_free_full(ctx->channels, free_channel);
g_free(ctx);
}
uint64_t p, q;
gchar *name = NULL, *contents = NULL;
gboolean status = FALSE;
- struct probe *probe;
+ struct vcd_channel *vcd_ch;
while (parse_section(file, &name, &contents)) {
sr_dbg("Section '%s', contents '%s'.", name, contents);
sr_info("Unsupported signal type: '%s'", parts[0]);
else if (strtol(parts[1], NULL, 10) != 1)
sr_info("Unsupported signal size: '%s'", parts[1]);
- else if (ctx->probecount >= ctx->maxprobes)
- sr_warn("Skipping '%s' because only %d probes requested.", parts[3], ctx->maxprobes);
+ else if (ctx->channelcount >= ctx->maxchannels)
+ sr_warn("Skipping '%s' because only %d channels requested.", parts[3], ctx->maxchannels);
else {
- sr_info("Probe %d is '%s' identified by '%s'.", ctx->probecount, parts[3], parts[2]);
- probe = g_malloc(sizeof(struct probe));
- probe->identifier = g_strdup(parts[2]);
- probe->name = g_strdup(parts[3]);
- ctx->probes = g_slist_append(ctx->probes, probe);
- ctx->probecount++;
+ sr_info("Channel %d is '%s' identified by '%s'.", ctx->channelcount, parts[3], parts[2]);
+ vcd_ch = g_malloc(sizeof(struct vcd_channel));
+ vcd_ch->identifier = g_strdup(parts[2]);
+ vcd_ch->name = g_strdup(parts[3]);
+ ctx->channels = g_slist_append(ctx->channels, vcd_ch);
+ ctx->channelcount++;
}
g_strfreev(parts);
static int init(struct sr_input *in, const char *filename)
{
- struct sr_channel *probe;
- int num_probes, i;
+ struct sr_channel *ch;
+ int num_channels, i;
char name[SR_MAX_PROBENAME_LEN + 1];
char *param;
struct context *ctx;
return SR_ERR_MALLOC;
}
- num_probes = DEFAULT_NUM_PROBES;
+ num_channels = DEFAULT_NUM_PROBES;
ctx->samplerate = 0;
ctx->downsample = 1;
ctx->skip = -1;
if (in->param) {
- param = g_hash_table_lookup(in->param, "numprobes");
+ param = g_hash_table_lookup(in->param, "numchannels");
if (param) {
- num_probes = strtoul(param, NULL, 10);
- if (num_probes < 1) {
+ num_channels = strtoul(param, NULL, 10);
+ if (num_channels < 1) {
release_context(ctx);
return SR_ERR;
- } else if (num_probes > 64) {
- sr_err("No more than 64 probes supported.");
+ } else if (num_channels > 64) {
+ sr_err("No more than 64 channels supported.");
return SR_ERR;
}
}
ctx->skip = strtoul(param, NULL, 10) / ctx->downsample;
}
- /* Maximum number of probes to parse from the VCD */
- ctx->maxprobes = num_probes;
+ /* Maximum number of channels to parse from the VCD */
+ ctx->maxchannels = num_channels;
/* Create a virtual device. */
in->sdi = sr_dev_inst_new(0, SR_ST_ACTIVE, NULL, NULL, NULL);
in->internal = ctx;
- for (i = 0; i < num_probes; i++) {
+ for (i = 0; i < num_channels; i++) {
snprintf(name, SR_MAX_PROBENAME_LEN, "%d", i);
- if (!(probe = sr_probe_new(i, SR_PROBE_LOGIC, TRUE, name))) {
+ if (!(ch = sr_probe_new(i, SR_PROBE_LOGIC, TRUE, name))) {
release_context(ctx);
return SR_ERR;
}
- in->sdi->probes = g_slist_append(in->sdi->probes, probe);
+ in->sdi->channels = g_slist_append(in->sdi->channels, ch);
}
return SR_OK;
/* A new 1-bit sample value */
int i, bit;
GSList *l;
- struct probe *probe;
+ struct vcd_channel *vcd_ch;
bit = (token->str[0] == '1');
read_until(file, token, 'W');
}
- for (i = 0, l = ctx->probes; i < ctx->probecount && l; i++, l = l->next) {
- probe = l->data;
+ for (i = 0, l = ctx->channels; i < ctx->channelcount && l; i++, l = l->next) {
+ vcd_ch = l->data;
- if (g_strcmp0(token->str, probe->identifier) == 0) {
- /* Found our probe */
+ if (g_strcmp0(token->str, vcd_ch->identifier) == 0) {
+ /* Found our channel */
if (bit)
prev_values |= (uint64_t)1 << i;
else
}
}
- if (i == ctx->probecount)
- sr_dbg("Did not find probe for identifier '%s'.", token->str);
+ if (i == ctx->channelcount)
+ sr_dbg("Did not find channel for identifier '%s'.", token->str);
} else {
sr_warn("Skipping unknown token '%s'.", token->str);
}
static int init(struct sr_input *in, const char *filename)
{
- struct sr_channel *probe;
+ struct sr_channel *ch;
struct context *ctx;
- char buf[40], probename[8];
+ char buf[40], channelname[8];
int i;
if (get_wav_header(filename, buf) != SR_OK)
}
for (i = 0; i < ctx->num_channels; i++) {
- snprintf(probename, 8, "CH%d", i + 1);
- if (!(probe = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, probename)))
+ snprintf(channelname, 8, "CH%d", i + 1);
+ if (!(ch = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, channelname)))
return SR_ERR;
- in->sdi->probes = g_slist_append(in->sdi->probes, probe);
+ in->sdi->channels = g_slist_append(in->sdi->channels, ch);
}
return SR_OK;
}
packet.type = SR_DF_ANALOG;
packet.payload = &analog;
- analog.probes = in->sdi->probes;
+ analog.channels = in->sdi->channels;
analog.num_samples = chunk_samples;
analog.mq = 0;
analog.unit = 0;
/** Analog datafeed payload for type SR_DF_ANALOG. */
struct sr_datafeed_analog {
- /** The probes for which data is included in this packet. */
- GSList *probes;
+ /** The channels for which data is included in this packet. */
+ GSList *channels;
/** Number of samples in data */
int num_samples;
/** Measured quantity (voltage, current, temperature, and so on).
/** Bitmap with extra information about the MQ. Use SR_MQFLAG_AC, ... */
uint64_t mqflags;
/** The analog value(s). The data is interleaved according to
- * the probes list. */
+ * the channels list. */
float *data;
};
/**
* The device for which this output module is creating output. This
- * can be used by the module to find out probe names and numbers.
+ * can be used by the module to find out channel names and numbers.
*/
struct sr_dev_inst *sdi;
char *model;
/** Device version. */
char *version;
- /** List of probes. */
- GSList *probes;
+ /** List of channels. */
+ GSList *channels;
/** List of sr_channel_group structs */
GSList *channel_groups;
/** Device instance connection data (used?) */
/** Probe status change.
* @see sr_dev_probe_enable(), sr_dev_trigger_set(). */
int (*config_probe_set) (const struct sr_dev_inst *sdi,
- struct sr_channel *probe, unsigned int changes);
+ struct sr_channel *ch, unsigned int changes);
/** Apply configuration settings to the device hardware.
* @see sr_config_commit().*/
int (*config_commit) (const struct sr_dev_inst *sdi);
#define LOG_PREFIX "output/analog"
struct context {
- int num_enabled_probes;
- GPtrArray *probelist;
+ int num_enabled_channels;
+ GPtrArray *channellist;
};
static int init(struct sr_output *o)
{
struct context *ctx;
- struct sr_channel *probe;
+ struct sr_channel *ch;
GSList *l;
sr_spew("Initializing output module.");
}
o->internal = ctx;
- /* Get the number of probes and their names. */
- ctx->probelist = g_ptr_array_new();
- for (l = o->sdi->probes; l; l = l->next) {
- probe = l->data;
- if (!probe || !probe->enabled)
+ /* Get the number of channels and their names. */
+ ctx->channellist = g_ptr_array_new();
+ for (l = o->sdi->channels; l; l = l->next) {
+ ch = l->data;
+ if (!ch || !ch->enabled)
continue;
- g_ptr_array_add(ctx->probelist, probe->name);
- ctx->num_enabled_probes++;
+ g_ptr_array_add(ctx->channellist, ch->name);
+ ctx->num_enabled_channels++;
}
return SR_OK;
const struct sr_datafeed_packet *packet, GString **out)
{
const struct sr_datafeed_analog *analog;
- struct sr_channel *probe;
+ struct sr_channel *ch;
GSList *l;
const float *fdata;
int i, p;
fdata = (const float *)analog->data;
*out = g_string_sized_new(512);
for (i = 0; i < analog->num_samples; i++) {
- for (l = analog->probes, p = 0; l; l = l->next, p++) {
- probe = l->data;
- g_string_append_printf(*out, "%s: ", probe->name);
+ for (l = analog->channels, p = 0; l; l = l->next, p++) {
+ ch = l->data;
+ g_string_append_printf(*out, "%s: ", ch->name);
fancyprint(analog->unit, analog->mqflags,
fdata[i + p], *out);
}
return SR_ERR_ARG;
ctx = o->internal;
- g_ptr_array_free(ctx->probelist, 1);
+ g_ptr_array_free(ctx->channellist, 1);
g_free(ctx);
o->internal = NULL;
#define LOG_PREFIX "output/chronovu-la8"
struct context {
- unsigned int num_enabled_probes;
+ unsigned int num_enabled_channels;
unsigned int unitsize;
uint64_t trigger_point;
uint64_t samplerate;
static int init(struct sr_output *o)
{
struct context *ctx;
- struct sr_channel *probe;
+ struct sr_channel *ch;
GSList *l;
GVariant *gvar;
o->internal = ctx;
/* Get the unitsize. */
- for (l = o->sdi->probes; l; l = l->next) {
- probe = l->data;
- if (probe->type != SR_PROBE_LOGIC)
+ for (l = o->sdi->channels; l; l = l->next) {
+ ch = l->data;
+ if (ch->type != SR_PROBE_LOGIC)
continue;
- if (!probe->enabled)
+ if (!ch->enabled)
continue;
- ctx->num_enabled_probes++;
+ ctx->num_enabled_channels++;
}
- ctx->unitsize = (ctx->num_enabled_probes + 7) / 8;
+ ctx->unitsize = (ctx->num_enabled_channels + 7) / 8;
if (sr_config_get(o->sdi->driver, o->sdi, NULL, SR_CONF_SAMPLERATE,
&gvar) == SR_OK) {
#define LOG_PREFIX "output/csv"
struct context {
- unsigned int num_enabled_probes;
+ unsigned int num_enabled_channels;
unsigned int unitsize;
uint64_t samplerate;
GString *header;
* - Option to (not) print samplenumber / time as extra column.
* - Option to "compress" output (only print changed samples, VCD-like).
* - Option to print comma-separated bits, or whole bytes/words (for 8/16
- * probe LAs) as ASCII/hex etc. etc.
+ * channel LAs) as ASCII/hex etc. etc.
* - Trigger support.
*/
static int init(struct sr_output *o)
{
struct context *ctx;
- struct sr_channel *probe;
+ struct sr_channel *ch;
GSList *l;
GVariant *gvar;
- int num_probes;
+ int num_channels;
time_t t;
if (!o)
ctx = g_try_malloc0(sizeof(struct context));
o->internal = ctx;
- /* Get the number of probes, and the unitsize. */
- for (l = o->sdi->probes; l; l = l->next) {
- probe = l->data;
- if (probe->type != SR_PROBE_LOGIC)
+ /* Get the number of channels, and the unitsize. */
+ for (l = o->sdi->channels; l; l = l->next) {
+ ch = l->data;
+ if (ch->type != SR_PROBE_LOGIC)
continue;
- if (!probe->enabled)
+ if (!ch->enabled)
continue;
- ctx->num_enabled_probes++;
+ ctx->num_enabled_channels++;
}
- ctx->unitsize = (ctx->num_enabled_probes + 7) / 8;
+ ctx->unitsize = (ctx->num_enabled_channels + 7) / 8;
- num_probes = g_slist_length(o->sdi->probes);
+ num_channels = g_slist_length(o->sdi->channels);
if (sr_config_get(o->sdi->driver, o->sdi, NULL, SR_CONF_SAMPLERATE,
&gvar) == SR_OK) {
/* Columns / channels */
g_string_append_printf(ctx->header, "; Channels (%d/%d):",
- ctx->num_enabled_probes, num_probes);
- for (l = o->sdi->probes; l; l = l->next) {
- probe = l->data;
- if (probe->type != SR_PROBE_LOGIC)
+ ctx->num_enabled_channels, num_channels);
+ for (l = o->sdi->channels; l; l = l->next) {
+ ch = l->data;
+ if (ch->type != SR_PROBE_LOGIC)
continue;
- if (!probe->enabled)
+ if (!ch->enabled)
continue;
- g_string_append_printf(ctx->header, " %s,", probe->name);
+ g_string_append_printf(ctx->header, " %s,", ch->name);
}
- if (o->sdi->probes)
+ if (o->sdi->channels)
/* Drop last separator. */
g_string_truncate(ctx->header, ctx->header->len - 1);
g_string_append_printf(ctx->header, "\n");
}
for (i = 0; i <= logic->length - ctx->unitsize; i += ctx->unitsize) {
- for (j = 0; j < ctx->num_enabled_probes; j++) {
+ for (j = 0; j < ctx->num_enabled_channels; j++) {
p = logic->data + i + j / 8;
c = *p & (1 << (j % 8));
g_string_append_c(*out, c ? '1' : '0');
#define LOG_PREFIX "output/gnuplot"
struct context {
- unsigned int num_enabled_probes;
+ unsigned int num_enabled_channels;
unsigned int unitsize;
char *header;
uint8_t *old_sample;
# Generated by: %s on %s%s\
# Period: %s\n\
#\n\
-# Column\tProbe\n\
+# Column\tChannel\n\
# -------------------------------------\
----------------------------------------\n\
# 0\t\tSample counter (for internal gnuplot purposes)\n%s\n";
static const char *gnuplot_header_comment = "\
-# Comment: Acquisition with %d/%d probes at %s\n";
+# Comment: Acquisition with %d/%d channels at %s\n";
static int init(struct sr_output *o)
{
struct context *ctx;
- struct sr_channel *probe;
+ struct sr_channel *ch;
GSList *l;
GVariant *gvar;
uint64_t samplerate;
unsigned int i;
- int num_probes;
+ int num_channels;
char *c, *frequency_s;
char wbuf[1000], comment[128];
time_t t;
}
o->internal = ctx;
- ctx->num_enabled_probes = 0;
- for (l = o->sdi->probes; l; l = l->next) {
- probe = l->data;
- if (probe->type != SR_PROBE_LOGIC)
+ ctx->num_enabled_channels = 0;
+ for (l = o->sdi->channels; l; l = l->next) {
+ ch = l->data;
+ if (ch->type != SR_PROBE_LOGIC)
continue;
- if (!probe->enabled)
+ if (!ch->enabled)
continue;
- ctx->num_enabled_probes++;
+ ctx->num_enabled_channels++;
}
- if (ctx->num_enabled_probes <= 0) {
- sr_err("%s: no logic probe enabled", __func__);
+ if (ctx->num_enabled_channels <= 0) {
+ sr_err("%s: no logic channel enabled", __func__);
return SR_ERR;
}
- ctx->unitsize = (ctx->num_enabled_probes + 7) / 8;
+ ctx->unitsize = (ctx->num_enabled_channels + 7) / 8;
- num_probes = g_slist_length(o->sdi->probes);
+ num_channels = g_slist_length(o->sdi->channels);
comment[0] = '\0';
samplerate = 0;
if (sr_config_get(o->sdi->driver, o->sdi, NULL, SR_CONF_SAMPLERATE,
return SR_ERR;
}
snprintf(comment, 127, gnuplot_header_comment,
- ctx->num_enabled_probes, num_probes, frequency_s);
+ ctx->num_enabled_channels, num_channels, frequency_s);
g_free(frequency_s);
}
/* Columns / channels */
wbuf[0] = '\0';
- for (i = 0, l = o->sdi->probes; l; l = l->next, i++) {
- probe = l->data;
- if (probe->type != SR_PROBE_LOGIC)
+ for (i = 0, l = o->sdi->channels; l; l = l->next, i++) {
+ ch = l->data;
+ if (ch->type != SR_PROBE_LOGIC)
continue;
- if (!probe->enabled)
+ if (!ch->enabled)
continue;
c = (char *)&wbuf + strlen((const char *)&wbuf);
- sprintf(c, "# %d\t\t%s\n", i + 1, probe->name);
+ sprintf(c, "# %d\t\t%s\n", i + 1, ch->name);
}
if (!(frequency_s = sr_period_string(samplerate))) {
}
ctx = o->internal;
- max_linelen = 16 + ctx->num_enabled_probes * 2;
+ max_linelen = 16 + ctx->num_enabled_channels * 2;
outsize = length_in / ctx->unitsize * max_linelen;
if (ctx->header)
outsize += strlen(ctx->header);
sprintf((char *)c, "%" PRIu64 "\t", samplecount++);
/* The next columns are the values of all channels. */
- for (p = 0; p < ctx->num_enabled_probes; p++) {
+ for (p = 0; p < ctx->num_enabled_channels; p++) {
curbit = (sample[p / 8] & ((uint8_t) (1 << (p % 8)))) >> (p % 8);
c = outbuf + strlen((const char *)outbuf);
sprintf((char *)c, "%d ", curbit);
static GString *gen_header(const struct sr_dev_inst *sdi, struct context *ctx)
{
- struct sr_channel *probe;
+ struct sr_channel *ch;
GSList *l;
GString *s;
GVariant *gvar;
- int num_enabled_probes;
+ int num_enabled_channels;
if (!ctx->samplerate && sr_config_get(sdi->driver, sdi, NULL,
SR_CONF_SAMPLERATE, &gvar) == SR_OK) {
g_variant_unref(gvar);
}
- num_enabled_probes = 0;
- for (l = sdi->probes; l; l = l->next) {
- probe = l->data;
- if (probe->type != SR_PROBE_LOGIC)
+ num_enabled_channels = 0;
+ for (l = sdi->channels; l; l = l->next) {
+ ch = l->data;
+ if (ch->type != SR_PROBE_LOGIC)
continue;
- if (!probe->enabled)
+ if (!ch->enabled)
continue;
- num_enabled_probes++;
+ num_enabled_channels++;
}
s = g_string_sized_new(512);
g_string_append_printf(s, ";Rate: %"PRIu64"\n", ctx->samplerate);
- g_string_append_printf(s, ";Channels: %d\n", num_enabled_probes);
+ g_string_append_printf(s, ";Channels: %d\n", num_enabled_channels);
g_string_append_printf(s, ";EnabledChannels: -1\n");
g_string_append_printf(s, ";Compressed: true\n");
g_string_append_printf(s, ";CursorEnabled: false\n");
* extra output, e.g. trigger.
*/
outsize = 512 + (1 + (length_in / ctx->unitsize) / ctx->samples_per_line)
- * (ctx->num_enabled_probes * max_linelen);
+ * (ctx->num_enabled_channels * max_linelen);
if (!(outbuf = g_try_malloc0(outsize + 1))) {
sr_err("%s: outbuf malloc failed", __func__);
offset += ctx->unitsize) {
sample = data_in + offset;
- char tmpval[ctx->num_enabled_probes];
+ char tmpval[ctx->num_enabled_channels];
- for (p = 0; p < ctx->num_enabled_probes; p++) {
+ for (p = 0; p < ctx->num_enabled_channels; p++) {
uint8_t curbit = (sample[p / 8] & ((uint8_t) 1 << (p % 8)));
uint8_t prevbit = (ctx->prevsample[p / 8] &
((uint8_t) 1 << (p % 8)));
ctx->mark_trigger = -1;
}
- for (p = 0; p < ctx->num_enabled_probes; p++) {
+ for (p = 0; p < ctx->num_enabled_channels; p++) {
ctx->linebuf[p * ctx->linebuf_len +
ctx->line_offset] = tmpval[p];
}
* extra output, e.g. trigger.
*/
outsize = 512 + (1 + (length_in / ctx->unitsize) / ctx->samples_per_line)
- * (ctx->num_enabled_probes * max_linelen);
+ * (ctx->num_enabled_channels * max_linelen);
if (!(outbuf = g_try_malloc0(outsize + 1))) {
sr_err("%s: outbuf malloc failed", __func__);
for (offset = 0; offset <= length_in - ctx->unitsize;
offset += ctx->unitsize) {
sample = data_in + offset;
- for (p = 0; p < ctx->num_enabled_probes; p++) {
+ for (p = 0; p < ctx->num_enabled_channels; p++) {
c = (sample[p / 8] & ((uint8_t) 1 << (p % 8))) ? '1' : '0';
ctx->linebuf[p * ctx->linebuf_len +
ctx->line_offset] = c;
/* Add a space every 8th bit. */
if ((ctx->spl_cnt & 7) == 0) {
- for (p = 0; p < ctx->num_enabled_probes; p++)
+ for (p = 0; p < ctx->num_enabled_channels; p++)
ctx->linebuf[p * ctx->linebuf_len +
ctx->line_offset] = ' ';
ctx->line_offset++;
ctx = o->internal;
max_linelen = SR_MAX_PROBENAME_LEN + 3 + ctx->samples_per_line
+ ctx->samples_per_line / 2;
- outsize = length_in / ctx->unitsize * ctx->num_enabled_probes
+ outsize = length_in / ctx->unitsize * ctx->num_enabled_channels
/ ctx->samples_per_line * max_linelen + 512;
if (!(outbuf = g_try_malloc0(outsize + 1))) {
for (offset = 0; offset <= length_in - ctx->unitsize;
offset += ctx->unitsize) {
sample = data_in + offset;
- for (p = 0; p < ctx->num_enabled_probes; p++) {
+ for (p = 0; p < ctx->num_enabled_channels; p++) {
ctx->linevalues[p] <<= 1;
if (sample[p / 8] & ((uint8_t) 1 << (p % 8)))
ctx->linevalues[p] |= 1;
/* Add a space after every complete hex byte. */
if ((ctx->spl_cnt & 7) == 0) {
- for (p = 0; p < ctx->num_enabled_probes; p++)
+ for (p = 0; p < ctx->num_enabled_channels; p++)
ctx->linebuf[p * ctx->linebuf_len +
ctx->line_offset + 2] = ' ';
ctx->line_offset += 3;
SR_PRIV void flush_linebufs(struct context *ctx, uint8_t *outbuf)
{
- static int max_probename_len = 0;
+ static int max_channelname_len = 0;
int len, i;
GSList *l;
- char *probe_name;
+ char *channel_name;
if (ctx->linebuf[0] == 0)
return;
- if (max_probename_len == 0) {
+ if (max_channelname_len == 0) {
/* First time through... */
- for (l = ctx->probenames; l; l = l->next) {
- probe_name = l->data;
- len = strlen(probe_name);
- if (len > max_probename_len)
- max_probename_len = len;
+ for (l = ctx->channelnames; l; l = l->next) {
+ channel_name = l->data;
+ len = strlen(channel_name);
+ if (len > max_channelname_len)
+ max_channelname_len = len;
}
}
- for (i = 0, l = ctx->probenames; l; l = l->next, i++) {
- probe_name = l->data;
+ for (i = 0, l = ctx->channelnames; l; l = l->next, i++) {
+ channel_name = l->data;
sprintf((char *)outbuf + strlen((const char *)outbuf),
- "%*s:%s\n", max_probename_len,
- probe_name, ctx->linebuf + i * ctx->linebuf_len);
+ "%*s:%s\n", max_channelname_len,
+ channel_name, ctx->linebuf + i * ctx->linebuf_len);
}
/* Mark trigger with a ^ character. */
SR_PRIV int init(struct sr_output *o, int default_spl, enum outputmode mode)
{
struct context *ctx;
- struct sr_channel *probe;
+ struct sr_channel *ch;
GSList *l;
GVariant *gvar;
uint64_t samplerate;
- int num_probes, ret;
+ int num_channels, ret;
char *samplerate_s;
if (!(ctx = g_try_malloc0(sizeof(struct context)))) {
}
o->internal = ctx;
- ctx->num_enabled_probes = 0;
- ctx->probenames = NULL;
+ ctx->num_enabled_channels = 0;
+ ctx->channelnames = NULL;
- for (l = o->sdi->probes; l; l = l->next) {
- probe = l->data;
- if (probe->type != SR_PROBE_LOGIC)
+ for (l = o->sdi->channels; l; l = l->next) {
+ ch = l->data;
+ if (ch->type != SR_PROBE_LOGIC)
continue;
- if (!probe->enabled)
+ if (!ch->enabled)
continue;
- ctx->probenames = g_slist_append(ctx->probenames, probe->name);
- ctx->num_enabled_probes++;
+ ctx->channelnames = g_slist_append(ctx->channelnames, ch->name);
+ ctx->num_enabled_channels++;
}
- ctx->unitsize = (ctx->num_enabled_probes + 7) / 8;
+ ctx->unitsize = (ctx->num_enabled_channels + 7) / 8;
ctx->line_offset = 0;
ctx->spl_cnt = 0;
ctx->mark_trigger = -1;
}
snprintf(ctx->header, 511, "%s\n", PACKAGE_STRING);
- num_probes = g_slist_length(o->sdi->probes);
+ num_channels = g_slist_length(o->sdi->channels);
if (sr_config_get(o->sdi->driver, o->sdi, NULL, SR_CONF_SAMPLERATE,
&gvar) == SR_OK) {
samplerate = g_variant_get_uint64(gvar);
}
snprintf(ctx->header + strlen(ctx->header),
511 - strlen(ctx->header),
- "Acquisition with %d/%d probes at %s\n",
- ctx->num_enabled_probes, num_probes, samplerate_s);
+ "Acquisition with %d/%d channels at %s\n",
+ ctx->num_enabled_channels, num_channels, samplerate_s);
g_free(samplerate_s);
}
ctx->linebuf_len = ctx->samples_per_line * 2 + 4;
- if (!(ctx->linebuf = g_try_malloc0(num_probes * ctx->linebuf_len))) {
+ if (!(ctx->linebuf = g_try_malloc0(num_channels * ctx->linebuf_len))) {
sr_err("%s: ctx->linebuf malloc failed", __func__);
ret = SR_ERR_MALLOC;
goto err;
}
- if (!(ctx->linevalues = g_try_malloc0(num_probes))) {
+ if (!(ctx->linevalues = g_try_malloc0(num_channels))) {
sr_err("%s: ctx->linevalues malloc failed", __func__);
ret = SR_ERR_MALLOC;
}
if (mode == MODE_ASCII &&
- !(ctx->prevsample = g_try_malloc0(num_probes / 8))) {
+ !(ctx->prevsample = g_try_malloc0(num_channels / 8))) {
sr_err("%s: ctx->prevsample malloc failed", __func__);
ret = SR_ERR_MALLOC;
}
if (ctx->prevsample)
g_free(ctx->prevsample);
- g_slist_free(ctx->probenames);
+ g_slist_free(ctx->channelnames);
g_free(ctx);
*length_out = 0;
break;
case SR_DF_END:
- outsize = ctx->num_enabled_probes
+ outsize = ctx->num_enabled_channels
* (ctx->samples_per_line + 20) + 512;
if (!(outbuf = g_try_malloc0(outsize))) {
sr_err("%s: outbuf malloc failed", __func__);
};
struct context {
- unsigned int num_enabled_probes;
+ unsigned int num_enabled_channels;
int samples_per_line;
unsigned int unitsize;
int line_offset;
int linebuf_len;
- GSList *probenames;
+ GSList *channelnames;
uint8_t *linebuf;
int spl_cnt;
uint8_t *linevalues;
#define LOG_PREFIX "output/vcd"
struct context {
- int num_enabled_probes;
- GArray *probeindices;
+ int num_enabled_channels;
+ GArray *channelindices;
GString *header;
uint8_t *prevsample;
int period;
};
static const char *const vcd_header_comment =
- "$comment\n Acquisition with %d/%d probes at %s\n$end\n";
+ "$comment\n Acquisition with %d/%d channels at %s\n$end\n";
static int init(struct sr_output *o)
{
struct context *ctx;
- struct sr_channel *probe;
+ struct sr_channel *ch;
GSList *l;
GVariant *gvar;
- int num_probes, i;
+ int num_channels, i;
char *samplerate_s, *frequency_s, *timestamp;
time_t t;
}
o->internal = ctx;
- ctx->num_enabled_probes = 0;
- ctx->probeindices = g_array_new(FALSE, FALSE, sizeof(int));
+ ctx->num_enabled_channels = 0;
+ ctx->channelindices = g_array_new(FALSE, FALSE, sizeof(int));
- for (l = o->sdi->probes; l; l = l->next) {
- probe = l->data;
- if (probe->type != SR_PROBE_LOGIC)
+ for (l = o->sdi->channels; l; l = l->next) {
+ ch = l->data;
+ if (ch->type != SR_PROBE_LOGIC)
continue;
- if (!probe->enabled)
+ if (!ch->enabled)
continue;
- ctx->probeindices = g_array_append_val(
- ctx->probeindices, probe->index);
- ctx->num_enabled_probes++;
+ ctx->channelindices = g_array_append_val(
+ ctx->channelindices, ch->index);
+ ctx->num_enabled_channels++;
}
- if (ctx->num_enabled_probes > 94) {
- sr_err("VCD only supports 94 probes.");
+ if (ctx->num_enabled_channels > 94) {
+ sr_err("VCD only supports 94 channels.");
return SR_ERR;
}
- ctx->unitsize = (ctx->num_enabled_probes + 7) / 8;
+ ctx->unitsize = (ctx->num_enabled_channels + 7) / 8;
ctx->header = g_string_sized_new(512);
- num_probes = g_slist_length(o->sdi->probes);
+ num_channels = g_slist_length(o->sdi->channels);
/* timestamp */
t = time(NULL);
return SR_ERR;
}
g_string_append_printf(ctx->header, vcd_header_comment,
- ctx->num_enabled_probes, num_probes, samplerate_s);
+ ctx->num_enabled_channels, num_channels, samplerate_s);
g_free(samplerate_s);
}
g_string_append_printf(ctx->header, "$scope module %s $end\n", PACKAGE);
/* Wires / channels */
- for (i = 0, l = o->sdi->probes; l; l = l->next, i++) {
- probe = l->data;
- if (probe->type != SR_PROBE_LOGIC)
+ for (i = 0, l = o->sdi->channels; l; l = l->next, i++) {
+ ch = l->data;
+ if (ch->type != SR_PROBE_LOGIC)
continue;
- if (!probe->enabled)
+ if (!ch->enabled)
continue;
g_string_append_printf(ctx->header, "$var wire 1 %c %s $end\n",
- (char)('!' + i), probe->name);
+ (char)('!' + i), ch->name);
}
g_string_append(ctx->header, "$upscope $end\n"
sample = logic->data + i;
timestamp_written = FALSE;
- for (p = 0; p < ctx->num_enabled_probes; p++) {
- index = g_array_index(ctx->probeindices, int, p);
+ for (p = 0; p < ctx->num_enabled_channels; p++) {
+ index = g_array_index(ctx->channelindices, int, p);
curbit = ((unsigned)sample[index / 8]
>> (index % 8)) & 1;
struct zip_file *zf;
struct zip_stat zs;
struct sr_dev_inst *sdi;
- struct sr_channel *probe;
- int ret, probenum, devcnt, i, j;
- uint64_t tmp_u64, total_probes, enabled_probes, p;
+ struct sr_channel *ch;
+ int ret, channelnum, devcnt, i, j;
+ uint64_t tmp_u64, total_channels, enabled_channels, p;
char **sections, **keys, *metafile, *val;
- char probename[SR_MAX_PROBENAME_LEN + 1];
+ char channelname[SR_MAX_PROBENAME_LEN + 1];
if ((ret = sr_sessionfile_check(filename)) != SR_OK)
return ret;
if (!strncmp(sections[i], "device ", 7)) {
/* device section */
sdi = NULL;
- enabled_probes = total_probes = 0;
+ enabled_channels = total_channels = 0;
keys = g_key_file_get_keys(kf, sections[i], NULL, NULL);
for (j = 0; keys[j]; j++) {
val = g_key_file_get_string(kf, sections[i], keys[j], NULL);
sdi->driver->config_set(SR_CONF_CAPTURE_UNITSIZE,
g_variant_new_uint64(tmp_u64), sdi, NULL);
} else if (!strcmp(keys[j], "total probes")) {
- total_probes = strtoull(val, NULL, 10);
+ total_channels = strtoull(val, NULL, 10);
sdi->driver->config_set(SR_CONF_NUM_LOGIC_PROBES,
- g_variant_new_uint64(total_probes), sdi, NULL);
- for (p = 0; p < total_probes; p++) {
- snprintf(probename, SR_MAX_PROBENAME_LEN, "%" PRIu64, p);
- if (!(probe = sr_probe_new(p, SR_PROBE_LOGIC, TRUE,
- probename)))
+ g_variant_new_uint64(total_channels), sdi, NULL);
+ for (p = 0; p < total_channels; p++) {
+ snprintf(channelname, SR_MAX_PROBENAME_LEN, "%" PRIu64, p);
+ if (!(ch = sr_probe_new(p, SR_PROBE_LOGIC, TRUE,
+ channelname)))
return SR_ERR;
- sdi->probes = g_slist_append(sdi->probes, probe);
+ sdi->channels = g_slist_append(sdi->channels, ch);
}
} else if (!strncmp(keys[j], "probe", 5)) {
if (!sdi)
continue;
- enabled_probes++;
+ enabled_channels++;
tmp_u64 = strtoul(keys[j]+5, NULL, 10);
/* sr_session_save() */
sr_dev_probe_name_set(sdi, tmp_u64 - 1, val);
} else if (!strncmp(keys[j], "trigger", 7)) {
- probenum = strtoul(keys[j]+7, NULL, 10);
- sr_dev_trigger_set(sdi, probenum, val);
+ channelnum = strtoul(keys[j]+7, NULL, 10);
+ sr_dev_trigger_set(sdi, channelnum, val);
}
}
g_strfreev(keys);
- /* Disable probes not specifically listed. */
- if (total_probes)
- for (p = enabled_probes; p < total_probes; p++)
+ /* Disable channels not specifically listed. */
+ if (total_channels)
+ for (p = enabled_channels; p < total_channels; p++)
sr_dev_probe_enable(sdi, p, FALSE);
}
devcnt++;
SR_API int sr_session_save(const char *filename, const struct sr_dev_inst *sdi,
unsigned char *buf, int unitsize, int units)
{
- struct sr_channel *probe;
+ struct sr_channel *ch;
GSList *l;
GVariant *gvar;
uint64_t samplerate;
int cnt, ret;
- char **probe_names;
+ char **channel_names;
samplerate = 0;
if (sr_dev_has_option(sdi, SR_CONF_SAMPLERATE)) {
}
}
- probe_names = g_malloc0(sizeof(char *) * (g_slist_length(sdi->probes) + 1));
+ channel_names = g_malloc0(sizeof(char *) * (g_slist_length(sdi->channels) + 1));
cnt = 0;
- for (l = sdi->probes; l; l = l->next) {
- probe = l->data;
- if (probe->type != SR_PROBE_LOGIC)
+ for (l = sdi->channels; l; l = l->next) {
+ ch = l->data;
+ if (ch->type != SR_PROBE_LOGIC)
continue;
- if (probe->enabled != TRUE)
+ if (ch->enabled != TRUE)
continue;
- if (!probe->name)
+ if (!ch->name)
continue;
/* Just borrowing the ptr. */
- probe_names[cnt++] = probe->name;
+ channel_names[cnt++] = ch->name;
}
- if ((ret = sr_session_save_init(filename, samplerate, probe_names)) != SR_OK)
+ if ((ret = sr_session_save_init(filename, samplerate, channel_names)) != SR_OK)
return ret;
ret = sr_session_append(filename, buf, unitsize, units);
* @param filename The name of the filename to save the current session as.
* Must not be NULL.
* @param samplerate The samplerate to store for this session.
- * @param probes A NULL-terminated array of strings containing the names
- * of all the probes active in this session.
+ * @param channels A NULL-terminated array of strings containing the names
+ * of all the channels active in this session.
*
* @retval SR_OK Success
* @retval SR_ERR_ARG Invalid arguments
* @retval SR_ERR Other errors
*/
SR_API int sr_session_save_init(const char *filename, uint64_t samplerate,
- char **probes)
+ char **channels)
{
FILE *meta;
struct zip *zipfile;
/* metadata */
fprintf(meta, "capturefile = logic-1\n");
cnt = 0;
- for (i = 0; probes[i]; i++)
+ for (i = 0; channels[i]; i++)
cnt++;
fprintf(meta, "total probes = %d\n", cnt);
s = sr_samplerate_string(samplerate);
fprintf(meta, "samplerate = %s\n", s);
g_free(s);
- for (i = 0; probes[i]; i++)
- fprintf(meta, "probe%d = %s\n", i + 1, probes[i]);
+ for (i = 0; channels[i]; i++)
+ fprintf(meta, "probe%d = %s\n", i + 1, channels[i]);
fclose(meta);
* intended. Must not be NULL. Also, sdi->driver and
* sdi->driver->info_get must not be NULL.
* @param triggerstring The string containing the trigger specification for
- * one or more probes of this device. Entries for multiple probes are
+ * one or more channels of this device. Entries for multiple channels are
* comma-separated. Triggers are specified in the form key=value,
- * where the key is a probe number (or probe name) and the value is
+ * where the key is a channel number (or channel name) and the value is
* the requested trigger type. Valid trigger types currently
* include 'r' (rising edge), 'f' (falling edge), 'c' (any pin value
* change), '0' (low value), or '1' (high value).
*
* @return Pointer to a list of trigger types (strings), or NULL upon errors.
* The pointer list (if non-NULL) has as many entries as the
- * respective device has probes (all physically available probes,
+ * respective device has channels (all physically available channels,
* not just enabled ones). Entries of the list which don't have
* a trigger value set in 'triggerstring' are NULL, the other entries
* contain the respective trigger type which is requested for the
- * respective probe (e.g. "r", "c", and so on).
+ * respective channel (e.g. "r", "c", and so on).
*/
SR_API char **sr_parse_triggerstring(const struct sr_dev_inst *sdi,
const char *triggerstring)
{
GSList *l;
GVariant *gvar;
- struct sr_channel *probe;
- int max_probes, probenum, i;
+ struct sr_channel *ch;
+ int max_channels, channelnum, i;
char **tokens, **triggerlist, *trigger, *tc;
const char *trigger_types;
gboolean error;
- max_probes = g_slist_length(sdi->probes);
+ max_channels = g_slist_length(sdi->channels);
error = FALSE;
- if (!(triggerlist = g_try_malloc0(max_probes * sizeof(char *)))) {
+ if (!(triggerlist = g_try_malloc0(max_channels * sizeof(char *)))) {
sr_err("%s: triggerlist malloc failed", __func__);
return NULL;
}
}
trigger_types = g_variant_get_string(gvar, NULL);
- tokens = g_strsplit(triggerstring, ",", max_probes);
+ tokens = g_strsplit(triggerstring, ",", max_channels);
for (i = 0; tokens[i]; i++) {
- probenum = -1;
- for (l = sdi->probes; l; l = l->next) {
- probe = (struct sr_channel *)l->data;
- if (probe->enabled
- && !strncmp(probe->name, tokens[i],
- strlen(probe->name))) {
- probenum = probe->index;
+ channelnum = -1;
+ for (l = sdi->channels; l; l = l->next) {
+ ch = (struct sr_channel *)l->data;
+ if (ch->enabled
+ && !strncmp(ch->name, tokens[i],
+ strlen(ch->name))) {
+ channelnum = ch->index;
break;
}
}
- if (probenum < 0 || probenum >= max_probes) {
- sr_err("Invalid probe.");
+ if (channelnum < 0 || channelnum >= max_channels) {
+ sr_err("Invalid channel.");
error = TRUE;
break;
}
}
}
if (!error)
- triggerlist[probenum] = g_strdup(trigger);
+ triggerlist[channelnum] = g_strdup(trigger);
}
}
g_strfreev(tokens);
g_variant_unref(gvar);
if (error) {
- for (i = 0; i < max_probes; i++)
+ for (i = 0; i < max_channels; i++)
g_free(triggerlist[i]);
g_free(triggerlist);
triggerlist = NULL;
GArray *srtest_get_enabled_logic_probes(const struct sr_dev_inst *sdi)
{
- struct sr_channel *probe;
+ struct sr_channel *ch;
GArray *probes;
GSList *l;
projects / libsigrok.git / commitdiff