#ifdef HAVE_SERIAL_COMM
-/* See if a (assumed opened) serial port is of any supported type. */
+/* See if an (assumed opened) serial port is of any supported type. */
static int dev_is_supported(struct sr_serial_dev_inst *serial)
{
- if (!serial)
- return 0;
- if (!serial->lib_funcs)
+ if (!serial || !serial->lib_funcs)
return 0;
return 1;
* via UART can get stored in a GString (which is a char array). Since
* the API hides this detail, we can address this issue later when needed.
* Callers use the API which communicates bytes.
+ *
+ * Applications optionally can register a "per RX chunk" callback, when
+ * they depend on the frame boundaries of the respective physical layer.
+ * Most callers just want the stream of RX data, and can use the buffer.
+ *
+ * The availability of RX chunks to callbacks, as well as the capability
+ * to pass on exact frames as chunks or potential re-assembly of chunks
+ * to a single data block, depend on each transport's implementation.
*/
+/**
+ * Register application callback for RX data chunks.
+ *
+ * @param[in] serial Previously initialized serial port instance.
+ * @param[in] cb Routine to call as RX data becomes available.
+ * @param[in] cb_data User data to pass to the callback in addition to RX data.
+ *
+ * @retval SR_ERR_ARG Invalid parameters.
+ * @retval SR_OK Successful registration.
+ *
+ * Callbacks get unregistered by specifying NULL for the 'cb' parameter.
+ *
+ * @private
+ */
+SR_PRIV int serial_set_read_chunk_cb(struct sr_serial_dev_inst *serial,
+ serial_rx_chunk_callback cb, void *cb_data)
+{
+ if (!serial)
+ return SR_ERR_ARG;
+
+ serial->rx_chunk_cb_func = cb;
+ serial->rx_chunk_cb_data = cb_data;
+
+ return SR_OK;
+}
+
/**
* Discard previously queued RX data. Internal to the serial subsystem,
* coordination between common and transport specific support code.
*
* @param[in] serial Previously opened serial port instance.
*
- * @internal
+ * @private
*/
SR_PRIV void sr_ser_discard_queued_data(struct sr_serial_dev_inst *serial)
{
- if (!serial)
- return;
- if (!serial->rcv_buffer)
+ if (!serial || !serial->rcv_buffer)
return;
g_string_truncate(serial->rcv_buffer, 0);
*
* @param[in] serial Previously opened serial port instance.
*
- * @internal
+ * @private
*/
SR_PRIV size_t sr_ser_has_queued_data(struct sr_serial_dev_inst *serial)
{
- if (!serial)
- return 0;
- if (!serial->rcv_buffer)
+ if (!serial || !serial->rcv_buffer)
return 0;
return serial->rcv_buffer->len;
* @param[in] data Pointer to data bytes to queue.
* @param[in] len Number of data bytes to queue.
*
- * @internal
+ * @private
*/
SR_PRIV void sr_ser_queue_rx_data(struct sr_serial_dev_inst *serial,
const uint8_t *data, size_t len)
{
- if (!serial)
- return;
- if (!data || !len)
+ if (!serial || !data || !len)
return;
- if (serial->rcv_buffer)
+ if (serial->rx_chunk_cb_func)
+ serial->rx_chunk_cb_func(serial, serial->rx_chunk_cb_data, data, len);
+ else if (serial->rcv_buffer)
g_string_append_len(serial->rcv_buffer, (const gchar *)data, len);
}
* @param[out] data Pointer to store retrieved data bytes into.
* @param[in] len Number of data bytes to retrieve.
*
- * @internal
+ * @private
*/
SR_PRIV size_t sr_ser_unqueue_rx_data(struct sr_serial_dev_inst *serial,
uint8_t *data, size_t len)
size_t qlen;
GString *buf;
- if (!serial)
- return 0;
- if (!data || !len)
+ if (!serial || !data || !len)
return 0;
qlen = sr_ser_has_queued_data(serial);
*
* Returns 0 if no receive data is available, or if the amount of
* available receive data cannot get determined.
+ *
+ * @private
*/
SR_PRIV size_t serial_has_receive_data(struct sr_serial_dev_inst *serial)
{
* @param is_valid Callback that assesses whether the packet is valid or not.
* @param[in] timeout_ms The timeout after which, if no packet is detected, to
* abort scanning.
- * @param[in] baudrate The baudrate of the serial port. This parameter is not
- * critical, but it helps fine tune the serial port polling
- * delay.
*
* @retval SR_OK Valid packet was found within the given timeout.
* @retval SR_ERR Failure.
uint8_t *buf, size_t *buflen,
size_t packet_size,
packet_valid_callback is_valid,
- uint64_t timeout_ms, int baudrate)
+ uint64_t timeout_ms)
{
uint64_t start, time, byte_delay_us;
size_t ibuf, i, maxlen;
maxlen = *buflen;
- sr_dbg("Detecting packets on %s (timeout = %" PRIu64
- "ms, baudrate = %d).", serial->port, timeout_ms, baudrate);
+ sr_dbg("Detecting packets on %s (timeout = %" PRIu64 "ms).",
+ serial->port, timeout_ms);
- if (maxlen < (packet_size / 2) ) {
+ if (maxlen < (packet_size * 2) ) {
sr_err("Buffer size must be at least twice the packet size.");
return SR_ERR;
}
/* Assume 8n1 transmission. That is 10 bits for every byte. */
- byte_delay_us = 10 * ((1000 * 1000) / baudrate);
+ byte_delay_us = serial_timeout(serial, 1) * 1000;
start = g_get_monotonic_time();
i = ibuf = len = 0;
/** @private */
SR_PRIV int serial_timeout(struct sr_serial_dev_inst *port, int num_bytes)
{
- int bits, baud;
- int ret;
- int timeout_ms;
+ int bits, baud, ret, timeout_ms;
/* Get the bitrate and frame length. */
bits = baud = 0;
projects / libsigrok.git / blobdiff