feat: add irq_status_t structure and update get_irq_status to use it

feat: implement string conversion functions for CommandStatus and ChipMode enums

inc/llcc68.hpp

@@ -176,12 +176,37 @@ Result<Unit, error_t> inline write_buffer(std::span<const uint8_t> data, const u
 	return spi::write_buffer(offset, data);
 }
 
-inline Result<uint16_t, error_t>
+struct irq_status_bits_t {
+	// LSB
+
+	bool tx_done : 1;           // 0
+	bool rx_done : 1;           // 1
+	bool preamble_detected : 1; // 2
+	bool sync_word_valid : 1;   // 3
+	bool header_valid : 1;      // 4
+	bool header_err : 1;        // 5
+	bool crc_err : 1;           // 6
+	bool cad_done : 1;          // 7
+	bool cad_detected : 1;      // 8
+	bool timeout : 1;           // 9
+	uint8_t reserved_0 : 4;     // 10-13
+	bool lr_fhss_hop : 1;       // 14
+	uint8_t reserved_1 : 1;     // 15
+
+	// MSB
+};
+union irq_status_t {
+	uint16_t raw;
+	irq_status_bits_t bits;
+};
+static_assert(sizeof(irq_status_t) == 2, "irq_status_t must be 2 bytes");
+
+inline Result<irq_status_t, error_t>
 get_irq_status() {
 	uint8_t data[] = {0x00, 0x00};
 	const auto res = spi::read_stream(RADIOLIB_SX126X_CMD_GET_IRQ_STATUS, data);
 	APP_RADIO_RETURN_ERR(res);
-	return static_cast<uint16_t>(data[0] << 8) | static_cast<uint16_t>(data[1]);
+	return irq_status_t{.raw = static_cast<uint16_t>(static_cast<uint16_t>(data[0] << 8) | static_cast<uint16_t>(data[1]))};
 }
 
 inline Result<Unit, error_t>
@@ -708,9 +733,9 @@ inline Result<bool, error_t>
 channel_scan_result() {
 	const auto res = get_irq_status();
 	APP_RADIO_RETURN_ERR(res);
-	if (*res & RADIOLIB_SX126X_IRQ_CAD_DETECTED) {
+	if (res->bits.cad_detected) {
 		return false;
-	} else if (*res & RADIOLIB_SX126X_IRQ_CAD_DONE) {
+	} else if (res->bits.cad_done) {
 		return true;
 	}
 	return ue_t{error_t{error::RADIO_INVALID_CAD_RESULT}};
@@ -932,15 +957,15 @@ get_rx_buffer_status() {
 }
 
 struct read_result_t {
-	uint16_t irq_status;
+	irq_status_t irq_status;
 	std::span<const uint8_t> data;
 
 	bool is_crc_err() const {
-		return (irq_status & RADIOLIB_SX126X_IRQ_CRC_ERR) != 0;
+		return (irq_status.bits.crc_err) != 0;
 	}
 
 	bool is_header_err() const {
-		return (irq_status & RADIOLIB_SX126X_IRQ_HEADER_ERR) != 0;
+		return (irq_status.bits.header_err) != 0;
 	}
 
 	/*!
@@ -964,7 +989,7 @@ read_data_internal() {
 	APP_RADIO_RETURN_ERR(st_);
 	const auto irq = *irq_;
 	const auto st  = *st_;
-	if (irq & RADIOLIB_SX126X_IRQ_TIMEOUT || st.command_status == CommandStatus::COMMAND_TIMEOUT) {
+	if (irq.bits.timeout || st.command_status == CommandStatus::COMMAND_TIMEOUT) {
 		return ue_t{error_t{error::RADIO_RX_TIMEOUT}};
 	}
 

inc/llcc68_definitions.hpp

@@ -225,6 +225,27 @@ enum class CommandStatus : uint8_t {
 	COMMAND_TX_DONE            = 0x06, // 0b110
 };
 
+inline const char *to_str(const CommandStatus &status) {
+	switch (status) {
+	case CommandStatus::RESERVED:
+		return "RESERVED";
+	case CommandStatus::RFU:
+		return "RFU";
+	case CommandStatus::DATA_AVAILABLE:
+		return "DATA_AVAILABLE";
+	case CommandStatus::COMMAND_TIMEOUT:
+		return "COMMAND_TIMEOUT";
+	case CommandStatus::COMMAND_PROCESSING_ERROR:
+		return "COMMAND_PROCESSING_ERROR";
+	case CommandStatus::FAILURE_TO_EXECUTE_COMMAND:
+		return "FAILURE_TO_EXECUTE_COMMAND";
+	case CommandStatus::COMMAND_TX_DONE:
+		return "COMMAND_TX_DONE";
+	default:
+		return "Unknown";
+	}
+}
+
 enum class ChipMode : uint8_t {
 	UNUSED    = 0x00, // 0b000
 	RFU       = 0x01, // 0b001
@@ -235,6 +256,27 @@ enum class ChipMode : uint8_t {
 	TX        = 0x06, // 0b110
 };
 
+inline const char *to_str(const ChipMode &mode) {
+	switch (mode) {
+	case ChipMode::UNUSED:
+		return "UNUSED";
+	case ChipMode::RFU:
+		return "RFU";
+	case ChipMode::STBY_RC:
+		return "STBY_RC";
+	case ChipMode::STBY_XOSC:
+		return "STBY_XOSC";
+	case ChipMode::FS:
+		return "FS";
+	case ChipMode::RX:
+		return "RX";
+	case ChipMode::TX:
+		return "TX";
+	default:
+		return "Unknown";
+	}
+}
+
 
 struct __attribute__((packed)) status_t {
 	uint8_t reserved_1 : 1;