TODO

From sigrok
Revision as of 03:41, 13 February 2012 by Bert (talk | contribs)
Jump to navigation Jump to search

sigrok 0.3

  • Remove time/duration left-overs from libsigrok.
  • stackable protocol decoder implementation
    • Fix segfault: If "probes = [{}]" is used (for example), i.e., one or more of the dict items are not there, that yields a segfault.
    • How to pass (and what exactly, and in which format) samples and already decoded protocol packets:
        • From C to Python (i.e. from libsigrokdecode/controller to the lowest-level decoder)
        • From Python to Python (i.e., from one decoder to the next in the stack)
        • From Python to C (i.e., from a decoder back to libsigrokdecode, which then hands it over to the CLI/GUI, which write it to file or display it in the GUI).
    • free all instances at end of session
    • Annotations need an additional 'type' field, so that PDs/GUIs can differentiate between different output "things".
      • Types are not yet defined, but could be things like DEFAULT, ERR, WARN, DBG, and others.
      • Best handled with a keyword arg to put(), which defaults to srd.ANN_DEFAULT
    • There will also have to be a type for "sections", i.e. grouped sets of fields that have something in common -- an EDID block, ethernet frame, etc.
      • Actually not needed: these annotations will cover a larger sample range than its individual fields, so it's up to the frontend to do something visually interesting with this.
    • Annotations: replace string with optional list, containing annotations in decreasing length?
      • quick and easy form: put(ss, es, opid_ann, "something")
      • multiple strings: put(ss, es, opid_ann, ["something", "else", "yet"])
      • ...or annotations of decreasing length: put(ss, es, opid_ann, ["something", "sth", "s"])
    • Test/implement support for multiple outputs of one PD, and stacking different additional PDs on those outputs.
    • Test/implement multiple inputs support.
  • APIs:
    • PDs: Change extra_probes to optional_probes (or a shorter name for that).
    • srd: All public functions/names must have srd_ prefix.
    • Add good Doxygen documentation
      • libsigrokdecode
      • libsigrok
    • validate/review APIs
      • libsigrokdecode
      • libsigrok
    • all API calls should use/return g_try_malloc()ed stuff and use g_free() instead of regular malloc()/free().
      • libsigrokdecode
      • libsigrok
    • all APIs need to be carefully reviewed/checked and private stuff must be made private via "static" or SR_PRIV/SRD_PRIV.
      • libsigrokdecode
      • libsigrok
    • srd: Python implementation details should be removed from the API.
    • all direct uses of file descriptors in the API should disappear, and GIOChannel should be used instead (portability issues)
    • use gboolean for all functions returning boolean values (as we depend on glib already anyway)
      • libsigrokdecode
      • libsigrok
    • use const for all parameters which are not changed by the API call.
    • there must not be any lib-internal data structures that a frontend can manipulate directly. Internal stuff must be non-accessible, except via our defined API calls.
    • use short naming for some overly long function names. For example: device_instance -> dev_inst everywhere.
  • Mac OS X: B460800 is not available it seems. Find the correct header (if any) and/or find a (possibly platform-specific) workaround, or drop this on Mac OS X.
  • Make sure all combinations of --enable-*/--disable-* options works for configure.
    • There may be issue if none of the drivers is enabled, print useful error in that case(?)
  • libsigrok.h/libsigrokdecode.h: Only list public API functions.

sigrok 0.4

  • SRD improvements:
    • Performance: ATM data passed to decode() creates lots of Python objects (-> performance, huge memory usage); find a way to make that more efficient. Use 'bytes' and/or 'memoryview' and the new Python 3 buffer API (?)
    • Test/implement config PD method etc.
  • CLI improvements:
    • Stop session if SRD initialization indicates an error at any point.
    • Support for printing/selecting a specific annotation for output (or multiple).
    • Eliminate all printing to stdout, only sample data or decoder output should end up there. Error/debug messages should go to stderr always.
    • Add a --start-sampling (TODO: Better name?) option, which just starts sampling with the supplied or default samplerate. Contrary to --time or --samples you don't need to explicitly specify a duration or number of samples here, that's automatically determined by the available memory of the logic analyzer and the selected samplerate.
      • TODO: Similar to --continuous? Merge both?
      • make it --run
    • enforce input/output options in PDs: don't send logic if PD only accepts i2c etc. figure out what to do with inputs[] and outputs[] (1-wire case)
    • Python exception handling in libsrd: add full traceback support with srd_dbg()
  • Wiki improvements:
  • Run the code receiving the samples as quickly as possible, run output format code and other non-timing-critical stuff (protocol decoders) in an extra thread. The problem is nicely visible with FX2-based logic analyzers, the longer an output format takes to produce its output, the better your chances to get "oops, I just lost samples" errors.
  • modular filter system
    • take arguments in the regular thing:key=value format
    • integrate current probe compression filter
    • resampling module: sample up/down based on factor argument
    • noise filter: filter out pulses shorter than the samplerate's period
  • Finish fx2lafw (open-source FX2 firmware).
  • Factor out input/output file formats to libsigrokfile.
  • change all code to start counting probes at 0, not 1.
  • Get rid of the use of manual polling of FDs, which is not portable (doesn't work on Windows). Use g_poll() instead (which spawns a new thread on Windows).
  • We will have an extra datafeed type SR_DF_LOGIC_INDEXED, which contains [samplenumber, sample] instead of just raw samples. Samplenumber is a uint64_t, and sample is unchanged (unitsize). Frontends must be able to handle both, and modular filters in libsigrok or the sampling filter in libsigrokdecode may convert from SR_DF_LOGIC to SR_DF_LOGIC_INDEXED at any time.
  • ANT8/18e unified driver
  • Processing raw logic vs. everything else up the stack: (optionally) deliver pre-sampled by clock or rate?

    Yes, the controller will deliver a clock- or rate-sampled feed instead, if the PD requests this via a configuration option.

  • Hardware drivers: Make specification of triggering capabilities more detailed, so that frontends/GUIs can auto-generate GUI forms out of that metadata.
  • Windows port:
    • Implement anykey.c replacement.
    • hex output: Not all lines/columns are of the same length (as they are with real LAs).
    • VCD: All samplenumbers are 0 (instead of the proper samplecount).
    • OLS, gnuplot: Hangs on MinGW for some reasons (not sure if related).

Before 1.0

  • all output modules should use GString API instead of estimating output size
  • VCD input modules
  • OLS format input module

Future

  • udev:
    • Make udev optional, only build MSO driver if it's available
    • have OLS driver use udev if available, fall back to serial port probing otherwise
    • Find alternative to udev for windows and macos
  • Fix/workaround libusb 1.0 Windows port issues:
    • Device renumeration not yet supported (needed for FX2 based LAs)
    • File descriptor / socket based polling not supported in Windows. Workaround (short-term): Use a thread in sigrok.
  • Make sure all optional components are really optional in the build system:
    • Only require Python if the users wants protocol decoders, the rest should also build/compile/run fine without Python installed.
  • sigrok uses uint64_t as an internal datatype to represent a sample, limiting the number of probes on supported hardware to 64. But high-end logic analyzers can have hundreds of probes. A solution would be to switch to either a roll-our-own byte array type, or use GMP. In any case, the overhead of switching over shouldn't be too bad: the filter code and frontend datafeed callback functions will need to use it, but hardware drivers should have enough with a couple of lightweight wrappers.
  • sr_errno:
    • Most functions should return SR_OK or SR_ERR_* (same for SRD_OK etc).
    • Most backend functions return status as an integer, which is SR_OK if all went well, or SR_ERR_* and similar if an error occurred.
    • However there is no way to pass any information back as to what went wrong — and this is important for user-friendliness.
    • Perhaps an error code is not enough; maybe something like sigrok_errno(errorcode, "unsupported device") is better.
  • Clean up device-specific globals in hardware drivers, to properly permit multiple devices per driver: asix-sigma, demo (not relevant), link-mso19, openbench-logic-sniffer, saleae-logic, zeroplus-logic-cube
  • Python bindings for libsigrok and libsigrokdecode.

Contributors wanted

  • Add output for latex package tikz-timing.
  • Add output for browser waveform viewer/editor written in javascript/JSON called WaveDrom.
  • Linux distro packages for non-Debian distros.
  • FreeBSD packages/ports.
Retrieved from "https://sigrok.org/w/index.php?title=TODO&oldid=1562"