feat: add tactile codec
This commit is contained in:
49
components/ffmsep/tactile/tacdec.h
Normal file
49
components/ffmsep/tactile/tacdec.h
Normal file
@@ -0,0 +1,49 @@
|
||||
//
|
||||
// High level helpers for the tactile sensor binary protocol.
|
||||
//
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "../cpdecoder.hh"
|
||||
|
||||
#include <cstdint>
|
||||
#include <optional>
|
||||
#include <vector>
|
||||
|
||||
namespace ffmsep::tactile {
|
||||
|
||||
inline constexpr std::uint8_t kStartByte = 0x3A;
|
||||
inline constexpr std::uint8_t kEndByteFirst = 0x0D;
|
||||
inline constexpr std::uint8_t kEndByteSecond = 0x0A;
|
||||
|
||||
enum class FunctionCode : std::uint8_t {
|
||||
Unknown = 0x00,
|
||||
ReadMatrix = 0x01,
|
||||
ReadSingle = 0x02,
|
||||
ReadTemperature = 0x03,
|
||||
SetDeviceId = 0x51,
|
||||
SetMatrixSize = 0x52,
|
||||
CalibrationMode = 0x53
|
||||
};
|
||||
|
||||
struct MatrixSize {
|
||||
std::uint8_t long_edge = 0;
|
||||
std::uint8_t short_edge = 0;
|
||||
};
|
||||
|
||||
struct TactileFrame {
|
||||
std::uint8_t device_address = 0;
|
||||
FunctionCode function = FunctionCode::Unknown;
|
||||
std::uint8_t data_length = 0;
|
||||
std::vector<std::uint8_t> payload;
|
||||
};
|
||||
|
||||
std::optional<TactileFrame> parse_frame(const CPFrame& frame);
|
||||
std::vector<std::uint16_t> parse_pressure_values(const TactileFrame& frame);
|
||||
std::optional<MatrixSize> parse_matrix_size_payload(const TactileFrame& frame);
|
||||
std::optional<MatrixSize> parse_matrix_coordinate_payload(const TactileFrame& frame);
|
||||
|
||||
const CPCodec* tactile_codec();
|
||||
void register_tactile_codec();
|
||||
|
||||
} // namespace ffmsep::tactile
|
||||
286
components/ffmsep/tactile/tecdec.cc
Normal file
286
components/ffmsep/tactile/tecdec.cc
Normal file
@@ -0,0 +1,286 @@
|
||||
//
|
||||
// Decoder for the tactile sensor framed binary protocol.
|
||||
//
|
||||
|
||||
#include "tacdec.h"
|
||||
|
||||
#include <algorithm>
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
#include <new>
|
||||
|
||||
namespace ffmsep::tactile {
|
||||
|
||||
namespace {
|
||||
|
||||
constexpr std::size_t kMinimumFrameSize = 1 // start
|
||||
+ 1 // address
|
||||
+ 1 // function
|
||||
+ 1 // length
|
||||
+ 0 // payload
|
||||
+ 2 // CRC
|
||||
+ 2; // end markers
|
||||
|
||||
constexpr std::uint16_t kCrcInitial = 0xFFFF;
|
||||
constexpr std::uint16_t kCrcPolynomial = 0xA001; // CRC-16/MODBUS (LSB first)
|
||||
|
||||
struct TactileDecoderContext {
|
||||
std::vector<std::uint8_t> fifo;
|
||||
bool end_of_stream = false;
|
||||
std::int64_t next_pts = 0;
|
||||
};
|
||||
|
||||
std::uint16_t crc16_modbus(const std::uint8_t* data, std::size_t length) {
|
||||
std::uint16_t crc = kCrcInitial;
|
||||
for (std::size_t i = 0; i < length; ++i) {
|
||||
crc ^= static_cast<std::uint16_t>(data[i]);
|
||||
for (int bit = 0; bit < 8; ++bit) {
|
||||
if ((crc & 0x0001U) != 0U) {
|
||||
crc = static_cast<std::uint16_t>((crc >> 1U) ^ kCrcPolynomial);
|
||||
} else {
|
||||
crc = static_cast<std::uint16_t>(crc >> 1U);
|
||||
}
|
||||
}
|
||||
}
|
||||
return crc;
|
||||
}
|
||||
|
||||
TactileDecoderContext* get_priv(CPCodecContext* ctx) {
|
||||
return ctx ? ctx->priv_as<TactileDecoderContext>() : nullptr;
|
||||
}
|
||||
|
||||
int tactile_init(CPCodecContext* ctx) {
|
||||
if (!ctx) {
|
||||
return CP_ERROR_INVALID_ARGUMENT;
|
||||
}
|
||||
if (!ctx->priv_data) {
|
||||
ctx->ensure_priv_storage(sizeof(TactileDecoderContext));
|
||||
}
|
||||
auto* storage = static_cast<TactileDecoderContext*>(ctx->priv_data);
|
||||
new (storage) TactileDecoderContext();
|
||||
return CP_SUCCESS;
|
||||
}
|
||||
|
||||
void tactile_close(CPCodecContext* ctx) {
|
||||
if (!ctx || !ctx->priv_data) {
|
||||
return;
|
||||
}
|
||||
if (auto* priv = get_priv(ctx); priv != nullptr) {
|
||||
priv->~TactileDecoderContext();
|
||||
}
|
||||
}
|
||||
|
||||
int tactile_send_packet(CPCodecContext* ctx, const CPPacket& packet) {
|
||||
auto* priv = get_priv(ctx);
|
||||
if (!priv) {
|
||||
return CP_ERROR_INVALID_STATE;
|
||||
}
|
||||
|
||||
if (packet.flush) {
|
||||
priv->fifo.clear();
|
||||
priv->end_of_stream = false;
|
||||
priv->next_pts = 0;
|
||||
}
|
||||
|
||||
if (!packet.payload.empty()) {
|
||||
priv->fifo.insert(priv->fifo.end(), packet.payload.begin(), packet.payload.end());
|
||||
}
|
||||
|
||||
if (packet.end_of_stream) {
|
||||
priv->end_of_stream = true;
|
||||
}
|
||||
|
||||
return CP_SUCCESS;
|
||||
}
|
||||
|
||||
std::size_t frame_length_from_payload(std::uint8_t payload_length) {
|
||||
return 1U + 1U + 1U + 1U + payload_length + 2U + 2U;
|
||||
}
|
||||
|
||||
const std::uint8_t* buffer_data(const std::vector<std::uint8_t>& buf) {
|
||||
return buf.empty() ? nullptr : buf.data();
|
||||
}
|
||||
|
||||
int tactile_receive_frame(CPCodecContext* ctx, CPFrame& frame) {
|
||||
auto* priv = get_priv(ctx);
|
||||
if (!priv) {
|
||||
return CP_ERROR_INVALID_STATE;
|
||||
}
|
||||
|
||||
auto& buf = priv->fifo;
|
||||
|
||||
while (true) {
|
||||
if (buf.empty()) {
|
||||
if (priv->end_of_stream) {
|
||||
priv->end_of_stream = false;
|
||||
return CP_ERROR_EOF;
|
||||
}
|
||||
return CP_ERROR_EAGAIN;
|
||||
}
|
||||
|
||||
// Discard bytes until start byte is found.
|
||||
auto start_it = std::find(buf.begin(), buf.end(), kStartByte);
|
||||
if (start_it == buf.end()) {
|
||||
buf.clear();
|
||||
if (priv->end_of_stream) {
|
||||
priv->end_of_stream = false;
|
||||
return CP_ERROR_EOF;
|
||||
}
|
||||
return CP_ERROR_EAGAIN;
|
||||
}
|
||||
if (start_it != buf.begin()) {
|
||||
buf.erase(buf.begin(), start_it);
|
||||
}
|
||||
|
||||
if (buf.size() < kMinimumFrameSize) {
|
||||
if (priv->end_of_stream) {
|
||||
// Incomplete frame at end of stream: drop it and report EOF.
|
||||
buf.clear();
|
||||
priv->end_of_stream = false;
|
||||
return CP_ERROR_EOF;
|
||||
}
|
||||
return CP_ERROR_EAGAIN;
|
||||
}
|
||||
|
||||
const std::uint8_t* data = buffer_data(buf);
|
||||
const std::uint8_t address = data[1];
|
||||
const std::uint8_t function = data[2];
|
||||
const std::uint8_t payload_length = data[3];
|
||||
|
||||
const std::size_t total_frame_length = frame_length_from_payload(payload_length);
|
||||
if (buf.size() < total_frame_length) {
|
||||
if (priv->end_of_stream) {
|
||||
// Not enough data before stream end: treat as EOF and drop buffer.
|
||||
buf.clear();
|
||||
priv->end_of_stream = false;
|
||||
return CP_ERROR_EOF;
|
||||
}
|
||||
return CP_ERROR_EAGAIN;
|
||||
}
|
||||
|
||||
const std::size_t payload_offset = 4U;
|
||||
const std::size_t crc_offset = payload_offset + payload_length;
|
||||
const std::size_t end_offset = crc_offset + 2U;
|
||||
|
||||
const std::uint8_t crc_lo = data[crc_offset];
|
||||
const std::uint8_t crc_hi = data[crc_offset + 1U];
|
||||
const std::uint16_t crc_value = static_cast<std::uint16_t>(crc_lo) |
|
||||
static_cast<std::uint16_t>(crc_hi << 8U);
|
||||
|
||||
const std::uint8_t end_first = data[end_offset];
|
||||
const std::uint8_t end_second = data[end_offset + 1U];
|
||||
|
||||
if (end_first != kEndByteFirst || end_second != kEndByteSecond) {
|
||||
// Invalid end marker, drop start byte and retry.
|
||||
buf.erase(buf.begin());
|
||||
continue;
|
||||
}
|
||||
|
||||
const std::size_t crc_region_length = 3U + payload_length; // address + function + length + payload
|
||||
const std::uint16_t computed_crc = crc16_modbus(data + 1U, crc_region_length);
|
||||
if (computed_crc != crc_value) {
|
||||
buf.erase(buf.begin());
|
||||
continue;
|
||||
}
|
||||
|
||||
(void)address;
|
||||
(void)function;
|
||||
|
||||
frame.data.assign(buf.begin(), buf.begin() + static_cast<std::ptrdiff_t>(total_frame_length));
|
||||
frame.pts = priv->next_pts++;
|
||||
frame.key_frame = true;
|
||||
frame.valid = true;
|
||||
|
||||
buf.erase(buf.begin(), buf.begin() + static_cast<std::ptrdiff_t>(total_frame_length));
|
||||
|
||||
return CP_SUCCESS;
|
||||
}
|
||||
}
|
||||
|
||||
const CPCodec kTactileCodec {
|
||||
"tactile_serial",
|
||||
"Framed tactile sensor serial protocol decoder",
|
||||
CPMediaType::Data,
|
||||
CPCodecID::Tactile,
|
||||
sizeof(TactileDecoderContext),
|
||||
&tactile_init,
|
||||
&tactile_close,
|
||||
&tactile_send_packet,
|
||||
&tactile_receive_frame
|
||||
};
|
||||
|
||||
} // namespace
|
||||
|
||||
std::optional<TactileFrame> parse_frame(const CPFrame& frame) {
|
||||
if (!frame.valid || frame.data.size() < kMinimumFrameSize) {
|
||||
return std::nullopt;
|
||||
}
|
||||
const auto* bytes = frame.data.data();
|
||||
const std::size_t size = frame.data.size();
|
||||
|
||||
if (bytes[0] != kStartByte) {
|
||||
return std::nullopt;
|
||||
}
|
||||
if (bytes[size - 2] != kEndByteFirst || bytes[size - 1] != kEndByteSecond) {
|
||||
return std::nullopt;
|
||||
}
|
||||
|
||||
if (size < 4U) {
|
||||
return std::nullopt;
|
||||
}
|
||||
|
||||
const std::uint8_t length = bytes[3];
|
||||
if (frame_length_from_payload(length) != size) {
|
||||
return std::nullopt;
|
||||
}
|
||||
|
||||
const std::uint8_t address = bytes[1];
|
||||
const FunctionCode function = static_cast<FunctionCode>(bytes[2]);
|
||||
const std::size_t payload_offset = 4U;
|
||||
|
||||
TactileFrame parsed{};
|
||||
parsed.device_address = address;
|
||||
parsed.function = function;
|
||||
parsed.data_length = length;
|
||||
parsed.payload.assign(bytes + payload_offset, bytes + payload_offset + length);
|
||||
return parsed;
|
||||
}
|
||||
|
||||
std::vector<std::uint16_t> parse_pressure_values(const TactileFrame& frame) {
|
||||
if (frame.payload.empty() || (frame.payload.size() % 2U != 0U)) {
|
||||
return {};
|
||||
}
|
||||
std::vector<std::uint16_t> values;
|
||||
values.reserve(frame.payload.size() / 2U);
|
||||
for (std::size_t idx = 0; idx + 1U < frame.payload.size(); idx += 2U) {
|
||||
const std::uint16_t value = static_cast<std::uint16_t>(
|
||||
static_cast<std::uint16_t>(frame.payload[idx]) |
|
||||
static_cast<std::uint16_t>(frame.payload[idx + 1U] << 8U));
|
||||
values.push_back(value);
|
||||
}
|
||||
return values;
|
||||
}
|
||||
|
||||
std::optional<MatrixSize> parse_matrix_size_payload(const TactileFrame& frame) {
|
||||
if (frame.payload.size() != 2U) {
|
||||
return std::nullopt;
|
||||
}
|
||||
MatrixSize size{};
|
||||
size.long_edge = frame.payload[0];
|
||||
size.short_edge = frame.payload[1];
|
||||
return size;
|
||||
}
|
||||
|
||||
std::optional<MatrixSize> parse_matrix_coordinate_payload(const TactileFrame& frame) {
|
||||
return parse_matrix_size_payload(frame);
|
||||
}
|
||||
|
||||
const CPCodec* tactile_codec() {
|
||||
return &kTactileCodec;
|
||||
}
|
||||
|
||||
void register_tactile_codec() {
|
||||
cpcodec_register(&kTactileCodec);
|
||||
}
|
||||
|
||||
} // namespace ffmsep::tactile
|
||||
Reference in New Issue
Block a user