]> sigrok.org Git - libsigrok.git/blame - output/vcd.c
Skip analog probes in logic-only output formats.
[libsigrok.git] / output / vcd.c
CommitLineData
4c9ffa83 1/*
50985c20 2 * This file is part of the libsigrok project.
4c9ffa83
UH
3 *
4 * Copyright (C) 2010 Uwe Hermann <uwe@hermann-uwe.de>
13d8e03c 5 * Copyright (C) 2013 Bert Vermeulen <bert@biot.com>
4c9ffa83
UH
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22#include <stdlib.h>
23#include <string.h>
24#include <glib.h>
545f9786 25#include "config.h" /* Needed for PACKAGE and others. */
45c59c8b
BV
26#include "libsigrok.h"
27#include "libsigrok-internal.h"
4c9ffa83 28
3544f848 29#define LOG_PREFIX "output/vcd"
a944a84b 30
4c9ffa83
UH
31struct context {
32 int num_enabled_probes;
a1be7b6c 33 GArray *probeindices;
fbf1ff5d 34 GString *header;
b050fc48 35 uint8_t *prevsample;
b33e7d70
HE
36 int period;
37 uint64_t samplerate;
b050fc48 38 unsigned int unitsize;
4c9ffa83
UH
39};
40
d078d2e5 41static const char *vcd_header_comment = "\
7aae7462
BV
42$comment\n Acquisition with %d/%d probes at %s\n$end\n";
43
f50f3f40 44static int init(struct sr_output *o)
4c9ffa83 45{
4c9ffa83 46 struct context *ctx;
1afe8989 47 struct sr_probe *probe;
4c9ffa83 48 GSList *l;
ec4063b8 49 GVariant *gvar;
b33e7d70 50 int num_probes, i;
fbf1ff5d 51 char *samplerate_s, *frequency_s, *timestamp;
5cca9adb 52 time_t t;
4c9ffa83 53
133a37bf 54 if (!(ctx = g_try_malloc0(sizeof(struct context)))) {
a944a84b 55 sr_err("%s: ctx malloc failed", __func__);
e46b8fb1 56 return SR_ERR_MALLOC;
133a37bf 57 }
757b8c62 58
4c9ffa83
UH
59 o->internal = ctx;
60 ctx->num_enabled_probes = 0;
a1be7b6c 61 ctx->probeindices = g_array_new(FALSE, FALSE, sizeof(int));
757b8c62 62
5c3c1241 63 for (l = o->sdi->probes; l; l = l->next) {
4c9ffa83 64 probe = l->data;
3699a8a1
BV
65 if (probe->type != SR_PROBE_LOGIC)
66 continue;
757b8c62
UH
67 if (!probe->enabled)
68 continue;
a1be7b6c
ML
69 ctx->probeindices = g_array_append_val(
70 ctx->probeindices, probe->index);
ba6568c5 71 ctx->num_enabled_probes++;
4c9ffa83 72 }
fbf1ff5d 73 if (ctx->num_enabled_probes > 94) {
a944a84b 74 sr_err("VCD only supports 94 probes.");
e46b8fb1 75 return SR_ERR;
fbf1ff5d 76 }
4c9ffa83 77
b050fc48 78 ctx->unitsize = (ctx->num_enabled_probes + 7) / 8;
fbf1ff5d 79 ctx->header = g_string_sized_new(512);
5c3c1241 80 num_probes = g_slist_length(o->sdi->probes);
4c9ffa83 81
fbf1ff5d
BV
82 /* timestamp */
83 t = time(NULL);
133a37bf 84 timestamp = g_strdup(ctime(&t));
fbf1ff5d
BV
85 timestamp[strlen(timestamp)-1] = 0;
86 g_string_printf(ctx->header, "$date %s $end\n", timestamp);
133a37bf 87 g_free(timestamp);
4c9ffa83 88
fbf1ff5d
BV
89 /* generator */
90 g_string_append_printf(ctx->header, "$version %s %s $end\n",
91 PACKAGE, PACKAGE_VERSION);
4c9ffa83 92
d3c74a6f
BV
93 if (sr_config_get(o->sdi->driver, o->sdi, NULL, SR_CONF_SAMPLERATE,
94 &gvar) == SR_OK) {
ec4063b8 95 ctx->samplerate = g_variant_get_uint64(gvar);
af51a771 96 g_variant_unref(gvar);
a00ba012 97 if (!((samplerate_s = sr_samplerate_string(ctx->samplerate)))) {
fbf1ff5d 98 g_string_free(ctx->header, TRUE);
133a37bf 99 g_free(ctx);
e46b8fb1 100 return SR_ERR;
6b5e3cee 101 }
fbf1ff5d
BV
102 g_string_append_printf(ctx->header, vcd_header_comment,
103 ctx->num_enabled_probes, num_probes, samplerate_s);
133a37bf 104 g_free(samplerate_s);
7aae7462 105 }
4c9ffa83 106
fbf1ff5d
BV
107 /* timescale */
108 /* VCD can only handle 1/10/100 (s - fs), so scale up first */
59df0c77
UH
109 if (ctx->samplerate > SR_MHZ(1))
110 ctx->period = SR_GHZ(1);
111 else if (ctx->samplerate > SR_KHZ(1))
112 ctx->period = SR_MHZ(1);
fbf1ff5d 113 else
59df0c77 114 ctx->period = SR_KHZ(1);
a00ba012 115 if (!(frequency_s = sr_period_string(ctx->period))) {
fbf1ff5d 116 g_string_free(ctx->header, TRUE);
133a37bf 117 g_free(ctx);
e46b8fb1 118 return SR_ERR;
fbf1ff5d
BV
119 }
120 g_string_append_printf(ctx->header, "$timescale %s $end\n", frequency_s);
133a37bf 121 g_free(frequency_s);
fbf1ff5d
BV
122
123 /* scope */
124 g_string_append_printf(ctx->header, "$scope module %s $end\n", PACKAGE);
125
4c9ffa83 126 /* Wires / channels */
d601c0e9
ML
127 for (i = 0, l = o->sdi->probes; l; l = l->next, i++) {
128 probe = l->data;
3699a8a1
BV
129 if (probe->type != SR_PROBE_LOGIC)
130 continue;
d601c0e9
ML
131 if (!probe->enabled)
132 continue;
fbf1ff5d 133 g_string_append_printf(ctx->header, "$var wire 1 %c %s $end\n",
d601c0e9 134 (char)('!' + i), probe->name);
4c9ffa83
UH
135 }
136
fbf1ff5d
BV
137 g_string_append(ctx->header, "$upscope $end\n"
138 "$enddefinitions $end\n$dumpvars\n");
4c9ffa83 139
b050fc48 140 if (!(ctx->prevsample = g_try_malloc0(ctx->unitsize))) {
fbf1ff5d 141 g_string_free(ctx->header, TRUE);
133a37bf 142 g_free(ctx);
b050fc48 143 sr_err("%s: ctx->prevsample malloc failed", __func__);
e46b8fb1 144 return SR_ERR_MALLOC;
6b5e3cee 145 }
5a8fda15 146
e46b8fb1 147 return SR_OK;
4c9ffa83
UH
148}
149
17f63de6
BV
150static int receive(struct sr_output *o, const struct sr_dev_inst *sdi,
151 const struct sr_datafeed_packet *packet, GString **out)
4c9ffa83 152{
d5585e32 153 const struct sr_datafeed_logic *logic;
4c9ffa83 154 struct context *ctx;
fbf1ff5d 155 unsigned int i;
ba6568c5 156 int p, curbit, prevbit, index;
b050fc48 157 uint8_t *sample;
086eac7c 158 static uint64_t samplecount = 0;
4c9ffa83 159
d5585e32
BV
160 (void)sdi;
161
17f63de6 162 *out = NULL;
d5585e32 163 if (!o || !o->internal)
17f63de6 164 return SR_ERR_ARG;
4c9ffa83 165 ctx = o->internal;
d5585e32
BV
166
167 if (packet->type == SR_DF_END) {
17f63de6
BV
168 *out = g_string_new("$dumpoff\n$end\n");
169 return SR_OK;
d5585e32 170 } else if (packet->type != SR_DF_LOGIC)
17f63de6 171 return SR_OK;
6b5e3cee 172
4c9ffa83
UH
173 if (ctx->header) {
174 /* The header is still here, this must be the first packet. */
17f63de6 175 *out = ctx->header;
4c9ffa83 176 ctx->header = NULL;
d5585e32 177 } else {
17f63de6 178 *out = g_string_sized_new(512);
4c9ffa83
UH
179 }
180
d5585e32
BV
181 logic = packet->payload;
182 for (i = 0; i <= logic->length - logic->unitsize; i += logic->unitsize) {
086eac7c 183 samplecount++;
08b488b8 184
b050fc48 185 sample = logic->data + i;
08b488b8 186
4c9ffa83 187 for (p = 0; p < ctx->num_enabled_probes; p++) {
a1be7b6c 188 index = g_array_index(ctx->probeindices, int, p);
b050fc48 189 curbit = (sample[p / 8] & (((uint8_t) 1) << index)) >> index;
34539700 190 prevbit = (ctx->prevsample[p / 8] & (((uint8_t) 1) << index)) >> index;
fbe2f794
UH
191
192 /* VCD only contains deltas/changes of signals. */
607b58de
UH
193 if (prevbit == curbit)
194 continue;
4c9ffa83 195
fbe2f794 196 /* Output which signal changed to which value. */
17f63de6 197 g_string_append_printf(*out, "#%" PRIu64 "\n%i%c\n",
32c0551b 198 (uint64_t)(((float)samplecount / ctx->samplerate)
b33e7d70 199 * ctx->period), curbit, (char)('!' + p));
4c9ffa83 200 }
08b488b8 201
b050fc48 202 memcpy(ctx->prevsample, sample, ctx->unitsize);
4c9ffa83
UH
203 }
204
17f63de6 205 return SR_OK;
d5585e32
BV
206}
207
208static int cleanup(struct sr_output *o)
209{
210 struct context *ctx;
211
212 if (!o || !o->internal)
213 return SR_ERR_ARG;
214
215 ctx = o->internal;
216 g_free(ctx);
4c9ffa83 217
e46b8fb1 218 return SR_OK;
4c9ffa83
UH
219}
220
f50f3f40 221struct sr_output_format output_vcd = {
cdb3573c 222 .id = "vcd",
d494a4aa
UH
223 .description = "Value Change Dump (VCD)",
224 .df_type = SR_DF_LOGIC,
225 .init = init,
17f63de6 226 .receive = receive,
bbe6e336 227 .cleanup = cleanup,
4c9ffa83 228};