Wildcard or Mask for Header Check Definition

Oct 13, 2025 by wbrum.org 26 views

Introduction

In the world of serial communication, reading data from a device can be a complex task. The current implementation of the read operation in our component terminates when either a footer match, a CRC (Cyclic Redundancy Check) match, or a time out occurs. However, an additional method that would be helpful is based on a value within the data read back. This feature request proposes an option to use a length of data byte in data to terminate the read operation.

Current Implementation

At the moment, the read operation in our component is terminated when one of the following conditions is met:

A footer match is detected
A CRC match is detected
A time out occurs

While these conditions are common and effective, there are scenarios where a more flexible approach is required. This is where the proposed feature comes into play.

Proposed Feature

The proposed feature allows the user to specify a byte within the data read back that indicates the length of the data, including the CRC byte. This approach is quite common in serial communication protocols, where the length of the data is embedded within the data itself.

Example Use Case

Let's consider an example where the data block has the following structure:

CAFD062F900166000000000000000001230123012A018501850185000001070C012415361F02BB0000500000308058 (47 bytes)

In this example, the data block has the following structure:

Byte 1: Constant start byte - Header 1
Byte 2: Constant start byte - Header 2
Byte 3: Address of device returning data - Header 3
Byte 4: Length of data including header and CRC byte - not part of header
Byte 5: ACK of command used to produce data - Header 4
... data ...
Byte 47: CRC

The proposed feature would allow the user to specify the byte that indicates the length of the data, which in this case is byte 4.

Configuration Option

To enable this feature, a new configuration option would be added to the uartex component:

uartex:
  rx_length_at: 4

This option specifies that the length of the data is indicated by the value in byte 4.

Wildcard or Mask for Header Check Definition

Another issue raised with this data block is that the header is not continuous. To address this, a wildcard or mask for the header check definition would be helpful. This would allow the user to specify a pattern for the header, rather than a fixed value.

Example Use Case

Let's consider an example where the data block has the following structure:

CAFD062F900166000000000000000001230123012A018501850185000001070C012415361F02BB0000500000308058 (47 bytes)

In this example, the data block has the following structure:

Byte 1: Constant start byte - Header 1
Byte 2: Constant start byte - Header 2
Byte 3: Address of device returning data - Header 3
Byte 4: Length of data including header and CRC byte - not part of header
Byte 5: ACK of command used to produce data - Header 4
... data ...
Byte 47: CRC

To specify a wildcard or mask for the header check definition, the user could use the following configuration option:

uartex:
  rx_header: [0xCA, 0xFD, 0x06, 0x2F, 0x90]
  rx_header_mask: [0xFF, 0xFF, 0xFF, 0x00, 0xFF]

This option specifies that the header should match the pattern [0xCA, 0xFD, 0x06, 0x2F, 0x90], with a mask of [0xFF, 0xFF, 0xFF, 0x00, 0xFF].

Conclusion

In conclusion, the proposed feature would provide a more flexible approach to reading data from a device, allowing the user to specify a length of data byte in data to terminate the read operation. Additionally, the wildcard or mask for the header check definition would provide a more robust way to handle non-continuous headers. With this feature, our component would become even more useful for serial communication tasks.

Benefits

The proposed feature would provide the following benefits:

More flexible approach to reading data from a device
Ability to specify a length of data byte in data to terminate the read operation
Robust way to handle non-continuous headers
Improved usability and ease of use

Future Work

Future work on this feature could include:

Implementing the proposed feature in the uartex component
Testing and validating the feature to ensure it works as expected
Documenting the feature and its usage in the component's documentation

Introduction

In our previous article, we discussed a feature request to add an option to use a length of data byte in data to terminate the read operation in our component. This feature would provide a more flexible approach to reading data from a device, allowing the user to specify a length of data byte in data to terminate the read operation. In this article, we will answer some frequently asked questions (FAQs) about this feature.

Q: What is the purpose of this feature?

A: The purpose of this feature is to provide a more flexible approach to reading data from a device. Currently, the read operation is terminated when either a footer match, a CRC match, or a time out occurs. However, in some cases, it would be more convenient to specify a length of data byte in data to terminate the read operation.

Q: How does this feature work?

A: This feature works by allowing the user to specify a byte within the data read back that indicates the length of the data, including the CRC byte. The user can specify this byte using the rx_length_at configuration option.

Q: What is the `rx_length_at` configuration option?

A: The rx_length_at configuration option is a new option that will be added to the uartex component. This option specifies the byte within the data read back that indicates the length of the data, including the CRC byte.

Q: How do I use the `rx_length_at` configuration option?

A: To use the rx_length_at configuration option, you will need to add the following line to your configuration file:

uartex:
  rx_length_at: 4

In this example, the rx_length_at option is set to 4, which means that the length of the data is indicated by the value in byte 4.

Q: What if the header is not continuous?

A: If the header is not continuous, you can use a wildcard or mask for the header check definition. This will allow you to specify a pattern for the header, rather than a fixed value.

Q: How do I use a wildcard or mask for the header check definition?

A: To use a wildcard or mask for the header check definition, you will need to add the following lines to your configuration file:

uartex:
  rx_header: [0xCA, 0xFD, 0x06, 0x2F, 0x90]
  rx_header_mask: [0xFF, 0xFF, 0xFF, 0x00, 0xFF]

In this example, the rx_header option specifies the pattern for the header, and the rx_header_mask option specifies the mask for the header.

Q: What are the benefits of this feature?

A: The benefits of this feature include:

More flexible approach to reading data from a device
Ability to specify a length of data byte in data to terminate the read operation
Robust way to handle non-continuous headers
Improved usability and ease of use

Q: What is the future work on this feature?

A: Future work on this feature could include:

Implementing the proposed feature in the uartex component
Testing and validating the feature to ensure it works as expected
Documenting the feature and its usage in the component's documentation

By implementing this feature, we can make our component even more useful and effective for serial communication tasks.

Conclusion

In conclusion, the feature request to add an option to use a length of data byte in data to terminate the read operation in our component is a valuable addition to our component. This feature will provide a more flexible approach to reading data from a device, allowing the user to specify a length of data byte in data to terminate the read operation. We hope that this feature will be useful to our users and will make our component even more effective for serial communication tasks.