Line data    Source code

       1              : /** \file telem_offloading.hpp
       2              :  * \brief The MagAO-X logger telem_offloading log type.
       3              :  * \author Jared R. Males (jaredmales@gmail.com)
       4              :  *
       5              :  * \ingroup logger_types_files
       6              :  *
       7              :  */
       8              : #ifndef logger_types_telem_offloading_hpp
       9              : #define logger_types_telem_offloading_hpp
      10              : 
      11              : #include "generated/telem_offloading_generated.h"
      12              : #include "flatbuffer_log.hpp"
      13              : 
      14              : namespace MagAOX
      15              : {
      16              : namespace logger
      17              : {
      18              : 
      19              : /// Log entry recording the build-time git state.
      20              : /** \ingroup logger_types
      21              :  */
      22              : struct telem_offloading : public flatbuffer_log
      23              : {
      24              :     /// The event code
      25              :     static const flatlogs::eventCodeT eventCode = eventCodes::TELEM_OFFLOADING;
      26              : 
      27              :     /// The default level
      28              :     static const flatlogs::logPrioT defaultLevel = flatlogs::logPrio::LOG_TELEM;
      29              : 
      30              :     static timespec lastRecord; ///< The time of the last time this log was recorded.  Used by the telemetry system.
      31              : 
      32              :     /// The type of the input message
      33              :     struct messageT : public fbMessage
      34              :     {
      35              :         /// Construct from components
      36            1 :         messageT( const uint32_t &num_modes,   ///< [in] the number of modes being offloaded
      37              :                   const uint32_t &num_average, ///< [in] the number of frames being averaged
      38              :                   const float    &fps          ///< [in] the rate of offloading, in frames per second
      39              :         )
      40            1 :         {
      41            1 :             auto fp = CreateTelem_offloading_fb( builder, num_modes, num_average, fps );
      42            1 :             builder.Finish( fp );
      43            1 :         }
      44              :     };
      45              : 
      46            1 :     static bool verify( flatlogs::bufferPtrT &logBuff, ///< [in] Buffer containing the flatbuffer serialized message.
      47              :                         flatlogs::msgLenT     len      ///< [in] length of msgBuffer.
      48              :     )
      49              :     {
      50            1 :         auto verifier = flatbuffers::Verifier( static_cast<uint8_t *>( flatlogs::logHeader::messageBuffer( logBuff ) ),
      51            1 :                                                static_cast<size_t>( len ) );
      52            2 :         return VerifyTelem_offloading_fbBuffer( verifier );
      53              :     }
      54              : 
      55              :     /// Get the message formatte for human consumption.
      56            0 :     static std::string msgString( void *msgBuffer,      /**< [in] Buffer containing the flatbuffer serialized message.*/
      57              :                                   flatlogs::msgLenT len /**< [in] [unused] length of msgBuffer.*/
      58              :     )
      59              :     {
      60              :         static_cast<void>( len );
      61              : 
      62            0 :         auto fbs = GetTelem_offloading_fb( msgBuffer );
      63              : 
      64            0 :         std::string msg = "[offloading] ";
      65              : 
      66            0 :         msg += "modes: ";
      67            0 :         msg += std::to_string( fbs->num_modes() ) + " ";
      68              : 
      69            0 :         msg += "n-avg: ";
      70            0 :         msg += std::to_string( fbs->num_average() ) + " ";
      71              : 
      72            0 :         msg += "fps: ";
      73            0 :         msg += std::to_string( fbs->fps() ) + " ";
      74              : 
      75            0 :         return msg;
      76            0 :     }
      77              : 
      78            0 :     static uint32_t num_modes( void *msgBuffer )
      79              :     {
      80            0 :         auto fbs = GetTelem_offloading_fb( msgBuffer );
      81            0 :         return fbs->num_modes();
      82              :     }
      83              : 
      84            0 :     static uint32_t num_average( void *msgBuffer )
      85              :     {
      86            0 :         auto fbs = GetTelem_offloading_fb( msgBuffer );
      87            0 :         return fbs->num_average();
      88              :     }
      89              : 
      90            0 :     static float fps( void *msgBuffer )
      91              :     {
      92            0 :         auto fbs = GetTelem_offloading_fb( msgBuffer );
      93            0 :         return fbs->fps();
      94              :     }
      95              : 
      96              :     /// Get the logMetaDetail for a member by name
      97              :     /**
      98              :      * \returns the a logMetaDetail filled in with the appropriate details
      99              :      * \returns an empty logMetaDetail if member not recognized
     100              :      */
     101            0 :     static logMetaDetail getAccessor( const std::string &member /**< [in] the name of the member */ )
     102              :     {
     103            0 :         if( member == "num_modes" )
     104              :             return logMetaDetail( { "NUMBER OF MODES",
     105              :                                     logMeta::valTypes::Int,
     106              :                                     logMeta::metaTypes::State,
     107            0 :                                     reinterpret_cast<void *>( &num_modes ) } );
     108            0 :         else if( member == "num_average" )
     109              :             return logMetaDetail( { "FRAMES AVERAGED",
     110              :                                     logMeta::valTypes::Int,
     111              :                                     logMeta::metaTypes::State,
     112            0 :                                     reinterpret_cast<void *>( &num_average ) } );
     113            0 :         else if( member == "fps" )
     114              :             return logMetaDetail(
     115            0 :                 { "FPS", logMeta::valTypes::Float, logMeta::metaTypes::State, reinterpret_cast<void *>( &fps ) } );
     116              :         else
     117              :         {
     118            0 :             std::cerr << "No member " << member << " in telem_offloading\n";
     119            0 :             return logMetaDetail();
     120              :         }
     121              :     }
     122              : 
     123              : }; // telem_offloading
     124              : 
     125              : } // namespace logger
     126              : } // namespace MagAOX
     127              : 
     128              : #endif // logger_types_telem_offloading_hpp