TelemetryManager.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 Manager header file
 
Author: Alex Reynolds
*/
#ifndef FLIGHT_TELEMETRYMANAGER_H
#define FLIGHT_TELEMETRYMANAGER_H
 
#include "architecture/Time.h"
#include "architecture/CircularBuffer.hpp"
#include "flight/App.h"
#include "flight/flighterrors.h"
#include "telemetry/tlm_TelemetryManager.h"
 
namespace warpos {
 
class FlightExecutive;

enum tlm_priority_e : uint8 {
    NORMAL = 0,
    HIGH = 1
};

struct PacketTypeInfo {
    clockwerk::Time rate_sec;   
    clockwerk::Time last_sent;  
    uint16 apid;                
    uint16 count;               
    tlm_priority_e priority;    
    uint8 instance;             
    uint8 target;               
};

struct PacketInfo {
    uint32 size; 
    uint16 apid; 
    clockwerk::Time timestamp; 
    uint8 instance; 
};

class TelemetryManager : public App {
    public:
        START_PARAMS
            SIGNAL(max_bytes_per_step,              uint32,             TLM_NORMAL_PRI_QUEUE_SIZE_BYTES + TLM_HIGH_PRI_QUEUE_SIZE_BYTES)
        END_PARAMS

        TelemetryManager(FlightExecutive &exc);
        virtual ~TelemetryManager();

        int16 addTlmToQueue(const cmd_tlm_base& pkt, uint8 instance);

        int16 writeQueues(void *tlm_ptr, uint32 size, const PacketInfo &tlminfo, tlm_priority_e priority);

        int16 registerTlmPacket(uint16 tlm_apid, uint8 instance);

        int16 configureTlmPacket(const PacketTypeInfo& info);

        uint32 queueCountNormalPri() { return _tlm_normal_info_queue.valsHeld(); }

        uint32 queueCountHighPri() { return _tlm_high_info_queue.valsHeld(); }

        int16 activate() override;

        int16 deactivate() override;

        int16 command(uint16 apid, uint8* buffer, uint16 size) override;

        uint16 numRegisteredPackets() {return _tlm_table_idx;}

        PacketTypeInfo* registeredPackets() {return _tlm_table;}

        clockwerk::Queue<uint8, TLM_NORMAL_PRI_QUEUE_SIZE_BYTES>& tlmNormalPriByteQueue() {return _tlm_normal_byte_queue;}

        clockwerk::Queue<PacketInfo, TLM_NORMAL_PRI_QUEUE_SIZE_PKTS>& tlmNormalPriInfoQueue() {return _tlm_normal_info_queue;}

        clockwerk::Queue<uint8, TLM_HIGH_PRI_QUEUE_SIZE_BYTES>& tlmHighPriByteQueue() {return _tlm_high_byte_queue;}

        clockwerk::Queue<PacketInfo, TLM_HIGH_PRI_QUEUE_SIZE_PKTS>& tlmHighPriInfoQueue() {return _tlm_high_info_queue;}
    protected:
        int16 start() override;
        int16 execute() override;

        uint32 _sendNextTlmPacket();

        int32 _findPktIndex(uint16 apid, uint8 instance);
 
        clockwerk::Queue<uint8, TLM_NORMAL_PRI_QUEUE_SIZE_BYTES> _tlm_normal_byte_queue; 
        clockwerk::Queue<PacketInfo, TLM_NORMAL_PRI_QUEUE_SIZE_PKTS> _tlm_normal_info_queue; 
 
        clockwerk::Queue<uint8, TLM_HIGH_PRI_QUEUE_SIZE_BYTES> _tlm_high_byte_queue; 
        clockwerk::Queue<PacketInfo, TLM_HIGH_PRI_QUEUE_SIZE_PKTS> _tlm_high_info_queue; 
 
        PacketTypeInfo _tlm_table[MAX_TLM_TABLE_SIZE]; 
 
        char _print_buff[200];           
 
        // Output Telemetry Items
        uint16 _tlm_table_idx = 0;     
        uint8 _byte_queue_error = 0;   
        uint8 _ccsds_failure = 0;      
        uint8 _telem_write_error = 0;  
        uint8 _buffer_overwrite = 0;   
        uint8 _successful_packets = 0; 
 
        tlm_tlm_mngr_status _status_tlm;        
        uint8 _tlm_packet[sizeof(_status_tlm)]; 
 
        uint8 _packetized_data[CMD_TLM_PKT_MAX_SIZE_BYTES];     
};
} // namespace warpos
 
#endif