Line data    Source code

       1              : /** \file telem_flowrpm.hpp
       2              :  * \brief The MagAO-X logger telem_flowrpm log type.
       3              :  * \author Jared R. Males (jaredmales@gmail.com)
       4              :  *
       5              :  * \ingroup logger_types_files
       6              :  */
       7              : 
       8              : #ifndef logger_types_telem_flowrpm_hpp
       9              : #define logger_types_telem_flowrpm_hpp
      10              : 
      11              : #include "generated/telem_flowrpm_generated.h"
      12              : #include "flatbuffer_log.hpp"
      13              : 
      14              : namespace MagAOX
      15              : {
      16              : namespace logger
      17              : {
      18              : 
      19              : /// Log entry recording the displayed flow value and source age.
      20              : /** \ingroup logger_types
      21              :  */
      22              : struct telem_flowrpm : public flatbuffer_log
      23              : {
      24              :     /// The event code.
      25              :     static const flatlogs::eventCodeT eventCode = eventCodes::TELEM_FLOWRPM;
      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            5 :         messageT( const double flowRate, /**< [in] displayed flow rate in LPM */
      37              :                   const double age,      /**< [in] displayed age in seconds */
      38              :                   const bool   valid     /**< [in] whether the displayed value is valid */
      39              :         )
      40            5 :         {
      41            5 :             auto fp = CreateTelem_flowrpm_fb( builder, flowRate, age, valid );
      42            5 :             builder.Finish( fp );
      43            5 :         }
      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_flowrpm_fbBuffer( verifier );
      53              :     }
      54              : 
      55              :     /// Get the message formatted 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_flowrpm_fb( msgBuffer );
      63            0 :         std::string msg = "[flowrpm] ";
      64              : 
      65            0 :         msg += "flow: ";
      66            0 :         msg += std::to_string( fbs->flowRate() );
      67            0 :         msg += " LPM age: ";
      68            0 :         msg += std::to_string( fbs->age() );
      69            0 :         msg += " s valid: ";
      70            0 :         msg += ( fbs->valid() ? "true" : "false" );
      71              : 
      72            0 :         return msg;
      73            0 :     }
      74              : 
      75              :     /// Recover the flow rate from a serialized message.
      76            0 :     static double flowRate( void *msgBuffer )
      77              :     {
      78            0 :         return GetTelem_flowrpm_fb( msgBuffer )->flowRate();
      79              :     }
      80              : 
      81              :     /// Recover the age from a serialized message.
      82            0 :     static double age( void *msgBuffer )
      83              :     {
      84            0 :         return GetTelem_flowrpm_fb( msgBuffer )->age();
      85              :     }
      86              : 
      87              :     /// Recover the validity flag from a serialized message.
      88            0 :     static bool valid( void *msgBuffer )
      89              :     {
      90            0 :         return GetTelem_flowrpm_fb( msgBuffer )->valid();
      91              :     }
      92              : 
      93              :     /// Get the logMetaDetail for a member by name.
      94            0 :     static logMetaDetail getAccessor( const std::string &member /**< [in] the name of the member */ )
      95              :     {
      96            0 :         if( member == "flowRate" )
      97              :         {
      98              :             return logMetaDetail( { "FLOW RATE",
      99              :                                     "LPM",
     100              :                                     logMeta::valTypes::Double,
     101              :                                     logMeta::metaTypes::Continuous,
     102              :                                     reinterpret_cast<void *>( &flowRate ),
     103            0 :                                     true } );
     104              :         }
     105            0 :         else if( member == "age" )
     106              :         {
     107              :             return logMetaDetail( { "FLOW AGE",
     108              :                                     "s",
     109              :                                     logMeta::valTypes::Double,
     110              :                                     logMeta::metaTypes::Continuous,
     111              :                                     reinterpret_cast<void *>( &age ),
     112            0 :                                     true } );
     113              :         }
     114            0 :         else if( member == "valid" )
     115              :         {
     116              :             return logMetaDetail( { "FLOW VALID",
     117              :                                     "",
     118              :                                     logMeta::valTypes::Bool,
     119              :                                     logMeta::metaTypes::State,
     120              :                                     reinterpret_cast<void *>( &valid ),
     121            0 :                                     true } );
     122              :         }
     123              :         else
     124              :         {
     125            0 :             std::cerr << "No member " << member << " in telem_flowrpm\n";
     126            0 :             return logMetaDetail();
     127              :         }
     128              :     }
     129              : };
     130              : 
     131              : } // namespace logger
     132              : } // namespace MagAOX
     133              : 
     134              : #endif // logger_types_telem_flowrpm_hpp