2 * This file is part of the libsigrok project.
4 * Copyright (C) 2020 Gerhard Sittig <gerhard.sittig@gmx.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 <libsigrok/libsigrok.h>
21 #include "libsigrok-internal.h"
24 struct feed_queue_logic {
25 const struct sr_dev_inst *sdi;
30 struct sr_datafeed_packet packet;
31 struct sr_datafeed_logic logic;
34 SR_API struct feed_queue_logic *feed_queue_logic_alloc(
35 const struct sr_dev_inst *sdi,
36 size_t sample_count, size_t unit_size)
38 struct feed_queue_logic *q;
40 q = g_malloc0(sizeof(*q));
42 q->unit_size = unit_size;
43 q->alloc_count = sample_count;
44 q->data_bytes = g_try_malloc(q->alloc_count * q->unit_size);
50 memset(&q->packet, 0, sizeof(q->packet));
51 memset(&q->logic, 0, sizeof(q->logic));
52 q->packet.type = SR_DF_LOGIC;
53 q->packet.payload = &q->logic;
54 q->logic.unitsize = q->unit_size;
55 q->logic.data = q->data_bytes;
60 SR_API int feed_queue_logic_submit_one(struct feed_queue_logic *q,
61 const uint8_t *data, size_t repeat_count)
66 wrptr = &q->data_bytes[q->fill_count * q->unit_size];
67 while (repeat_count--) {
68 memcpy(wrptr, data, q->unit_size);
69 wrptr += q->unit_size;
71 if (q->fill_count == q->alloc_count) {
72 ret = feed_queue_logic_flush(q);
75 wrptr = &q->data_bytes[0];
82 SR_API int feed_queue_logic_submit_many(struct feed_queue_logic *q,
83 const uint8_t *data, size_t samples_count)
86 size_t space, copy_count;
89 wrptr = &q->data_bytes[q->fill_count * q->unit_size];
90 while (samples_count) {
91 space = q->alloc_count - q->fill_count;
92 copy_count = samples_count;
93 if (copy_count > space)
95 memcpy(wrptr, data, copy_count * q->unit_size);
96 data += copy_count * q->unit_size;
97 samples_count -= copy_count;
98 wrptr += copy_count * q->unit_size;
99 q->fill_count += copy_count;
100 if (q->fill_count == q->alloc_count) {
101 ret = feed_queue_logic_flush(q);
104 wrptr = &q->data_bytes[0];
111 SR_API int feed_queue_logic_flush(struct feed_queue_logic *q)
118 q->logic.length = q->fill_count * q->unit_size;
119 ret = sr_session_send(q->sdi, &q->packet);
127 SR_API int feed_queue_logic_send_trigger(struct feed_queue_logic *q)
131 ret = feed_queue_logic_flush(q);
135 ret = std_session_send_df_trigger(q->sdi);
142 SR_API void feed_queue_logic_free(struct feed_queue_logic *q)
148 g_free(q->data_bytes);
152 struct feed_queue_analog {
153 const struct sr_dev_inst *sdi;
158 struct sr_datafeed_packet packet;
159 struct sr_datafeed_analog analog;
160 struct sr_analog_encoding encoding;
161 struct sr_analog_meaning meaning;
162 struct sr_analog_spec spec;
166 SR_API struct feed_queue_analog *feed_queue_analog_alloc(
167 const struct sr_dev_inst *sdi,
168 size_t sample_count, int digits, struct sr_channel *ch)
170 struct feed_queue_analog *q;
172 q = g_malloc0(sizeof(*q));
174 q->alloc_count = sample_count;
175 q->data_values = g_try_malloc(q->alloc_count * sizeof(float));
176 if (!q->data_values) {
181 q->channels = g_slist_append(NULL, ch);
183 memset(&q->packet, 0, sizeof(q->packet));
184 sr_analog_init(&q->analog, &q->encoding, &q->meaning, &q->spec, digits);
185 q->packet.type = SR_DF_ANALOG;
186 q->packet.payload = &q->analog;
187 q->encoding.is_signed = TRUE;
188 q->meaning.channels = q->channels;
189 q->analog.data = q->data_values;
194 SR_API int feed_queue_analog_mq_unit(struct feed_queue_analog *q,
195 enum sr_mq mq, enum sr_mqflag mq_flag, enum sr_unit unit)
202 ret = feed_queue_analog_flush(q);
207 q->meaning.mqflags = mq_flag;
208 q->meaning.unit = unit;
213 SR_API int feed_queue_analog_scale_offset(struct feed_queue_analog *q,
214 const struct sr_rational *scale, const struct sr_rational *offset)
221 ret = feed_queue_analog_flush(q);
226 q->encoding.scale = *scale;
228 q->encoding.offset = *offset;
233 SR_API int feed_queue_analog_submit_one(struct feed_queue_analog *q,
234 float data, size_t repeat_count)
238 while (repeat_count--) {
239 q->data_values[q->fill_count++] = data;
240 if (q->fill_count == q->alloc_count) {
241 ret = feed_queue_analog_flush(q);
250 SR_API int feed_queue_analog_flush(struct feed_queue_analog *q)
257 q->analog.num_samples = q->fill_count;
258 ret = sr_session_send(q->sdi, &q->packet);
266 SR_API void feed_queue_analog_free(struct feed_queue_analog *q)
272 g_free(q->data_values);
273 g_slist_free(q->channels);