X-Git-Url: https://sigrok.org/gitweb/?a=blobdiff_plain;f=output%2Foutput_analog.c;h=663b8df3ae9c77581c40a1522868c36fe57b602b;hb=baf1d71477ea5c1dea449bc9ce72b39d02751934;hp=6c2901ae086a9850ab6a54ae20c98c0f847457f7;hpb=f3163a6c2ee7a1d7ec6865f11cfcf52b07dc31f5;p=libsigrok.git diff --git a/output/output_analog.c b/output/output_analog.c index 6c2901ae..663b8df3 100644 --- a/output/output_analog.c +++ b/output/output_analog.c @@ -3,6 +3,7 @@ * * Copyright (C) 2010 Bert Vermeulen * Copyright (C) 2011 HÃ¥vard Espeland + * Copyright (C) 2011 Daniel Ribeiro * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -47,7 +48,7 @@ struct context { uint8_t *linevalues; char *header; int mark_trigger; - uint64_t prevsample; +// struct sr_analog_sample *prevsample; enum outputmode mode; }; @@ -88,17 +89,17 @@ static void flush_linebufs(struct context *ctx, char *outbuf) memset(ctx->linebuf, 0, i * ctx->linebuf_len); } -static int init(struct output *o, int default_spl, enum outputmode mode) +static int init(struct sr_output *o, int default_spl, enum outputmode mode) { struct context *ctx; - struct probe *probe; + struct sr_probe *probe; GSList *l; uint64_t samplerate; int num_probes; char *samplerate_s; if (!(ctx = calloc(1, sizeof(struct context)))) - return SIGROK_ERR_MALLOC; + return SR_ERR_MALLOC; o->internal = ctx; ctx->num_enabled_probes = 0; @@ -111,7 +112,8 @@ static int init(struct output *o, int default_spl, enum outputmode mode) } ctx->probelist[ctx->num_enabled_probes] = 0; - ctx->unitsize = (ctx->num_enabled_probes + 7) / 8; + ctx->unitsize = sizeof(struct sr_analog_sample) + + (ctx->num_enabled_probes * sizeof(struct sr_analog_probe)); ctx->line_offset = 0; ctx->spl_cnt = 0; ctx->mark_trigger = -1; @@ -120,24 +122,24 @@ static int init(struct output *o, int default_spl, enum outputmode mode) if (o->param && o->param[0]) { ctx->samples_per_line = strtoul(o->param, NULL, 10); if (ctx->samples_per_line < 1) - return SIGROK_ERR; + return SR_ERR; } else ctx->samples_per_line = default_spl; if (!(ctx->header = malloc(512))) { free(ctx); - return SIGROK_ERR_MALLOC; + return SR_ERR_MALLOC; } snprintf(ctx->header, 511, "%s\n", PACKAGE_STRING); num_probes = g_slist_length(o->device->probes); - if (o->device->plugin) { + if (o->device->plugin && sr_device_has_hwcap(o->device, SR_HWCAP_SAMPLERATE)) { samplerate = *((uint64_t *) o->device->plugin->get_device_info( - o->device->plugin_index, DI_CUR_SAMPLERATE)); - if (!(samplerate_s = sigrok_samplerate_string(samplerate))) { + o->device->plugin_index, SR_DI_CUR_SAMPLERATE)); + if (!(samplerate_s = sr_samplerate_string(samplerate))) { free(ctx->header); free(ctx); - return SIGROK_ERR; + return SR_ERR; } snprintf(ctx->header + strlen(ctx->header), 511 - strlen(ctx->header), @@ -150,18 +152,18 @@ static int init(struct output *o, int default_spl, enum outputmode mode) if (!(ctx->linebuf = calloc(1, num_probes * ctx->linebuf_len))) { free(ctx->header); free(ctx); - return SIGROK_ERR_MALLOC; + return SR_ERR_MALLOC; } if (!(ctx->linevalues = calloc(1, num_probes))) { free(ctx->header); free(ctx); - return SIGROK_ERR_MALLOC; + return SR_ERR_MALLOC; } - return SIGROK_OK; + return SR_OK; } -static int event(struct output *o, int event_type, char **data_out, +static int event(struct sr_output *o, int event_type, char **data_out, uint64_t *length_out) { struct context *ctx; @@ -170,16 +172,16 @@ static int event(struct output *o, int event_type, char **data_out, ctx = o->internal; switch (event_type) { - case DF_TRIGGER: + case SR_DF_TRIGGER: ctx->mark_trigger = ctx->spl_cnt; *data_out = NULL; *length_out = 0; break; - case DF_END: + case SR_DF_END: outsize = ctx->num_enabled_probes * (ctx->samples_per_line + 20) + 512; if (!(outbuf = calloc(1, outsize))) - return SIGROK_ERR_MALLOC; + return SR_ERR_MALLOC; flush_linebufs(ctx, outbuf); *data_out = outbuf; *length_out = strlen(outbuf); @@ -192,25 +194,25 @@ static int event(struct output *o, int event_type, char **data_out, break; } - return SIGROK_OK; + return SR_OK; } -static int init_bits(struct output *o) +static int init_bits(struct sr_output *o) { return init(o, DEFAULT_BPL_BITS, MODE_BITS); } -static int data_bits(struct output *o, char *data_in, uint64_t length_in, - char **data_out, uint64_t *length_out) +static int data_bits(struct sr_output *o, const char *data_in, + uint64_t length_in, char **data_out, uint64_t *length_out) { struct context *ctx; unsigned int outsize, offset, p; int max_linelen; - uint64_t sample; + struct sr_analog_sample *sample; char *outbuf, c; ctx = o->internal; - max_linelen = MAX_PROBENAME_LEN + 3 + ctx->samples_per_line + max_linelen = SR_MAX_PROBENAME_LEN + 3 + ctx->samples_per_line + ctx->samples_per_line / 8; /* * Calculate space needed for probes. Set aside 512 bytes for @@ -220,7 +222,7 @@ static int data_bits(struct output *o, char *data_in, uint64_t length_in, * (ctx->num_enabled_probes * max_linelen); if (!(outbuf = calloc(1, outsize + 1))) - return SIGROK_ERR_MALLOC; + return SR_ERR_MALLOC; outbuf[0] = '\0'; if (ctx->header) { @@ -230,16 +232,26 @@ static int data_bits(struct output *o, char *data_in, uint64_t length_in, ctx->header = NULL; /* Ensure first transition. */ - memcpy(&ctx->prevsample, data_in, ctx->unitsize); - ctx->prevsample = ~ctx->prevsample; +// memcpy(&ctx->prevsample, data_in, ctx->unitsize); +// ctx->prevsample = ~ctx->prevsample; } if (length_in >= ctx->unitsize) { for (offset = 0; offset <= length_in - ctx->unitsize; offset += ctx->unitsize) { - memcpy(&sample, data_in + offset, ctx->unitsize); + sample = (struct sr_analog_sample *) (data_in + offset); for (p = 0; p < ctx->num_enabled_probes; p++) { - c = (sample & ((uint64_t) 1 << p)) ? '1' : '0'; + int val = sample->probes[p].val; + int res = sample->probes[p].res; + if (res == 1) + c = '0' + (val & ((1 << res) - 1)); + else + /* + * Scale analog resolution down so it + * fits 25 letters + */ + c = 'A' + (((val & ((1 << res) - 1)) / + (res * res)) / 10); ctx->linebuf[p * ctx->linebuf_len + ctx->line_offset] = c; } @@ -262,22 +274,22 @@ static int data_bits(struct output *o, char *data_in, uint64_t length_in, } } } else { - g_message("short buffer (length_in=%" PRIu64 ")", length_in); + sr_info("short buffer (length_in=%" PRIu64 ")", length_in); } *data_out = outbuf; *length_out = strlen(outbuf); - return SIGROK_OK; + return SR_OK; } - -static int init_hex(struct output *o) +#if 0 +static int init_hex(struct sr_output *o) { return init(o, DEFAULT_BPL_HEX, MODE_HEX); } -static int data_hex(struct output *o, char *data_in, uint64_t length_in, - char **data_out, uint64_t *length_out) +static int data_hex(struct sr_output *o, const char *data_in, + uint64_t length_in, char **data_out, uint64_t *length_out) { struct context *ctx; unsigned int outsize, offset, p; @@ -286,13 +298,13 @@ static int data_hex(struct output *o, char *data_in, uint64_t length_in, char *outbuf; ctx = o->internal; - max_linelen = MAX_PROBENAME_LEN + 3 + ctx->samples_per_line + 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 / ctx->samples_per_line * max_linelen + 512; if (!(outbuf = calloc(1, outsize + 1))) - return SIGROK_ERR_MALLOC; + return SR_ERR_MALLOC; outbuf[0] = '\0'; if (ctx->header) { @@ -333,16 +345,16 @@ static int data_hex(struct output *o, char *data_in, uint64_t length_in, *data_out = outbuf; *length_out = strlen(outbuf); - return SIGROK_OK; + return SR_OK; } -static int init_ascii(struct output *o) +static int init_ascii(struct sr_output *o) { return init(o, DEFAULT_BPL_ASCII, MODE_ASCII); } -static int data_ascii(struct output *o, char *data_in, uint64_t length_in, - char **data_out, uint64_t *length_out) +static int data_ascii(struct sr_output *o, const char *data_in, + uint64_t length_in, char **data_out, uint64_t *length_out) { struct context *ctx; unsigned int outsize, offset, p; @@ -351,7 +363,7 @@ static int data_ascii(struct output *o, char *data_in, uint64_t length_in, char *outbuf; ctx = o->internal; - max_linelen = MAX_PROBENAME_LEN + 3 + ctx->samples_per_line + max_linelen = SR_MAX_PROBENAME_LEN + 3 + ctx->samples_per_line + ctx->samples_per_line / 8; /* * Calculate space needed for probes. Set aside 512 bytes for @@ -361,7 +373,7 @@ static int data_ascii(struct output *o, char *data_in, uint64_t length_in, * (ctx->num_enabled_probes * max_linelen); if (!(outbuf = calloc(1, outsize + 1))) - return SIGROK_ERR_MALLOC; + return SR_ERR_MALLOC; outbuf[0] = '\0'; if (ctx->header) { @@ -416,39 +428,40 @@ static int data_ascii(struct output *o, char *data_in, uint64_t length_in, ctx->prevsample = sample; } } else { - g_message("short buffer (length_in=%" PRIu64 ")", length_in); + sr_info("short buffer (length_in=%" PRIu64 ")", length_in); } *data_out = outbuf; *length_out = strlen(outbuf); - return SIGROK_OK; + return SR_OK; } - - -struct output_format output_text_bits = { - "bits", - "Bits (takes argument, default 64)", - DF_LOGIC, - init_bits, - data_bits, - event, +#endif + +struct sr_output_format output_analog_bits = { + .id = "analog_bits", + .description = "Bits (takes argument, default 64)", + .df_type = SR_DF_ANALOG, + .init = init_bits, + .data = data_bits, + .event = event, }; - -struct output_format output_text_hex = { - "hex", - "Hexadecimal (takes argument, default 192)", - DF_LOGIC, - init_hex, - data_hex, - event, +#if 0 +struct sr_output_format output_analog_hex = { + .id = "analog_hex", + .description = "Hexadecimal (takes argument, default 192)", + .df_type = SR_DF_ANALOG, + .init = init_hex, + .data = data_hex, + .event = event, }; -struct output_format output_text_ascii = { - "ascii", - "ASCII (takes argument, default 74)", - DF_LOGIC, - init_ascii, - data_ascii, - event, +struct sr_output_format output_analog_ascii = { + .id = "analog_ascii", + .description = "ASCII (takes argument, default 74)", + .df_type = SR_DF_ANALOG, + .init = init_ascii, + .data = data_ascii, + .event = event, }; +#endif