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/>.
20 #include "protocol_wrappers.h"
22 #define MAX_COMMAND_SIZE 64
26 * https://www.yokogawa.com/pdf/provide/E/GW/IM/0000022842/0/IM710105-17E.pdf
29 int dlm_timebase_get(struct sr_scpi_dev_inst *scpi,
32 return sr_scpi_get_string(scpi, ":TIMEBASE:TDIV?", response);
35 int dlm_timebase_set(struct sr_scpi_dev_inst *scpi,
38 gchar cmd[MAX_COMMAND_SIZE];
39 g_snprintf(cmd, sizeof(cmd), ":TIMEBASE:TDIV %s", value);
40 return sr_scpi_send(scpi, cmd);
43 int dlm_horiz_trigger_pos_get(struct sr_scpi_dev_inst *scpi,
46 return sr_scpi_get_float(scpi, ":TRIGGER:DELAY:TIME?", response);
49 int dlm_horiz_trigger_pos_set(struct sr_scpi_dev_inst *scpi,
52 gchar cmd[MAX_COMMAND_SIZE];
53 g_snprintf(cmd, sizeof(cmd), ":TRIGGER:DELAY:TIME %s", value);
54 return sr_scpi_send(scpi, cmd);
57 int dlm_trigger_source_get(struct sr_scpi_dev_inst *scpi,
60 return sr_scpi_get_string(scpi, ":TRIGGER:ATRIGGER:SIMPLE:SOURCE?", response);
63 int dlm_trigger_source_set(struct sr_scpi_dev_inst *scpi,
66 gchar cmd[MAX_COMMAND_SIZE];
67 g_snprintf(cmd, sizeof(cmd), ":TRIGGER:ATRIGGER:SIMPLE:SOURCE %s", value);
68 return sr_scpi_send(scpi, cmd);
71 int dlm_trigger_slope_get(struct sr_scpi_dev_inst *scpi,
79 if (sr_scpi_get_string(scpi, ":TRIGGER:ATRIGGER:SIMPLE:SLOPE?", &resp) != SR_OK) {
84 if (strcmp("RISE", resp) == 0) {
85 *response = SLOPE_POSITIVE;
89 if (strcmp("FALL", resp) == 0) {
90 *response = SLOPE_NEGATIVE;
98 int dlm_trigger_slope_set(struct sr_scpi_dev_inst *scpi,
101 if (value == SLOPE_POSITIVE)
102 return sr_scpi_send(scpi, ":TRIGGER:ATRIGGER:SIMPLE:SLOPE RISE");
104 if (value == SLOPE_NEGATIVE)
105 return sr_scpi_send(scpi, ":TRIGGER:ATRIGGER:SIMPLE:SLOPE FALL");
110 int dlm_analog_chan_state_get(struct sr_scpi_dev_inst *scpi, int channel,
113 gchar cmd[MAX_COMMAND_SIZE];
114 g_snprintf(cmd, sizeof(cmd), ":CHANNEL%d:DISPLAY?", channel);
115 return sr_scpi_get_bool(scpi, cmd, response);
118 int dlm_analog_chan_state_set(struct sr_scpi_dev_inst *scpi, int channel,
119 const gboolean value)
121 gchar cmd[MAX_COMMAND_SIZE];
124 g_snprintf(cmd, sizeof(cmd), ":CHANNEL%d:DISPLAY ON", channel);
126 g_snprintf(cmd, sizeof(cmd), ":CHANNEL%d:DISPLAY OFF", channel);
128 return sr_scpi_send(scpi, cmd);
131 int dlm_analog_chan_vdiv_get(struct sr_scpi_dev_inst *scpi, int channel,
134 gchar cmd[MAX_COMMAND_SIZE];
135 g_snprintf(cmd, sizeof(cmd), ":CHANNEL%d:VDIV?", channel);
136 return sr_scpi_get_string(scpi, cmd, response);
139 int dlm_analog_chan_vdiv_set(struct sr_scpi_dev_inst *scpi, int channel,
142 gchar cmd[MAX_COMMAND_SIZE];
143 g_snprintf(cmd, sizeof(cmd), ":CHANNEL%d:VDIV %s", channel, value);
144 return sr_scpi_send(scpi, cmd);
147 int dlm_analog_chan_voffs_get(struct sr_scpi_dev_inst *scpi, int channel,
150 gchar cmd[MAX_COMMAND_SIZE];
151 g_snprintf(cmd, sizeof(cmd), ":CHANNEL%d:POSITION?", channel);
152 return sr_scpi_get_float(scpi, cmd, response);
155 int dlm_analog_chan_srate_get(struct sr_scpi_dev_inst *scpi, int channel,
158 gchar cmd[MAX_COMMAND_SIZE];
159 g_snprintf(cmd, sizeof(cmd), ":WAVEFORM:TRACE %d", channel);
161 if (sr_scpi_send(scpi, cmd) != SR_OK)
164 g_snprintf(cmd, sizeof(cmd), ":WAVEFORM:RECORD 0");
165 if (sr_scpi_send(scpi, cmd) != SR_OK)
168 return sr_scpi_get_float(scpi, ":WAVEFORM:SRATE?", response);
171 int dlm_analog_chan_coupl_get(struct sr_scpi_dev_inst *scpi, int channel,
174 gchar cmd[MAX_COMMAND_SIZE];
175 g_snprintf(cmd, sizeof(cmd), ":CHANNEL%d:COUPLING?", channel);
176 return sr_scpi_get_string(scpi, cmd, response);
179 int dlm_analog_chan_coupl_set(struct sr_scpi_dev_inst *scpi, int channel,
182 gchar cmd[MAX_COMMAND_SIZE];
183 g_snprintf(cmd, sizeof(cmd), ":CHANNEL%d:COUPLING %s", channel, value);
184 return sr_scpi_send(scpi, cmd);
187 int dlm_analog_chan_wrange_get(struct sr_scpi_dev_inst *scpi, int channel,
190 gchar cmd[MAX_COMMAND_SIZE];
193 g_snprintf(cmd, sizeof(cmd), ":WAVEFORM:TRACE %d", channel);
194 result = sr_scpi_send(scpi, cmd);
195 result &= sr_scpi_get_float(scpi, ":WAVEFORM:RANGE?", response);
199 int dlm_analog_chan_woffs_get(struct sr_scpi_dev_inst *scpi, int channel,
202 gchar cmd[MAX_COMMAND_SIZE];
205 g_snprintf(cmd, sizeof(cmd), ":WAVEFORM:TRACE %d", channel);
206 result = sr_scpi_send(scpi, cmd);
207 result &= sr_scpi_get_float(scpi, ":WAVEFORM:OFFSET?", response);
211 int dlm_digital_chan_state_get(struct sr_scpi_dev_inst *scpi, int channel,
214 gchar cmd[MAX_COMMAND_SIZE];
215 g_snprintf(cmd, sizeof(cmd), ":LOGIC:PODA:BIT%d:DISPLAY?", channel);
216 return sr_scpi_get_bool(scpi, cmd, response);
219 int dlm_digital_chan_state_set(struct sr_scpi_dev_inst *scpi, int channel,
220 const gboolean value)
222 gchar cmd[MAX_COMMAND_SIZE];
225 g_snprintf(cmd, sizeof(cmd), ":LOGIC:PODA:BIT%d:DISPLAY ON", channel);
227 g_snprintf(cmd, sizeof(cmd), ":LOGIC:PODA:BIT%d:DISPLAY OFF", channel);
229 return sr_scpi_send(scpi, cmd);
232 int dlm_digital_pod_state_get(struct sr_scpi_dev_inst *scpi, int pod,
235 gchar cmd[MAX_COMMAND_SIZE];
237 /* TODO: pod currently ignored as DLM2000 only has pod A. */
240 g_snprintf(cmd, sizeof(cmd), ":LOGIC:MODE?");
241 return sr_scpi_get_bool(scpi, cmd, response);
244 int dlm_digital_pod_state_set(struct sr_scpi_dev_inst *scpi, int pod,
245 const gboolean value)
247 /* TODO: pod currently ignored as DLM2000 only has pod A. */
251 return sr_scpi_send(scpi, ":LOGIC:MODE ON");
253 return sr_scpi_send(scpi, ":LOGIC:MODE OFF");
256 int dlm_response_headers_set(struct sr_scpi_dev_inst *scpi,
257 const gboolean value)
260 return sr_scpi_send(scpi, ":COMMUNICATE:HEADER ON");
262 return sr_scpi_send(scpi, ":COMMUNICATE:HEADER OFF");
265 int dlm_acquisition_stop(struct sr_scpi_dev_inst *scpi)
267 return sr_scpi_send(scpi, ":STOP");
270 int dlm_acq_length_get(struct sr_scpi_dev_inst *scpi,
277 if (sr_scpi_get_string(scpi, ":WAVEFORM:LENGTH?", &s) != SR_OK)
281 if (sr_atol(s, &tmp) == SR_OK)
292 int dlm_chunks_per_acq_get(struct sr_scpi_dev_inst *scpi, int *response)
296 /* Data retrieval queries such as :WAVEFORM:SEND? will only return
297 * up to 12500 samples at a time. If the oscilloscope operates in a
298 * mode where more than 12500 samples fit on screen (i.e. in one
299 * acquisition), data needs to be retrieved multiple times.
302 result = sr_scpi_get_int(scpi, ":WAVEFORM:LENGTH?", &acq_len);
303 *response = MAX(acq_len / DLM_MAX_FRAME_LENGTH, 1);
308 int dlm_start_frame_set(struct sr_scpi_dev_inst *scpi, int value)
310 gchar cmd[MAX_COMMAND_SIZE];
312 g_snprintf(cmd, sizeof(cmd), ":WAVEFORM:START %d",
313 value * DLM_MAX_FRAME_LENGTH);
315 return sr_scpi_send(scpi, cmd);
318 int dlm_data_get(struct sr_scpi_dev_inst *scpi, int acquisition_num)
320 gchar cmd[MAX_COMMAND_SIZE];
322 g_snprintf(cmd, sizeof(cmd), ":WAVEFORM:ALL:SEND? %d", acquisition_num);
323 return sr_scpi_send(scpi, cmd);
326 int dlm_analog_data_get(struct sr_scpi_dev_inst *scpi, int channel)
328 gchar cmd[MAX_COMMAND_SIZE];
331 result = sr_scpi_send(scpi, ":WAVEFORM:FORMAT BYTE");
332 if (result == SR_OK) result = sr_scpi_send(scpi, ":WAVEFORM:RECORD 0");
333 if (result == SR_OK) result = sr_scpi_send(scpi, ":WAVEFORM:START 0");
334 if (result == SR_OK) result = sr_scpi_send(scpi, ":WAVEFORM:END 124999999");
336 g_snprintf(cmd, sizeof(cmd), ":WAVEFORM:TRACE %d", channel);
337 if (result == SR_OK) result = sr_scpi_send(scpi, cmd);
339 if (result == SR_OK) result = sr_scpi_send(scpi, ":WAVEFORM:SEND? 1");
344 int dlm_digital_data_get(struct sr_scpi_dev_inst *scpi)
348 result = sr_scpi_send(scpi, ":WAVEFORM:FORMAT BYTE");
349 if (result == SR_OK) result = sr_scpi_send(scpi, ":WAVEFORM:RECORD 0");
350 if (result == SR_OK) result = sr_scpi_send(scpi, ":WAVEFORM:START 0");
351 if (result == SR_OK) result = sr_scpi_send(scpi, ":WAVEFORM:END 124999999");
352 if (result == SR_OK) result = sr_scpi_send(scpi, ":WAVEFORM:TRACE LOGIC");
353 if (result == SR_OK) result = sr_scpi_send(scpi, ":WAVEFORM:SEND? 1");