Hacktoberfest 2026: los issues que los mantenedores marcaron para octubre, abiertos y aptos para principiantes. Explorar issues de Hacktoberfest

proposal: rework timeouts, StreamDevices and DatagramDevices

Abierto
  • ¿Algo no está bien?
#701 3 comentarios 0 reacciones 0 asignados Ver en GitHub

Los mantenedores suelen responder en 1 día

Nadie ha tomado este issue todavía.

Evaluación

Dificultad
5/5
Tiempo estimado
Más de una semana
Aptitud para principiantes
8/100
Tipo de issue
Refactorización
Claridad
Necesita aclaración
Estado de actividad
Estancado
Área
embedded-iot

Línea de trabajo

This is a design proposal, not a patch: it asks whether the StreamDevice and DatagramDevices interfaces should be merged, with read/write treating timeouts as non-errors and read_all/write_all treating them as errors. Start by reading the three comments to see whether maintainers reached a decision, and check the interface definitions the issue refers to. Done means a maintainer-agreed interface design, which should come before any code.

Escrito por el modelo de indexación a partir del texto del issue.

Descripción

driver framework

Summary:

  • Change the default timeout behavior in protocols that behave like streams

  • Analyze ambiguity between the current Datagram and StreamDevices interfaces

  • Extra case: Analyze the use case of drivers exposing generic interfaces

How a timeout can turn a stream into a datagram

A stream represents a communication channel with no predefined size.
Because of this, a timeout should not be treated as an error by default — it’s expected that a device might not send an entire buffer at once, or that a receiver might not always have enough incoming data to fill its read buffer.

However, the way we currently handle timeouts in most UART HALs treats a timeout as a failed transmission of a fixed-size buffer in single transaction, effectively turning the stream into a datagram-like operation.

This raises an interesting question:

Is UART really a StreamDevice?

Streams often use UART as their canonical example, since UART is a very common way to perform raw communication between two controllers.
But thinking more deeply — what prevents a fixed-size protocol from using UART?
Nothing. It’s perfectly valid (even if less common in some designs) to implement length-defined packet protocols over UART.

That means StreamDevice has an edge case where it behaves like a datagram.
But then, what are the edge cases for Datagram?

Is a datagram also a kind of stream?

By analogy, datagram interfaces are typically represented by I2C or SPI, which are usually used for fixed-size packet transfers.
And that’s true — to some extent.

These buses are very common in simple modules where communication rules are rigidly defined, and a write timeout or failed full transfer is indeed an error.

But both I2C and SPI can also be used in a stream-like context, especially SPI, which is often used for raw controller-to-controller communication (similar to USART).

I2C as a special case:

In a host → device transaction, the device can send a NACK to indicate it no longer wants to receive data — this is valid behavior.

In a device → host transaction, the specification requires the device to send 0xFF if it has no more data to transmit; This means that a reader with an arbitrary buffer length does not generate an error, which is problematic for streams: here, 0xFF is ambiguous, as it could be either valid data or a placeholder.

Despite this, REPEATED START, makes it much closer to stream-like behavior over a datagram, And there are also cases of
some I2C modules — especially those that also support SPI — to typically provide a burst read/write function, allowing the host to read or write N bytes sequentially (as long as a certain limit is not exceeded), edge-case of stream-like behavior on I2C.

So, even protocols usually treated as datagram-based have situations where they behave like streams.

In other words:

Anything that can be a stream can also behave like a datagram —
but not everything that’s a datagram can behave like a stream.

Why separate them, then?

If the distinction between stream and datagram depends mostly on how timeouts and buffer sizes are handled, we might not need two separate interfaces at all.

By defining methods like read_all and write_all, we can express both behaviors cleanly:

  • write/read — Timeout, NACK or any EOF is not an error → behaves like a stream
  • write_all/read_all — Timeout, NACK or any early EOF is an error → behaves like a datagram
Lenguaje dominante
Zig
Estrellas
2.3k
Forks
198
Merge medio
1 d 8 h
PR fusionados (30 d)
37

Preparar el entorno

Este proyecto no incluye contenedor de desarrollo, Dockerfile ni guía de contribución, así que la configuración corre por tu cuenta: empieza por su README y consulta nuestra guía para la primera contribución para los pasos generales.

Primeros pasos

  1. Lee el issue completo y luego la guía de contribución del proyecto.
  2. Comenta en el issue que vas a ocuparte — evita que dos personas hagan lo mismo.
  3. Haz un fork del repositorio y trabaja en una rama.
  4. Abre un pull request que haga referencia al número del issue.

Más de ZigEmbeddedGroup/microzig

Todos los issues de ZigEmbeddedGroup/microzig

Issues similares

Más issues de Embedded & IoT

Recibe los nuevos issues en tu correo

Un resumen breve de issues de GitHub para principiantes.