LCOV - code coverage report
Current view: top level - libMagAOX/logger/types - telem_poltrack.hpp (source / functions) Coverage Total Hit
Test: MagAOX Lines: 19.6 % 51 10
Test Date: 2026-01-03 21:03:39 Functions: 25.0 % 8 2

            Line data    Source code
       1              : /** \file telem_poltrack.hpp
       2              :  * \brief The MagAO-X logger telem_poltrack log type.
       3              :  * \author Jared R. Males (jaredmales@gmail.com)
       4              :  *
       5              :  * \ingroup logger_types_files
       6              :  *
       7              :  */
       8              : #ifndef logger_types_telem_poltrack_hpp
       9              : #define logger_types_telem_poltrack_hpp
      10              : 
      11              : #include "generated/telem_poltrack_generated.h"
      12              : #include "flatbuffer_log.hpp"
      13              : 
      14              : namespace MagAOX
      15              : {
      16              : namespace logger
      17              : {
      18              : 
      19              : /// Log entry recording poltrack stage specific status.
      20              : /** \ingroup logger_types
      21              :  */
      22              : struct telem_poltrack : public flatbuffer_log
      23              : {
      24              :     /// The event code
      25              :     static const flatlogs::eventCodeT eventCode = eventCodes::TELEM_POLTRACK;
      26              : 
      27              :     /// The default level
      28              :     static const flatlogs::logPrioT defaultLevel = flatlogs::logPrio::LOG_TELEM;
      29              : 
      30              :     static timespec
      31              :         lastRecord; ///< The timestamp of the last time this log was recorded.  Used by the telemetry system.
      32              : 
      33              :     /// The type of the input message
      34              :     struct messageT : public fbMessage
      35              :     {
      36              :         /// Construct from components
      37            1 :         messageT( const float &set_angle,   /**<[in] the HWP set angle */
      38              :                   const float &actual_angle, /**<[in] the actual HWP angle */
      39              :                   const std::string &pos_name, /**<[in] the name of the HWP position */
      40              :                   const bool &tracking
      41              :         )
      42            1 :         {
      43            1 :             auto _pos_name = builder.CreateString(pos_name);
      44              : 
      45            1 :             auto fp = CreateTelem_poltrack_fb( builder, set_angle, actual_angle, _pos_name, tracking);
      46            1 :             builder.Finish( fp );
      47            1 :         }
      48              :     };
      49              : 
      50            1 :     static bool verify( flatlogs::bufferPtrT &logBuff, ///< [in] Buffer containing the flatbuffer serialized message.
      51              :                         flatlogs::msgLenT     len      ///< [in] length of msgBuffer.
      52              :     )
      53              :     {
      54            1 :         auto verifier = flatbuffers::Verifier( static_cast<uint8_t *>( flatlogs::logHeader::messageBuffer( logBuff ) ),
      55            1 :                                                static_cast<size_t>( len ) );
      56            2 :         return VerifyTelem_poltrack_fbBuffer( verifier );
      57              :     }
      58              : 
      59              :     /// Get the message formatte for human consumption.
      60            0 :     static std::string msgString( void *msgBuffer,      /**< [in] Buffer containing the flatbuffer serialized message.*/
      61              :                                   flatlogs::msgLenT len /**< [in] [unused] length of msgBuffer.*/
      62              :     )
      63              :     {
      64              :         static_cast<void>( len );
      65              : 
      66            0 :         auto fbs = GetTelem_poltrack_fb( msgBuffer );
      67              : 
      68            0 :         std::string msg = "[poltrack] ";
      69              : 
      70            0 :         msg += "set: ";
      71            0 :         msg += std::to_string( fbs->set_angle() ) + " ";
      72              : 
      73            0 :         msg += "act: ";
      74            0 :         msg += std::to_string( fbs->actual_angle() ) + " ";
      75              : 
      76            0 :         msg += "name: ";
      77            0 :         if ( fbs->pos_name() )
      78              :         {
      79            0 :             msg += std::string(fbs->pos_name()->c_str()) + " ";
      80              :         }
      81              : 
      82            0 :         msg += "tracking: ";
      83            0 :         if (fbs->tracking())
      84              :         {
      85            0 :             msg += "SYNCHRO_ADI ";
      86              :         }
      87              :         else
      88              :         {
      89            0 :             msg += "NONE ";
      90              :         }
      91              : 
      92            0 :         return msg;
      93            0 :     }
      94              : 
      95            0 :     static float set_angle( void *msgBuffer )
      96              :     {
      97            0 :         auto fbs = GetTelem_poltrack_fb( msgBuffer );
      98            0 :         return fbs->set_angle();
      99              :     }
     100              : 
     101            0 :     static float actual_angle( void *msgBuffer )
     102              :     {
     103            0 :         auto fbs = GetTelem_poltrack_fb( msgBuffer );
     104            0 :         return fbs->actual_angle();
     105              :     }
     106              : 
     107            0 :     static std::string pos_name( void *msgBuffer )
     108              :     {
     109            0 :         auto fbs = GetTelem_poltrack_fb(msgBuffer);
     110            0 :         if(fbs->pos_name())
     111              :         {
     112            0 :             return std::string(fbs->pos_name()->c_str());
     113              :         }
     114            0 :         else return std::string();
     115              :     }
     116              : 
     117            0 :     static bool tracking( void *msgBuffer )
     118              :     {
     119            0 :         auto fbs = GetTelem_poltrack_fb( msgBuffer );
     120            0 :         return fbs->tracking();
     121              : 
     122              :     }
     123              : 
     124              :     /// Get the logMetaDetail for a member by name
     125              :     /**
     126              :      * \returns the a logMetaDetail filled in with the appropriate details
     127              :      * \returns an empty logMetaDetail if member not recognized
     128              :      */
     129            0 :     static logMetaDetail getAccessor( const std::string &member /**< [in] the name of the member */ )
     130              :     {
     131            0 :         if( member == "set_angle" )
     132              :         {
     133              :             return logMetaDetail( { "SET ANGLE",
     134              :                                     logMeta::valTypes::Float,
     135              :                                     logMeta::metaTypes::State,
     136            0 :                                     reinterpret_cast<void *>( &set_angle ) } );
     137              :         }
     138            0 :         else if( member == "actual_angle" )
     139              :         {
     140              :             return logMetaDetail( { "ACTUAL ANGLE",
     141              :                                     logMeta::valTypes::Float,
     142              :                                     logMeta::metaTypes::State,
     143            0 :                                     reinterpret_cast<void *>( &actual_angle ) } );
     144              :         }
     145            0 :         else if( member == "pos_name" )
     146              :         {
     147              :             return logMetaDetail( { "POS NAME",
     148              :                                     logMeta::valTypes::String,
     149              :                                     logMeta::metaTypes::State,
     150            0 :                                     reinterpret_cast<void *>( &pos_name ) } );
     151              :         }
     152            0 :         else if( member == "tracking" )
     153              :         {
     154              :             return logMetaDetail( { "TRACKING",
     155              :                                     logMeta::valTypes::Bool,
     156              :                                     logMeta::metaTypes::State,
     157            0 :                                     reinterpret_cast<void *>( &tracking ) } );
     158              :         }
     159              :         else
     160              :         {
     161            0 :             std::cerr << "No member " << member << " in telem_poltrack\n";
     162            0 :             return logMetaDetail();
     163              :         }
     164              :     }
     165              : 
     166              : }; // telem_poltrack
     167              : 
     168              : } // namespace logger
     169              : } // namespace MagAOX
     170              : 
     171              : #endif // logger_types_telem_poltrack_hpp
        

Generated by: LCOV version 2.0-1