2 * This file is part of the libsigrok project.
4 * Copyright (C) 2014 abraxa (Soeren Apel) <soeren@apelpie.net>
6 * This program is free software: you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation, either version 3 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program. If not, see <http://www.gnu.org/licenses/>.
21 #include "protocol_wrappers.h"
23 #define MAX_COMMAND_SIZE 64
27 * https://www.yokogawa.com/pdf/provide/E/GW/IM/0000022842/0/IM710105-17E.pdf
30 int dlm_timebase_get(struct sr_scpi_dev_inst *scpi,
33 return sr_scpi_get_string(scpi, ":TIMEBASE:TDIV?", response);
36 int dlm_timebase_set(struct sr_scpi_dev_inst *scpi,
39 gchar cmd[MAX_COMMAND_SIZE];
40 g_snprintf(cmd, sizeof(cmd), ":TIMEBASE:TDIV %s", value);
41 return sr_scpi_send(scpi, cmd);
44 int dlm_horiz_trigger_pos_get(struct sr_scpi_dev_inst *scpi,
47 return sr_scpi_get_float(scpi, ":TRIGGER:DELAY:TIME?", response);
50 int dlm_horiz_trigger_pos_set(struct sr_scpi_dev_inst *scpi,
53 gchar cmd[MAX_COMMAND_SIZE];
54 g_snprintf(cmd, sizeof(cmd), ":TRIGGER:DELAY:TIME %s", value);
55 return sr_scpi_send(scpi, cmd);
58 int dlm_trigger_source_get(struct sr_scpi_dev_inst *scpi,
61 return sr_scpi_get_string(scpi, ":TRIGGER:ATRIGGER:SIMPLE:SOURCE?", response);
64 int dlm_trigger_source_set(struct sr_scpi_dev_inst *scpi,
67 gchar cmd[MAX_COMMAND_SIZE];
68 g_snprintf(cmd, sizeof(cmd), ":TRIGGER:ATRIGGER:SIMPLE:SOURCE %s", value);
69 return sr_scpi_send(scpi, cmd);
72 int dlm_trigger_slope_get(struct sr_scpi_dev_inst *scpi,
80 if (sr_scpi_get_string(scpi, ":TRIGGER:ATRIGGER:SIMPLE:SLOPE?", &resp) != SR_OK) {
85 if (strcmp("RISE", resp) == 0) {
86 *response = SLOPE_POSITIVE;
90 if (strcmp("FALL", resp) == 0) {
91 *response = SLOPE_NEGATIVE;
100 int dlm_trigger_slope_set(struct sr_scpi_dev_inst *scpi,
103 if (value == SLOPE_POSITIVE)
104 return sr_scpi_send(scpi, ":TRIGGER:ATRIGGER:SIMPLE:SLOPE RISE");
106 if (value == SLOPE_NEGATIVE)
107 return sr_scpi_send(scpi, ":TRIGGER:ATRIGGER:SIMPLE:SLOPE FALL");
112 int dlm_analog_chan_state_get(struct sr_scpi_dev_inst *scpi, int channel,
115 gchar cmd[MAX_COMMAND_SIZE];
116 g_snprintf(cmd, sizeof(cmd), ":CHANNEL%d:DISPLAY?", channel);
117 return sr_scpi_get_bool(scpi, cmd, response);
120 int dlm_analog_chan_state_set(struct sr_scpi_dev_inst *scpi, int channel,
121 const gboolean value)
123 gchar cmd[MAX_COMMAND_SIZE];
126 g_snprintf(cmd, sizeof(cmd), ":CHANNEL%d:DISPLAY ON", channel);
128 g_snprintf(cmd, sizeof(cmd), ":CHANNEL%d:DISPLAY OFF", channel);
130 return sr_scpi_send(scpi, cmd);
133 int dlm_analog_chan_vdiv_get(struct sr_scpi_dev_inst *scpi, int channel,
136 gchar cmd[MAX_COMMAND_SIZE];
137 g_snprintf(cmd, sizeof(cmd), ":CHANNEL%d:VDIV?", channel);
138 return sr_scpi_get_string(scpi, cmd, response);
141 int dlm_analog_chan_vdiv_set(struct sr_scpi_dev_inst *scpi, int channel,
144 gchar cmd[MAX_COMMAND_SIZE];
145 g_snprintf(cmd, sizeof(cmd), ":CHANNEL%d:VDIV %s", channel, value);
146 return sr_scpi_send(scpi, cmd);
149 int dlm_analog_chan_voffs_get(struct sr_scpi_dev_inst *scpi, int channel,
152 gchar cmd[MAX_COMMAND_SIZE];
153 g_snprintf(cmd, sizeof(cmd), ":CHANNEL%d:POSITION?", channel);
154 return sr_scpi_get_float(scpi, cmd, response);
157 int dlm_analog_chan_srate_get(struct sr_scpi_dev_inst *scpi, int channel,
160 gchar cmd[MAX_COMMAND_SIZE];
161 g_snprintf(cmd, sizeof(cmd), ":WAVEFORM:TRACE %d", channel);
163 if (sr_scpi_send(scpi, cmd) != SR_OK)
166 g_snprintf(cmd, sizeof(cmd), ":WAVEFORM:RECORD 0");
167 if (sr_scpi_send(scpi, cmd) != SR_OK)
170 return sr_scpi_get_float(scpi, ":WAVEFORM:SRATE?", response);
173 int dlm_analog_chan_coupl_get(struct sr_scpi_dev_inst *scpi, int channel,
176 gchar cmd[MAX_COMMAND_SIZE];
177 g_snprintf(cmd, sizeof(cmd), ":CHANNEL%d:COUPLING?", channel);
178 return sr_scpi_get_string(scpi, cmd, response);
181 int dlm_analog_chan_coupl_set(struct sr_scpi_dev_inst *scpi, int channel,
184 gchar cmd[MAX_COMMAND_SIZE];
185 g_snprintf(cmd, sizeof(cmd), ":CHANNEL%d:COUPLING %s", channel, value);
186 return sr_scpi_send(scpi, cmd);
189 int dlm_analog_chan_wrange_get(struct sr_scpi_dev_inst *scpi, int channel,
192 gchar cmd[MAX_COMMAND_SIZE];
195 g_snprintf(cmd, sizeof(cmd), ":WAVEFORM:TRACE %d", channel);
196 result = sr_scpi_send(scpi, cmd);
197 result &= sr_scpi_get_float(scpi, ":WAVEFORM:RANGE?", response);
201 int dlm_analog_chan_woffs_get(struct sr_scpi_dev_inst *scpi, int channel,
204 gchar cmd[MAX_COMMAND_SIZE];
207 g_snprintf(cmd, sizeof(cmd), ":WAVEFORM:TRACE %d", channel);
208 result = sr_scpi_send(scpi, cmd);
209 result &= sr_scpi_get_float(scpi, ":WAVEFORM:OFFSET?", response);
213 int dlm_digital_chan_state_get(struct sr_scpi_dev_inst *scpi, int channel,
216 gchar cmd[MAX_COMMAND_SIZE];
217 g_snprintf(cmd, sizeof(cmd), ":LOGIC:PODA:BIT%d:DISPLAY?", channel);
218 return sr_scpi_get_bool(scpi, cmd, response);
221 int dlm_digital_chan_state_set(struct sr_scpi_dev_inst *scpi, int channel,
222 const gboolean value)
224 gchar cmd[MAX_COMMAND_SIZE];
227 g_snprintf(cmd, sizeof(cmd), ":LOGIC:PODA:BIT%d:DISPLAY ON", channel);
229 g_snprintf(cmd, sizeof(cmd), ":LOGIC:PODA:BIT%d:DISPLAY OFF", channel);
231 return sr_scpi_send(scpi, cmd);
234 int dlm_digital_pod_state_get(struct sr_scpi_dev_inst *scpi, int pod,
237 gchar cmd[MAX_COMMAND_SIZE];
239 /* TODO: pod currently ignored as DLM2000 only has pod A. */
242 g_snprintf(cmd, sizeof(cmd), ":LOGIC:MODE?");
243 return sr_scpi_get_bool(scpi, cmd, response);
246 int dlm_digital_pod_state_set(struct sr_scpi_dev_inst *scpi, int pod,
247 const gboolean value)
249 /* TODO: pod currently ignored as DLM2000 only has pod A. */
253 return sr_scpi_send(scpi, ":LOGIC:MODE ON");
255 return sr_scpi_send(scpi, ":LOGIC:MODE OFF");
258 int dlm_response_headers_set(struct sr_scpi_dev_inst *scpi,
259 const gboolean value)
262 return sr_scpi_send(scpi, ":COMMUNICATE:HEADER ON");
264 return sr_scpi_send(scpi, ":COMMUNICATE:HEADER OFF");
267 int dlm_acquisition_stop(struct sr_scpi_dev_inst *scpi)
269 return sr_scpi_send(scpi, ":STOP");
272 int dlm_acq_length_get(struct sr_scpi_dev_inst *scpi,
279 if (sr_scpi_get_string(scpi, ":WAVEFORM:LENGTH?", &s) != SR_OK)
283 if (sr_atol(s, &tmp) == SR_OK)
294 int dlm_chunks_per_acq_get(struct sr_scpi_dev_inst *scpi, int *response)
299 * Data retrieval queries such as :WAVEFORM:SEND? will only return
300 * up to 12500 samples at a time. If the oscilloscope operates in a
301 * mode where more than 12500 samples fit on screen (i.e. in one
302 * acquisition), data needs to be retrieved multiple times.
305 result = sr_scpi_get_int(scpi, ":WAVEFORM:LENGTH?", &acq_len);
306 *response = MAX(acq_len / DLM_MAX_FRAME_LENGTH, 1);
311 int dlm_start_frame_set(struct sr_scpi_dev_inst *scpi, int value)
313 gchar cmd[MAX_COMMAND_SIZE];
315 g_snprintf(cmd, sizeof(cmd), ":WAVEFORM:START %d",
316 value * DLM_MAX_FRAME_LENGTH);
318 return sr_scpi_send(scpi, cmd);
321 int dlm_data_get(struct sr_scpi_dev_inst *scpi, int acquisition_num)
323 gchar cmd[MAX_COMMAND_SIZE];
325 g_snprintf(cmd, sizeof(cmd), ":WAVEFORM:ALL:SEND? %d", acquisition_num);
326 return sr_scpi_send(scpi, cmd);
329 int dlm_analog_data_get(struct sr_scpi_dev_inst *scpi, int channel)
331 gchar cmd[MAX_COMMAND_SIZE];
334 result = sr_scpi_send(scpi, ":WAVEFORM:FORMAT BYTE");
335 if (result == SR_OK) result = sr_scpi_send(scpi, ":WAVEFORM:RECORD 0");
336 if (result == SR_OK) result = sr_scpi_send(scpi, ":WAVEFORM:START 0");
337 if (result == SR_OK) result = sr_scpi_send(scpi, ":WAVEFORM:END 124999999");
339 g_snprintf(cmd, sizeof(cmd), ":WAVEFORM:TRACE %d", channel);
340 if (result == SR_OK) result = sr_scpi_send(scpi, cmd);
342 if (result == SR_OK) result = sr_scpi_send(scpi, ":WAVEFORM:SEND? 1");
347 int dlm_digital_data_get(struct sr_scpi_dev_inst *scpi)
351 result = sr_scpi_send(scpi, ":WAVEFORM:FORMAT BYTE");
352 if (result == SR_OK) result = sr_scpi_send(scpi, ":WAVEFORM:RECORD 0");
353 if (result == SR_OK) result = sr_scpi_send(scpi, ":WAVEFORM:START 0");
354 if (result == SR_OK) result = sr_scpi_send(scpi, ":WAVEFORM:END 124999999");
355 if (result == SR_OK) result = sr_scpi_send(scpi, ":WAVEFORM:TRACE LOGIC");
356 if (result == SR_OK) result = sr_scpi_send(scpi, ":WAVEFORM:SEND? 1");