tcp: introduce common support code for TCP socket communication

It appears that so far only SCPI and the Beagleboard have supported
communication across TCP sockets. And both have locally open coded
the corresponding logic.

Introduce common support for TCP communication. This implementation
provides simple new/free, connect/disconnect, read/write (including
non-blocking reads), source add/remove calls, and keeps the API under
the sr_tcp_ prefix.

This commit introduces common code, but does not adjust callers.

input/protocoldata: also accept comma separated data values

Frame format specs in the header section accepted space and comma
separators already (though comma separated frame format details are
considered unusual). Protocol values in non-comment (text mode) lines
assumed strictly space separated fields.

Accept comma and semicolon too as data value separators for maximum user
convenience. Simplifies the import of post processed other text formats,
only requires the addition of headers and decoration (select control,
text to number conversion base), but allows re-use of all existing
values. Reduces diffs before and after manipulating original text into
protocoldata which sigrok can import.

These separators silently get ignored. They don't have a meaning in the
sense of interpreting "1, , 3" as three values. There is no concept of
empty fields in the sequence of data values. This is pure convenience.

input/protocoldata: reduce inter-frame gap for I2C waveforms

Space I2C data bytes the same as address bytes are spaced. Results in a
graphical presentation that is easier to inspect, and is less wasteful
at the same time (more data is seen at the same zoom level).

input: alpha-sort list of known input modules

Sort the 'extern' declarations and the input_module_list[] array items.
Does not change behaviour, just simplifies maintenance.

input/protocoldata: add input module for "protocol values" files

Implement an input module which accepts data values that may have been
gotten by arbitrary means (external capture utility, synthesized data),
and creates logic traces which mimic the respective protocol's format.
This pretends that a logic capture had been taken by sigrok means, which
can be fed to protocol decoders. The motivation is neither to perfectly
simulate a given protocol, nor to inject arbitrary error conditions and
edge cases, but instead to make externally provided data available to
sigrok protocol decoders.

The input module supports several user servicable options to describe
raw files which exclusively contain data bytes. Optional automatic file
format detection is also supported, as is an optional file header to
embed protocol properties with the bytes stream. Text formatted input
is supported as a strict alternative to raw data bytes, also supporting
comments as well as pseudo comments. The latter carry instructions to
control some aspects that are outside of the mere stream of data bytes.
Some protocols may exclusively be useful in combination with text input.

Protocol specific handlers can generate up to eight logic channels, an
arbitrary number of bits per protocol frame, including varying bit times
within a frame, and several quanta per bit time. It is assumed that this
implementation provides enough infrastructure to mimic an arbitrary set
of protocols beyond the initially supported set of UART, SPI, and I2C.

input/vcd: use common helpers for text lines/words splitting

Use recently added strutil helpers which isolate text lines in receive
buffers and which locate whitespace separated words on text lines. This
simplifies the processing of the data section of VCD input files.

It's essential to _not_ use these helpers when the receive buffer must
not get manipulated, like in file format matches, or when control data
sections span multiple text lines. Update comments to raise awareness.

tests: implement strutil tests for text line and word splitting

Add the test_text_line() and test_text_word() routines to cover the
splitting of text buffers into lines and the splitting of words on a
text line.

This implementation "suffers" from global vars at the file scope,
because moving the table of test cases into the test routine results in
compiler errors (initializer data not constant), the cause is uncertain.

strutil: add common helpers for input text parsing (lines, words)

Introduce the sr_text_next_line() and sr_text_next_word() routines which
split an input buffer into text lines and identify whitespace separated
words on a text line. Several input modules redundantly implement this,
having common support is desirable.

tests: raise maximum version text length (dirty flag)

The previous implementation of the version text length check accounted
for the major, minor, micro numbers and the git hash. Raise the upper
limit of the accepted text length range to also account for the optional
"dirty" flag. Update comments to keep awareness of the magic numbers in
the length calculation.

strutil: accept 0b prefix when base is 2 (which is non-zero)

The sr_atoul_base() conversion routine only accepted the 0b binary
prefix when base was 0. Extend this to also accept the 0b prefix when
the caller specified base is 2. This unbreaks a valid use case.

atorch: Implement support for DC and USB Meters

Tested with ATORCH J7-c USB Meter and ATORCH DL24MP-150W Purple Electronic Load

atorch: Initial driver skeleton

binary_helpers: remove unused u64 and float variants (dead code)

Remove support for uint64_t and float data types in the extraction of
number values from byte streams. These are unused in current mainline.
The larger types even don't fit in the single precision result, the
32bit integer already suffers from precision loss during conversion
to float.

binary_helpers: Add bv_get_value function.

binary_helpers: Rename bv_get_value to reflect it's length checking

Rename the bv_get_value() routine to bv_get_value_len() to better reflect
that this implementation checks the input data image's length. A version
which doesn't check length will get introduced soon.

[ gsi: use a shorter name than in the initial submission ]

binary_helpers: Reflect that bv_get_value() takes bytes as input

Prefer uint8_t pointers over void pointers in the bv_get_value()
signature for improved awareness.

binary_helpers: Add support for 24 bits wide integers.

libsigrok-internal.h: Add read_u24be helper function

make: move version suffix gathering from configure to compile time

Check at configure time whether version control is available. Determine
at configure time which branch is being worked on, and re-configure when
the branch changes. Append "-git" to the package version when the source
tree is not tagged at configure time.

Get revision numbers and the dirty flag at compile time. Check whether
the source code revision exactly matches a tag at compile time. Derive
the version suffix from these details. Generate a git-version.h header
file which only the version.c source file references.

This embeds detailled version information into the library, where it is
available at runtime for the library and for applications. And severely
speeds up development iterations by avoiding full rebuilds of the whole
library when a git commit happened. The dirty flag may either require a
manual reconfiguration, or 'make version-clean', if that workspace state
is not automatically picked up. Which is considered acceptable for now,
because builds for distribution should always start with the configure
phase anyway. This uncertainty could only get avoided at the cost of
always creating the git-version.h header file in every build invocation.
Which would be easy to achieve, but remains for a future commit.

The approach was outlined by Martin Ling in 2018-09, see bug #1283. This
implementation additionally handles out-of-source builds, uses positive
logic for the header inclusion, and handles distribution builds from
tarballs or other non-versioned sources (assumes an empty suffix then).
Could also handle other sources of version details, or alternative VCS
implementations, thus passes more variables than strictly necessary from
configuration to compilation.

microchip-pickit2: support user assigned channel names at probe time

Allow users to assign channel names at probe time already. Add support
for the SR_CONF_PROBE_NAMES scan option. Improves usability.

  $ sigrok-cli -d microchip-pickit2:probe_names=spi --samples 1024

microchip-pickit2: move channel creation to after device context alloc

Create device instance (sdi) and device context (devc) first, before
creating channels and channel groups. Channel creation might want to
reflect on per-device properties which are kept in the context.

rdtech-tc: Fix feed creation loop condition

[ gsi: Amends commit b3df76683179. ]

fluke-dmm: Fix digit count in handle_qm_28x function.

This requires splitting the measurement into mantissa and exponent,
as the exponent affects the significant digits count.

fluke-dmm: Fix counts_digits compatibility with 28x format

Remove sign, then only take into account numerical characters (this
correctly excludes the exponent in the scientific notation used by
28x models).

fluke-dmm: Update digits count with regard to measurement exponent

Also defer the creation of sr_datafeed_analog until the whole message
is parsed, and the number of significant digits is known.

binary_helpers: remove scaling factor from binary field extraction

All call sites use the sr_analog_encoding's support to scale values.
Drop the scaling support from the binary field extractor helper.
Adjust calling rdtech-um and rdtech-tc source code accordingly. See
a word diff for the essence.

rdtech-tc: avoid too eager request retransmission

The sequence of a scan/probe (which exchanges exactly one request and
response pair) before an acquisition (which requests another response,
then keeps re-requesting periodically) resulted in the transmission of
more requests shortly after a request was sent and before any response
started receiving at all. Which then resulted in unexpected lengths and
failed consistency checks for the receive data. This condition stuck
because rdtech-tc does not support the re-synchronization to the input
stream as rdtech-um does.

Defer transmission of requests until after receive data was seen (or
an acquisition start forces their transmission). Tested by repeatedly
running:

  $ sigrok-cli -d rdtech-tc:conn=bt/dialog/$MAC --continuous

rdtech-tc: style nits in variable names

Rename the AES_KEY[] to lower case, it's a variable not a preprocessor
symbol. Rename CRC variables to reflect what's calculated and what was
received.

rdtech-tc: dump response payload at higher log levels

The request is sent as is, responses are AES encrypted. Which voids the
point of transport layer dumps. Extend the rdtech-tc device driver, dump
the response content at spew levels after successful AES decryption and
validity checks. Pick a bytes per line count which matches the 64 bytes
chunked layout, yet reduces the number of created log output lines.

rdtech-tc: request keyword differs between CDC and BLE transports

The TC66C firmware implements different keywords and different request
terminators across the USB CDC and the Bluetooth LE transports. Move the
string literal to the probe routine, construct the request text at the
time when the device is probed, then re-use it for the remaining session.

Check the receive buffer size and maximum reponse length for consistency
at compile time. Declarations are spread across source files.

rdtech-tc: rename "buflen" variable, it's "read length"

The 'buflen' variable name could be misleading, as it's not the receive
buffer's size. Instead it is the amount of previously received response
data. Rename it to 'rdlen'.

serial_bt: add TC66C to list of known names, suggest MTU value

Add "TC66C" to the list of known BLE device names. Map it to the
dialog BLE chip. Suggest an MTU value of 200.

serial_bt: support the dialog DA14580 chip (seen in TC66C)

Add support for dialog DA14580 chips, accept conn=bt/dialog/$MAC specs.
These BLE chips were seen in RDTech TC66C energy meters. They appear to
send notifications without the necessity to write CCCD values.

It's yet to get determined whether it's the chip or the device firmware
which requires MTU exchange. The default value in the 400 range (near
the absolute maximum MTU for BLE communication) is rather arbitrary a
choice, needs reconsideration in the future. Users always can override
as desired.

serial_bt: add generic conn=bt/notify/<addr> "chip type"

Add support for the rather generic 'notify' Bluetooth "chip type". This
avoids the necessity to come up with chip names for yet unsupported or
unknown BLE modules. Might be less confusing for users. All RX/TX/CCCD
handles must be provided by users.

serial_bt, bluez: support MTU exchange in BLE reception

The central must respond to peripherals' requests to exchange the MTU
value. If it doesn't then the connection terminates. The central has no
choice whether this exchange happens or when it does, applicability is
the consequence of using a specific device (a firmware implementation).
This was first observed with RDTech TC66C energy meters.

Add support for the mtu= parameter in conn=bt/ specifications. A good
default value is yet to get determined. The connection type or the chip
in use are insufficient conditions AFAICT. Currently it is assumed that
users specify the central's MTU when their device firmware requires the
exchange.

Use the "warning" severity for the diagnostics message when peripherals
request MTU exchange while the central won't respond (due to lack of a
value to respond with).

serial_bt, bluez: rework diag in BLE reception, accept zero length data

Rework how the sr_bt_check_notify() routine processes messages that were
received from a Bluetooth socket. Comment on edge cases that we have yet
to see how they are handled. Extend the amount of details that are given
in diagnostics messages, and tune their verbosity level. The debug level
nicely illustrates how data flows, the spew level makes bytes available.

Consider zero length data chunks in receive code paths non-fatal. Accept
either NULL or non-NULL addresses when the length is zero. A NULL pointer
in combination with a non-zero length is considered fatal though.

tests: cover length checking incrementing endianess readers

libsigrok-internal.h: add length checking endianess helpers

Introduce the read_u8_inc_len() and read_u16le_inc_len() routines which
read the respective numbers from binary input, advance the current read
position, and also track the remaining length of input data. Call sites
need not duplicate the data field width they advanced over.

The input stream is considered exhausted when there is insufficient data
to read another field. All subsequent reads will also terminate. Calling
applications need to check before reading when they expect specific sets
of adjacent fields to be available. It is assumed that most call sites
already do this (once for the whole input stream, not individually for
each conversion call of a field).

strutil: add more space in hexdumps after 8 and 16 data bytes

The previous implementation just had one space between bytes. Which
quickly becomes hard to read for longer runs. Add more spaces after
8 and 16 bytes each for improved readability.

log: accept when applications void the log callback

Common support code in the libsigrok library passes all output through
an application specified log callback, while a default callback exists
which writes to stdout and stderr.

Accept when no callback at all is registered. Don't output text in that
case, succeed silently.

log: rephrase default sr_logv() routine, strip CR and LF

Unobfuscate how the unconditional prefix and the conditional timestamp
will prefix the caller's message. Separate the result check for emission
of the prefix/timestamp from the check for successful construction of
the caller's message text. Release the dynamic buffer in the error path.
Use pointers and character variables in the copy loop for readability.

Strip LF as well as CR from the resulting log output text. The previous
implementation exclusively stripped LF. Escaping non-printables is not
attempted in this version.

fluke-dmm: sort models by numbers, no behaviour change

As the list of supported models grows, let's keep their declaration and
processing in numerical order of their model name. This is a mechanical
adjustment, no change in behaviour.

fluke-dmm: reduce indentation in 18x/190/28x dispatch logic

Address several style nits in the fluke-dmm driver. Rephrase a lengthy
if-else-if sequence by means of switch-case, so that conditions are
easier to review. Use glib to get the vector length. Handle the trivial
case first, which reduces indentation for the remaining complex logic.
Fixup comment style, break long text lines.

fluke-dmm: Add support for Fluke 87/89 DMMs.

fluke-dmm: Extract digit count from response.

The DMMs kindly formats its responses with the proper number of digits.
Extract and use this value instead, to not use an arbitrary digit count.

[ gsi: apply the same logic to Fluke 190 ]

fluke-dmm: Do not consider 0.0 value an invalid measurement.

(Issue seems an oversight from commit 357e341)

configure.ac: put spaces around version operators in pkg-config requires

Putting a library name and its version as one bare word on the Requires:
line without spaces around the operators makes application builds fail
because the library isn't found. This amends commit b0b139d914b9.

configure.ac: glibmm check, add quotes to version string

Add quotes where glibmm version requirements are concatenated while the
strings contain ">=" relational operators. Avoid processing incomplete
text, and the creation of undesired files in the build output. Amends
commit ee9e086f1d6c.

Makefile.am: register more minilzo files with automake

The libsigrok project embeds a small minilzo distribution. List header
files next to their source files. And list all other files as extras.
Makes distributions complete again. Amends commit b9cd0c6a53a6.

serial_bt: add support for JL AC6328 chips (RFCOMM and BLE)

Add support for the JL AC6328B chip which happens to communicate both
RFCOMM (traditional Bluetooth) as well as BLE.

Support was tested with ATORCH USB loads and meters. Add a few product
names so that scans can list the "cable" when detected. Suggest to users
(as part of scan result output) that RFCOMM channel 2 is needed which is
not the default number.

rdtech-tc: send analog values in frames not samples

The RDTech TC energy meter provides six analog channels, the values of
which are taken at the same time from one consistent raw data image.
Send these values in frames, so applications can tell they are related.

This drops support for --samples specifications. And allows to read back
previously specified time limits.

Tested by means of:
  $ sigrok-cli -d rdtech-tc:conn=/dev/ttyACM0 --show
  $ sigrok-cli -d rdtech-tc:conn=/dev/ttyACM0 --frames 5

rdtech-um: send analog values in frames not samples

The RDTech UM energy meter provides six analog channels, the values of
which are taken at the same time from one consistent raw data image.
Send these values in frames, so applications can tell they are related.

This drops support for --samples specifications. And allows to read back
previously specified time limits.

Tested by means of:
  $ sigrok-cli -d rdtech-um:conn=bt/rfcomm/$MAC --show
  $ sigrok-cli -d rdtech-um:conn=bt/rfcomm/$MAC --frames 4

binary helper: drop analog channel support (submit samples to feed)

Remove the bv_send_analog_channel() routine and its data types. All
callers have migrated to the common feed queue API. Extracting numbers
from raw binary images remains the only use case for binary helpers.

Prefer read_u8() et al endianess aware readers over R8() preprocessor
macros. Reduce indentation in the switch() cases according to style.
Accept scale factor 0 to mean no scaling in addition to factor 1.
Update comments to avoid the redundant "binary blob" phrase.

rdtech-tc: migrate to feed queue helper

Implement the submission of analog data to the sigrok session by means
of the common feed queue logic. Use the feed queue's scaling support.
Implement a .dev_clear() routine which releases resources.

This exlusively leaves the extraction of numbers from binary data as
the only remaining use case for the binary helpers logic.

rdtech-tc: grab receive data in larger chunks

The previous implementation used to read each of the 192 bytes in
individual calls into the serial layer. This implementation grabs
receive data in larger chunks, and accepts data to be in flight
between main loop callbacks.

USB CDC appears to reliably deliver 64 byte chunks (unsurprisingly).
BLE communication is yet to get tested, isn't operational with current
mainline BT support because MTU exchange is not implemented.

(Re-)synchronization to the stream of packets after hiccups remains
an option which this implementation does not provide, neither did
the previous implementation.

rdtech-tc: rephrase probe/write timeout and poll interval for text length

Rename identifiers, break long text lines in the handling of probe and
write/read timeouts as well as the request transmission intervals.

rdtech-tc: detect receive and parse errors, terminate acquisition

Pepper the code paths from main loop calls via serial reception to
data processing with return code checks and error handling. Terminate
acquisition when communication or data processing fail.

Check whether acquisition limits were reached immediately after more
values were submitted. Keep a periodic check in the main loop call to
handle duration limits.

Comment on essential steps in the execution sequence.

rdtech-tc: concentrate request transmit handling in one spot

Move all "command sent at ..." calculation and update in a single spot
for improved awareness during development. Allow acquisition start to
force the transmission of the measurement request.

rdtech-tc: avoid mixing several iterations in the same for loop

Separate the iteration of a channels list, and indexing their associated
binary helpers descriptions. Use the for() statement for list iteration
exclusively, avoid the comma operator.

rdtech-tc: use size_t for memory sizes and indices

rdtech-tc: use common code to scan conn= and serialcomm= specs

rdtech-tc: eliminate redundant type info in malloc call

Allocate whatever it takes to hold the variable. Don't open code the
type information again when inconsistency would go unnoticed.

Link devc earlier to sdi, ideally immediately after allocation.

rdtech-tc: move assignments out of declarations

Separate the declaration of variables from their manipulation. Keep
initial assignments and subsequent updates and evaluation of results
in closer proximity.

Group related instructions while we are here, avoid scatter. Break
long lines, and add braces around complex multi-line statements.

rdtech-tc: rephrase PAC consistency check, discuss sample data layout

Rephrase access to the PAC chunks and the consistency check of the total
192 bytes data image in terms of one 64 bytes unit. Which eliminates
other magic numbers. Add a comment for awareness during development.

Prefer read_u32le() endianess conversion helpers for reliability. Use
big endian readers for four-character-codes to increase readability.
Address style nits in the process: Use booleans for checksum and
consistency checks. Eliminate else after return. Consolidate error
messages. Prefer indexing an array over pointer arithmetics. Group
related instructions in the same block.

rdtech-tc: use literal string for poll command instead of array

Use a char pointer for the poll command which is a string literal. Which
eliminates the "necessity" to strip the NUL terminator from an array
after its construction. The strlen() for literals also gets resolved at
compile time. Which means that execution cost remains identical.

Rename the variable to lower case, it's not a preprocessor symbol.

rdtech-tc: eliminate excessive indentation, address whitespace issues

[ see a whitespace ignoring diff for review ]

rdtech-tc: alpha-sort and group include directives

rdtech-um: migrate from binary helper channel to feed queue

Use common feed queue support for the submission of analog values to the
sigrok session. This leaves the extraction of the value from binary data
images with a factor of 1 for binary helpers, but uses existing code to
scale the value (which operates at higher accuracy) and to submit values
to the sigrok session.

It's up to debate whether a scaling factor value of { 10, 1000, } can be
recognized as 10mV by readers, and how this phrase relates to the other
spec of 2 significant digits. Might be acceptable. Offsetting and MQ flags
are not used by this driver. The exponent representation was used in the
channels table because some models support 100uA resolution for current.
Engineering exponents are preferred for readability (rationals are not
"normalized" to scientific presentation with "odd" exponent values).

Register a device clear routine so that the driver releases resources
that were allocated during scan and device instance creation.

rdtech-um: rework serial reception and processing, including re-sync

The previous implementation was expensive on the serial transport and
kept calling into this layer for individual bytes, to simplify the logic
which synchronized to the packetized input stream. And it used to block
in main loop calls until reception of a packet completes, which could
take some 200ms in the RFCOMM setup, and not much less for USB CDC.

Rework the call chain from main loop receive callbacks to processing
packets. Grab receive data in large chunks from the serial layer. Try
to rate limit the synchronization to the packet stream and associated
diagnostics messages. Process more return values and stop acquisition
upon errors. Move the checksum test to the packet content processor.
Check acquisition limits in the spot which just submitted more data
(keep another check in the periodic callback to handle time limits).
Strive for fast yet rate limited transmission of periodic measurement
requests, to initiate the reception of more sample values.

Shorten more lines (and avoid continuations and line breaks) by renaming
routines and variables. Pass packet content references such that content
handlers need not know about reception details, and reception can chunk
data differently in future versions.

This implementation became rather complex, most of all because of UI
concerns and robustness, as well as potential for future extension of
the scope of these code paths. The loss of synchronization and slow
reception of packets in chunks in combination with periodic request
transmission based on intervals results in "interesting" behaviour.
Maybe something simpler is desirable which is more expensive to run
but easier to maintain and reason about?

rdtech-um: rephrase channel count in profile description

Use ARRAY_AND_SIZE() instead of the ALL_ZERO terminator for the list
of channels in a model's profile. This improves iteration readability,
avoids off-by-one issues, eliminates "empty slot?" checks in numerical
iteration over indices. Rename channel list identifiers to reduce the
text line length in the source code.

rdtech-um: adjust read/write timeout style for text line length

Avoid the combination of function calls and the evaluation of their
return values for flow control in the same statement. Which improves
readability during maintenance. Rename identifiers to keep text line
lengths within style constraints.

Comment on non-trivial global parameters, and essential periodic jobs
in the main loop callback while we are here.

rdtech-um: data type nits, common expressions, for loop iteration

Address several style nits: Use size types where appropriate. Avoid
repeated complex expressions in the profile lookup. Don't mix different
types of iterations in a for() loop (traversal of a channels list, and
indexing the channels' blob access details). Rename a generic identifier
in the probe routine.

rdtech-um: tone down and extend diagnostics messages

Reflect tested conditions in diagnostics messages, and tell more
conditions apart where possible. Take the user's perspective in these
messages.

Address programming style while we are here: Prefer read_u16be() over
RB16() for robustness. Use intermediate variables to avoid repeated
converter calls. Transparently advance over the received data length
(the read size and the separated increment had no perceivable relation
in the source code).

rdtech-um: use common helper to parse conn= and serialcomm= specs

Use the common sr_serial_extract_options() helper when conn= specs
are mandatory (and serialcomm= remains optional).

rdtech-um: eliminate redundant data types in memory allocation

Just allocate the size of the involved variable. Eliminate redundant
data type specs where inconsistency would go unnoticed.

Link the device context earlier to the device instance while we are
here. Immediately after allocation of the dynamic memory so that the
relation remains obvious.

rdtech-um: concentrate poll period handling in one spot

The handling of "command sent at ..." and the emission of periodic poll
requests is non-trivial, and was scattered around different locations.
Concentrate all of the time scaling and delta calculation and updating
internal state into a single spot, and allow callers to force the first
emission when desired (acquisition start needs this). Which eliminates
repeated calls into the microseconds getter.

Not advancing the last checkpoint, and keep sending requests until
successful transmission, remains identical to the previous version of
the implementation. In practise transmit errors are rare.

rdtech-um: rephrase checksum verification routines

Rename the unfortunately named poll_csum() callback. It neither polled
for receive data nor calculated checksums for the caller. It verifies
that a received packet's checksum is plausible, and returns a boolean.

Address coding style nits in the process. Adjust data types. Use size
types where appropriate. Don't use characters when bytes are meant. Use
booleans for the checksum test result. Shorten identifier names to trim
text line length. No need to "take the address" of a routine. Remove
dead code, model dependent checksum approaches are handled by registered
callbacks in profiles. Eliminate else after return. Prefer read_u16be()
endianess routines over RB16() preprocessor macros. Prefer lower case
hex digits. Make the code reflect that the last 16bit or 8bit entity in
the received data packet gets checked. Use "calc" and "recv" names for
awareness which variable holds which value.

rdtech-um: style nits, move assignment out of declaration blocks

Move initial assigment, subsequent updates, and checks of resulting
variable content closer to each other. Don't hide code in declaration
blocks. Eliminate redundant assignments that don't take effect, yet
can hide programming errors. Increases awareness during maintenance.

rdtech-um: alpha-sort and group include directives

Put <config.h> first. Then system headers. Then application headers.

rdtech-um: address style nits (whitespace, braces)

Eliminate excessive indentation and other whitespace nits. Alignment of
tables wasn't working anyway. Put braces around complex statements that
span multiple lines, or trim line length differently where appropriate.

rdtech-um: increase digits count for models with higher resolution

The table of UM25C channels differs from other models. The V and I
channels provide a higher resolution, their scaling factors differ.
Update the number of significant digits, too, which went unnoticed.

serial_bt: move lookup code next to database of known device names

Move the scan_is_supported() routine close to the scan_supported_items[]
table which is traverses. Comment on the database's motivation, and its
current capabilities. This will be helpful should the table need to move
to a separate source file as the database grows over time.

serial_bt: prepare support for additional params in scan results

The scan_supported_items[] table contains a list of known device names,
and connection types that are used to communicate to them. Prepare the
presentation of more parameters in scan results when a device is known
to require these.

serial_bt: increase scan duration for BT/BLE connections

Some devices are slow to respond to scans. Increase the scan duration
from 2s to 3s. Tested with RDTech UM25C. Should be acceptable when a
manual scan takes some 6 seconds (BT and BLE) instead of 4.

serial_bt: add UM25C to list of known device names

Register that RFCOMM can be used when the device name is UM25C.

serial_bt: update comments on conn=bt/... parameters

Commit 0e4a85a9254c added support for parameters that follow the BT/BLE
remote address in conn= specs. Update developer comments near the parse
routine.

feed queue: add scale/offset support, rename MQ/unit routine

Use the scale and offset support for analog measurement values which is
part of the existing sr_analog_encoding API. Rename the routine which
configures MQ and unit before submission of analog data.

This drops local redundant scaling support. And brings feed queue on par
with the binary helpers implementation.

feed queue: unbreak MQ and unit support in analog feeds

Unbreak the compilation of the feed queue. The error was introduced
in commit 43e6f7a7798f which added MQ and unit support.

feed queue: add scaling, MQ and unit to analog feed submission

Allow for the analog data to scale during submission, and pass caller
specified MQ including flags and units to the sigrok session. Using
these specs is optional, default behaviour is backwards compatible.
Accumulated data gets flushed before the configuration changes. This
allows the migration of binary helper using drivers to feed queue.

binary helpers: touch up Doxygen comments (in/out params, clutter)

Provide 'in' and 'out' directions for function parameters. Unclutter
struct declarations by putting comments after their fields. Eliminate
redundant "binary blob" phrases.

binary helpers: address minor style nits, break long text lines

Break long text lines in source code files, and break them in more
appropriate locations (keep groups of related function parameters).

udev: add Siglent SDM3055 USB identification rule

Add the USB identification for the Siglent SDM3055 multimeter and the
SDS1104X-E scope.

scpi-dmm: add support for Siglent SDM3055

scpi: add Siglent to the vendor alias list

README.devices: document conn=bt/ extensions for more optional parameters

The conn=bt/ syntax grew support for optional additional parameters. Add
them to the README.devices page for awareness.

serial_bt: support more key=value parameters for conn=bt/ specs

Extend the syntax for conn=bt/ specs. Accept RFCOMM channel numbers, as
well as BLE handles for RX, TX, and CCCD, as well as a CCCD value. This
allows users to unbreak their "cables" without necessity of adjusting
source code.

korad-kaxxxxp: add quirk for long processing times of commands

Some Korad compatibles are said to take rather long a time between
reception of adjacent commands. It's not just that the response is
delayed, or that execution takes a long time. It's worse in that the
next request isn't received, and later responses don't correspond
to the requests which host software associates them with. A driver
implementation detail then "reads" 0.000 current values when the
PSU failed to respond to the "IOUT?" request.

Add a quirk flag. Allow for extra processing time after SET commands
and the GET command for STATUS. Add the Velleman PS3005D V1.3 model
with this quirk. Behaviour does not change for other devices.

This implementation is based on a submission that was provided by
Pilatomic <redacted>.

korad-kaxxxxp: eliminate excessive whitespace in continued signatures

Continuation lines in routine signatures should be indented by one TAB
(which is sufficient) or two (which is luxury). Four TABs is excessive,
and does not improve readability. Eliminate the excess whitespace.

korad-kaxxxxp: address style nits, redundant data type in malloc

Rephrase malloc calls, eliminate a redundant yet unnecessary data type
duplication. Just get how much space the variable happens to require.

korad-kaxxxxp: tweak first "give time to process" invocation

The give_device_time_to_process() routine unconditionally calculated
with a "time since last command transmission" value which may not have
been assigned to in the first invocation of a getter or setter.

Just don't sleep at all when nothing was sent before. Avoids a
dependency on implementation details of signed integer math.