Telemetry.h

Go to the documentation of this file.

/******************************************************************************
* Copyright (c) ATTX INC 2025. All Rights Reserved.
*
* This software and associated documentation (the "Software") are the
* proprietary and confidential information of ATTX, INC. The Software is
* furnished under a license agreement between ATTX and the user organization
* and may be used or copied only in accordance with the terms of the agreement.
* Refer to 'license/attx_license.adoc' for standard license terms.
*
* EXPORT CONTROL NOTICE: THIS SOFTWARE MAY INCLUDE CONTENT CONTROLLED UNDER THE
* INTERNATIONAL TRAFFIC IN ARMS REGULATIONS (ITAR) OR THE EXPORT ADMINISTRATION
* REGULATIONS (EAR99). No part of the Software may be used, reproduced, or
* transmitted in any form or by any means, for any purpose, without the express
* written permission of ATTX, INC.
******************************************************************************/
/*
Telemetry Macro header file
 
Author: Alex Reynolds
Secondary Contributor: James Tabony
*/
 
#ifndef FLIGHT_TELEMETRY_H
#define FLIGHT_TELEMETRY_H
 
#include <string.h>
 
#include "communication/spacepacketutils.hpp"
#include "utils/stringutils.hpp"
#include "configuration.h"
 
// The minimum allowable value of the last 4 bits of a command APID
#define CMD_APID_MIN_ALLOWABLE 0x1
// The maximum allowable value of the last 4 bits of a command APID
#define CMD_APID_MAX_ALLOWABLE 0xB
// The minimum allowable value of the last 4 bits of a telemetry APID
#define TLM_APID_MIN_ALLOWABLE 0xC
// The maximum allowable value of the last 4 bits of a command APID
#define TLM_APID_MAX_ALLOWABLE 0xF

struct cmd_tlm_base {
    virtual uint16 apid() const {return 0;}
    virtual uint16 size() const {return 0;}
    virtual void packetize(uint8* out) const {return;}
    virtual void depacketize(const uint8* out) {return;}
    virtual int16 str(char* output, uint16 size) const {return 0;}
};
 
#define CMD_TLM_COMMON(NAME, APID, SIZE, ...)                                       \
    struct NAME : public cmd_tlm_base {                                             \
        /* mutable to allow modification within the const str() member function */  \
        mutable char temp_buf[MAX_TLM_FIELD_CHAR_BUF_SIZE];                         \
                                                                                    \
        EXPAND_VAL(FOR_EACH(DECLARE_FIELD, __VA_ARGS__))                            \
                                                                                    \
        uint16 apid() const override { return APID; }                               \
                                                                                    \
        uint16 size() const override { return SIZE; }                               \
                                                                                    \
        void packetize(uint8* out) const override {                                 \
            uint8* ptr = out;                                                       \
            EXPAND_VAL(FOR_EACH(PACKETIZE_FIELD, __VA_ARGS__))                      \
        }                                                                           \
                                                                                    \
        void depacketize(const uint8* in) override {                                \
            const uint8* ptr = in;                                                  \
            EXPAND_VAL(FOR_EACH(DEPACKETIZE_FIELD, __VA_ARGS__))                    \
        }                                                                           \
                                                                                    \
        int16 str(char* output, uint16 size) const override {                       \
            char* ptr = output;                                                     \
            EXPAND_VAL(FOR_EACH(STR_FIELD, __VA_ARGS__))                            \
            *(ptr - 1) = '\0';                                                      \
            return NO_ERROR;                                                        \
        }                                                                           \
    };
 
// Strip parentheses from complex types
#define STRIP_PARENS(X) STRIP_PARENS_IMPL X
#define STRIP_PARENS_IMPL(...) __VA_ARGS__
 
// Field declarations
#define DECLARE_FIELD(pair)   DECLARE_FIELD_ pair
#define DECLARE_FIELD_(type, name) STRIP_PARENS(type) name;
 
// Packetize
#define PACKETIZE_FIELD(pair) PACKETIZE_FIELD_ pair
#define PACKETIZE_FIELD_(type, name) do {                                               \
    STRIP_PARENS(type) temp = this->name;                                               \
    if (sizeof(STRIP_PARENS(type)) > 1 && !IS_BIG_ENDIAN) temp = warpos::changeEndian(temp);\
    memcpy(ptr, &temp, sizeof(temp));                                                   \
    ptr += sizeof(temp);                                                                \
} while (0)
 
// Depacketize
#define DEPACKETIZE_FIELD(pair) DEPACKETIZE_FIELD_ pair
#define DEPACKETIZE_FIELD_(type, name) do {                                             \
    STRIP_PARENS(type) temp;                                                            \
    memcpy(&temp, ptr, sizeof(temp));                                                   \
    if (sizeof(STRIP_PARENS(type)) > 1 && !IS_BIG_ENDIAN) temp = warpos::changeEndian(temp);\
    this->name = temp;                                                                  \
    ptr += sizeof(temp);                                                                \
} while (0)
 
// Stringify helpers
#define STR_FIELD(pair) STR_FIELD_ pair
#define STR_FIELD_(type, name) do {                                                   \
    int16 status = clockwerk::numberToString(this->name, temp_buf, sizeof(temp_buf));            \
    if (status != NO_ERROR) return status;                                            \
    size_t len = strlen(temp_buf);                                 \
    if ((size_t)(ptr - output) + len + 2 > size) return ERROR_DIMENSIONS; /* not enough space */\
    memcpy(ptr, temp_buf, len);                                                       \
    ptr += len;                                                                       \
    *ptr++ = ',';                                                                     \
} while (0)
 
// FOR_EACH utilities (handles up to 10 fields) 
#define EXPAND_VAL(x) x
#define FOR_EACH_1(M,  x)      M(x);
#define FOR_EACH_2(M,  x, ...) M(x); FOR_EACH_1(M, __VA_ARGS__)
#define FOR_EACH_3(M,  x, ...) M(x); FOR_EACH_2(M, __VA_ARGS__)
#define FOR_EACH_4(M,  x, ...) M(x); FOR_EACH_3(M, __VA_ARGS__)
#define FOR_EACH_5(M,  x, ...) M(x); FOR_EACH_4(M, __VA_ARGS__)
#define FOR_EACH_6(M,  x, ...) M(x); FOR_EACH_5(M, __VA_ARGS__)
#define FOR_EACH_7(M,  x, ...) M(x); FOR_EACH_6(M, __VA_ARGS__)
#define FOR_EACH_8(M,  x, ...) M(x); FOR_EACH_7(M, __VA_ARGS__)
#define FOR_EACH_9(M,  x, ...) M(x); FOR_EACH_8(M, __VA_ARGS__)
#define FOR_EACH_10(M, x, ...) M(x); FOR_EACH_9(M, __VA_ARGS__)
#define FOR_EACH_11(M, x, ...) M(x); FOR_EACH_10(M, __VA_ARGS__)
#define FOR_EACH_12(M, x, ...) M(x); FOR_EACH_11(M, __VA_ARGS__)
#define FOR_EACH_13(M, x, ...) M(x); FOR_EACH_12(M, __VA_ARGS__)
#define FOR_EACH_14(M, x, ...) M(x); FOR_EACH_13(M, __VA_ARGS__)
#define FOR_EACH_15(M, x, ...) M(x); FOR_EACH_14(M, __VA_ARGS__)
#define FOR_EACH_16(M, x, ...) M(x); FOR_EACH_15(M, __VA_ARGS__)
#define FOR_EACH_17(M, x, ...) M(x); FOR_EACH_16(M, __VA_ARGS__)
#define FOR_EACH_18(M, x, ...) M(x); FOR_EACH_17(M, __VA_ARGS__)
#define FOR_EACH_19(M, x, ...) M(x); FOR_EACH_18(M, __VA_ARGS__)
#define FOR_EACH_20(M, x, ...) M(x); FOR_EACH_19(M, __VA_ARGS__)
#define FOR_EACH_21(M, x, ...) M(x); FOR_EACH_20(M, __VA_ARGS__)
#define FOR_EACH_22(M, x, ...) M(x); FOR_EACH_21(M, __VA_ARGS__)
#define FOR_EACH_23(M, x, ...) M(x); FOR_EACH_22(M, __VA_ARGS__)
#define FOR_EACH_24(M, x, ...) M(x); FOR_EACH_23(M, __VA_ARGS__)
#define FOR_EACH_25(M, x, ...) M(x); FOR_EACH_24(M, __VA_ARGS__)
#define FOR_EACH_26(M, x, ...) M(x); FOR_EACH_25(M, __VA_ARGS__)
#define FOR_EACH_27(M, x, ...) M(x); FOR_EACH_26(M, __VA_ARGS__)
#define FOR_EACH_28(M, x, ...) M(x); FOR_EACH_27(M, __VA_ARGS__)
#define FOR_EACH_29(M, x, ...) M(x); FOR_EACH_28(M, __VA_ARGS__)
#define FOR_EACH_30(M, x, ...) M(x); FOR_EACH_29(M, __VA_ARGS__)
#define FOR_EACH_31(M, x, ...) M(x); FOR_EACH_30(M, __VA_ARGS__)
#define FOR_EACH_32(M, x, ...) M(x); FOR_EACH_31(M, __VA_ARGS__)
#define FOR_EACH_33(M, x, ...) M(x); FOR_EACH_32(M, __VA_ARGS__)
#define FOR_EACH_34(M, x, ...) M(x); FOR_EACH_33(M, __VA_ARGS__)
#define FOR_EACH_35(M, x, ...) M(x); FOR_EACH_34(M, __VA_ARGS__)
#define FOR_EACH_36(M, x, ...) M(x); FOR_EACH_35(M, __VA_ARGS__)
#define FOR_EACH_37(M, x, ...) M(x); FOR_EACH_36(M, __VA_ARGS__)
#define FOR_EACH_38(M, x, ...) M(x); FOR_EACH_37(M, __VA_ARGS__)
#define FOR_EACH_39(M, x, ...) M(x); FOR_EACH_38(M, __VA_ARGS__)
#define FOR_EACH_40(M, x, ...) M(x); FOR_EACH_39(M, __VA_ARGS__)
#define FOR_EACH_41(M, x, ...) M(x); FOR_EACH_40(M, __VA_ARGS__)
#define FOR_EACH_42(M, x, ...) M(x); FOR_EACH_41(M, __VA_ARGS__)
#define FOR_EACH_43(M, x, ...) M(x); FOR_EACH_42(M, __VA_ARGS__)
#define FOR_EACH_44(M, x, ...) M(x); FOR_EACH_43(M, __VA_ARGS__)
#define FOR_EACH_45(M, x, ...) M(x); FOR_EACH_44(M, __VA_ARGS__)
#define FOR_EACH_46(M, x, ...) M(x); FOR_EACH_45(M, __VA_ARGS__)
#define FOR_EACH_47(M, x, ...) M(x); FOR_EACH_46(M, __VA_ARGS__)
#define FOR_EACH_48(M, x, ...) M(x); FOR_EACH_47(M, __VA_ARGS__)
#define FOR_EACH_49(M, x, ...) M(x); FOR_EACH_48(M, __VA_ARGS__)
#define FOR_EACH_50(M, x, ...) M(x); FOR_EACH_49(M, __VA_ARGS__)
 
 
#define GET_FOR_EACH_MACRO( \
    _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
    _11,_12,_13,_14,_15,_16,_17,_18,_19,_20, \
    _21,_22,_23,_24,_25,_26,_27,_28,_29,_30, \
    _31,_32,_33,_34,_35,_36,_37,_38,_39,_40, \
    _41,_42,_43,_44,_45,_46,_47,_48,_49,_50, \
    NAME, ...) NAME
// This macro selects the appropriate FOR_EACH macro based on the number of arguments
#define FOR_EACH(M, ...)                                                \
    EXPAND_VAL(GET_FOR_EACH_MACRO(__VA_ARGS__,                              \
        FOR_EACH_50, FOR_EACH_49, FOR_EACH_48, FOR_EACH_47, FOR_EACH_46,\
        FOR_EACH_45, FOR_EACH_44, FOR_EACH_43, FOR_EACH_42, FOR_EACH_41,\
        FOR_EACH_40, FOR_EACH_39, FOR_EACH_38, FOR_EACH_37, FOR_EACH_36,\
        FOR_EACH_35, FOR_EACH_34, FOR_EACH_33, FOR_EACH_32, FOR_EACH_31,\
        FOR_EACH_30, FOR_EACH_29, FOR_EACH_28, FOR_EACH_27, FOR_EACH_26,\
        FOR_EACH_25, FOR_EACH_24, FOR_EACH_23, FOR_EACH_22, FOR_EACH_21,\
        FOR_EACH_20, FOR_EACH_19, FOR_EACH_18, FOR_EACH_17, FOR_EACH_16,\
        FOR_EACH_15, FOR_EACH_14, FOR_EACH_13, FOR_EACH_12, FOR_EACH_11,\
        FOR_EACH_10, FOR_EACH_9,  FOR_EACH_8,  FOR_EACH_7,  FOR_EACH_6, \
        FOR_EACH_5,  FOR_EACH_4,  FOR_EACH_3,  FOR_EACH_2,  FOR_EACH_1)  \
        (M, __VA_ARGS__))

#define TELEMETRY(NAME, APID, SIZE, ...) \
    static_assert(((APID) & 0x00F) >= TLM_APID_MIN_ALLOWABLE && ((APID) & 0x00F) <= TLM_APID_MAX_ALLOWABLE, \
                  "Creating TLM NAME failed. APID must be between TLM_APID_MIN_ALLOWABLE and TLM_APID_MAX_ALLOWABLE"); \
    static_assert(SIZE <= CMD_TLM_PKT_MAX_SIZE_BYTES, "Creating TLM NAME failed. SIZE must be <=> configuration/CMD_TLM_PKT_MAX_SIZE_BYTES");\
    CMD_TLM_COMMON(NAME, APID, SIZE, __VA_ARGS__)
 
#endif