LCOV - code coverage report
Current view: top level - libMagAOX/logger/types - cred2_temps.hpp (source / functions) Coverage Total Hit
Test: MagAOX Lines: 13.8 % 65 9
Test Date: 2026-04-15 19:34:29 Functions: 18.2 % 11 2

            Line data    Source code
       1              : /** \file cred2_temps.hpp
       2              :  * \brief The MagAO-X logger cred2_temps log type.
       3              :  * \author Jared R. Males (jaredmales@gmail.com)
       4              :  *
       5              :  * \ingroup logger_types_files
       6              :  *
       7              :  * History:
       8              :  * - 2026-03-27 created by Codex
       9              :  */
      10              : #ifndef logger_types_cred2_temps_hpp
      11              : #define logger_types_cred2_temps_hpp
      12              : 
      13              : #include "generated/cred2_temps_generated.h"
      14              : #include "flatbuffer_log.hpp"
      15              : 
      16              : namespace MagAOX
      17              : {
      18              : namespace logger
      19              : {
      20              : 
      21              : /// Log entry recording the C-RED 2 detailed temperature channels.
      22              : /** \ingroup logger_types
      23              :  */
      24              : struct cred2_temps : public flatbuffer_log
      25              : {
      26              :     /// The event code
      27              :     static const flatlogs::eventCodeT eventCode = eventCodes::CRED2_TEMPS;
      28              : 
      29              :     /// The default level
      30              :     static const flatlogs::logPrioT defaultLevel = flatlogs::logPrio::LOG_TELEM;
      31              : 
      32              :     static timespec lastRecord; ///< The timestamp of the last time this log was recorded. Used by telemetry.
      33              : 
      34              :     /// The type of the input message
      35              :     struct messageT : public fbMessage
      36              :     {
      37              :         /// Construct from components
      38           10 :         messageT( const float &motherboard, ///< [in] motherboard temperature [C]
      39              :                   const float &frontend,    ///< [in] front-end temperature [C]
      40              :                   const float &powerboard,  ///< [in] power-board temperature [C]
      41              :                   const float &snake,       ///< [in] detector temperature [C]
      42              :                   const float &setpoint,    ///< [in] detector setpoint temperature [C]
      43              :                   const float &peltier,     ///< [in] external TEC temperature [C]
      44              :                   const float &heatsink     ///< [in] heatsink temperature [C]
      45              :         )
      46           10 :         {
      47              :             auto fp =
      48           10 :                 CreateCred2_temps_fb( builder, motherboard, frontend, powerboard, snake, setpoint, peltier, heatsink );
      49           10 :             builder.Finish( fp );
      50           10 :         }
      51              :     };
      52              : 
      53            1 :     static bool verify( flatlogs::bufferPtrT &logBuff, ///< [in] buffer containing the flatbuffer serialized message
      54              :                         flatlogs::msgLenT     len      ///< [in] length of msgBuffer
      55              :     )
      56              :     {
      57            1 :         auto verifier = flatbuffers::Verifier( static_cast<uint8_t *>( flatlogs::logHeader::messageBuffer( logBuff ) ),
      58            1 :                                                static_cast<size_t>( len ) );
      59            2 :         return VerifyCred2_temps_fbBuffer( verifier );
      60              :     }
      61              : 
      62              :     /// Get the message formatted for human consumption.
      63            0 :     static std::string msgString( void *msgBuffer,      /**< [in] buffer containing the flatbuffer serialized message */
      64              :                                   flatlogs::msgLenT len /**< [in] [unused] length of msgBuffer */
      65              :     )
      66              :     {
      67              :         static_cast<void>( len );
      68              : 
      69            0 :         auto fbs = GetCred2_temps_fb( msgBuffer );
      70              : 
      71            0 :         std::string msg = "mb: ";
      72            0 :         msg += std::to_string( fbs->motherboard() ) + " C ";
      73              : 
      74            0 :         msg += "fe: ";
      75            0 :         msg += std::to_string( fbs->frontend() ) + " C ";
      76              : 
      77            0 :         msg += "pwr: ";
      78            0 :         msg += std::to_string( fbs->powerboard() ) + " C ";
      79              : 
      80            0 :         msg += "snake: ";
      81            0 :         msg += std::to_string( fbs->snake() ) + " C ";
      82              : 
      83            0 :         msg += "setpt: ";
      84            0 :         msg += std::to_string( fbs->setpoint() ) + " C ";
      85              : 
      86            0 :         msg += "pelt: ";
      87            0 :         msg += std::to_string( fbs->peltier() ) + " C ";
      88              : 
      89            0 :         msg += "sink: ";
      90            0 :         msg += std::to_string( fbs->heatsink() ) + " C ";
      91              : 
      92            0 :         return msg;
      93            0 :     }
      94              : 
      95            0 :     static float motherboard( void *msgBuffer /**< [in] buffer containing the flatbuffer serialized message */ )
      96              :     {
      97            0 :         auto fbs = GetCred2_temps_fb( msgBuffer );
      98            0 :         return fbs->motherboard();
      99              :     }
     100              : 
     101            0 :     static float frontend( void *msgBuffer /**< [in] buffer containing the flatbuffer serialized message */ )
     102              :     {
     103            0 :         auto fbs = GetCred2_temps_fb( msgBuffer );
     104            0 :         return fbs->frontend();
     105              :     }
     106              : 
     107            0 :     static float powerboard( void *msgBuffer /**< [in] buffer containing the flatbuffer serialized message */ )
     108              :     {
     109            0 :         auto fbs = GetCred2_temps_fb( msgBuffer );
     110            0 :         return fbs->powerboard();
     111              :     }
     112              : 
     113            0 :     static float snake( void *msgBuffer /**< [in] buffer containing the flatbuffer serialized message */ )
     114              :     {
     115            0 :         auto fbs = GetCred2_temps_fb( msgBuffer );
     116            0 :         return fbs->snake();
     117              :     }
     118              : 
     119            0 :     static float setpoint( void *msgBuffer /**< [in] buffer containing the flatbuffer serialized message */ )
     120              :     {
     121            0 :         auto fbs = GetCred2_temps_fb( msgBuffer );
     122            0 :         return fbs->setpoint();
     123              :     }
     124              : 
     125            0 :     static float peltier( void *msgBuffer /**< [in] buffer containing the flatbuffer serialized message */ )
     126              :     {
     127            0 :         auto fbs = GetCred2_temps_fb( msgBuffer );
     128            0 :         return fbs->peltier();
     129              :     }
     130              : 
     131            0 :     static float heatsink( void *msgBuffer /**< [in] buffer containing the flatbuffer serialized message */ )
     132              :     {
     133            0 :         auto fbs = GetCred2_temps_fb( msgBuffer );
     134            0 :         return fbs->heatsink();
     135              :     }
     136              : 
     137              :     /// Get the logMetaDetail for a member by name.
     138              :     /**
     139              :      * \returns a logMetaDetail filled in with the appropriate details
     140              :      * \returns an empty logMetaDetail if member not recognized
     141              :      */
     142            0 :     static logMetaDetail getAccessor( const std::string &member /**< [in] the name of the member */ )
     143              :     {
     144            0 :         if( member == "motherboard" )
     145              :             return logMetaDetail( { "MB TEMP",
     146              :                                     "motherboard temperature [C]",
     147              :                                     logMeta::valTypes::Float,
     148              :                                     logMeta::metaTypes::Continuous,
     149              :                                     reinterpret_cast<void *>( &motherboard ),
     150            0 :                                     false } );
     151            0 :         else if( member == "frontend" )
     152              :             return logMetaDetail( { "FE TEMP",
     153              :                                     "front-end temperature [C]",
     154              :                                     logMeta::valTypes::Float,
     155              :                                     logMeta::metaTypes::Continuous,
     156              :                                     reinterpret_cast<void *>( &frontend ),
     157            0 :                                     false } );
     158            0 :         else if( member == "powerboard" )
     159              :             return logMetaDetail( { "PWR TEMP",
     160              :                                     "power-board temperature [C]",
     161              :                                     logMeta::valTypes::Float,
     162              :                                     logMeta::metaTypes::Continuous,
     163              :                                     reinterpret_cast<void *>( &powerboard ),
     164            0 :                                     false } );
     165            0 :         else if( member == "snake" )
     166              :             return logMetaDetail( { "SNAKE TEMP",
     167              :                                     "detector temperature [C]",
     168              :                                     logMeta::valTypes::Float,
     169              :                                     logMeta::metaTypes::Continuous,
     170              :                                     reinterpret_cast<void *>( &snake ),
     171            0 :                                     false } );
     172            0 :         else if( member == "setpoint" )
     173              :             return logMetaDetail( { "SET TEMP",
     174              :                                     "detector setpoint temperature [C]",
     175              :                                     logMeta::valTypes::Float,
     176              :                                     logMeta::metaTypes::Continuous,
     177              :                                     reinterpret_cast<void *>( &setpoint ),
     178            0 :                                     false } );
     179            0 :         else if( member == "peltier" )
     180              :             return logMetaDetail( { "PELTIER TEMP",
     181              :                                     "external TEC temperature [C]",
     182              :                                     logMeta::valTypes::Float,
     183              :                                     logMeta::metaTypes::Continuous,
     184              :                                     reinterpret_cast<void *>( &peltier ),
     185            0 :                                     false } );
     186            0 :         else if( member == "heatsink" )
     187              :             return logMetaDetail( { "SINK TEMP",
     188              :                                     "heatsink temperature [C]",
     189              :                                     logMeta::valTypes::Float,
     190              :                                     logMeta::metaTypes::Continuous,
     191              :                                     reinterpret_cast<void *>( &heatsink ),
     192            0 :                                     false } );
     193              :         else
     194              :         {
     195            0 :             std::cerr << "No member " << member << " in cred2_temps\n";
     196            0 :             return logMetaDetail();
     197              :         }
     198              :     }
     199              : };
     200              : 
     201              : } // namespace logger
     202              : } // namespace MagAOX
     203              : 
     204              : #endif // logger_types_cred2_temps_hpp
        

Generated by: LCOV version 2.0-1