LCOV - code coverage report
Current view: top level - libMagAOX/logger/types - telem_fgtimings.hpp (source / functions) Coverage Total Hit
Test: MagAOX Lines: 29.3 % 58 17
Test Date: 2026-01-03 21:03:39 Functions: 30.0 % 10 3

            Line data    Source code
       1              : /** \file telem_fgtimings.hpp
       2              :   * \brief The MagAO-X logger telem_fgtimings log type.
       3              :   * \author Jared R. Males (jaredmales@gmail.com)
       4              :   *
       5              :   * \ingroup logger_types_files
       6              :   *
       7              :   * History:
       8              :   * - 2022-10-03 created by JRM
       9              :   */
      10              : #ifndef logger_types_telem_fgtimings_hpp
      11              : #define logger_types_telem_fgtimings_hpp
      12              : 
      13              : #include "generated/telem_fgtimings_generated.h"
      14              : #include "flatbuffer_log.hpp"
      15              : 
      16              : namespace MagAOX
      17              : {
      18              : namespace logger
      19              : {
      20              : 
      21              : 
      22              : /// Log entry recording framegrabber timings.
      23              : /** \ingroup logger_types
      24              :   */
      25              : struct telem_fgtimings : public flatbuffer_log
      26              : {
      27              :    ///The event code
      28              :    static const flatlogs::eventCodeT eventCode = eventCodes::TELEM_FGTIMINGS;
      29              : 
      30              :    ///The default level
      31              :    static const flatlogs::logPrioT defaultLevel = flatlogs::logPrio::LOG_TELEM;
      32              : 
      33              :    static timespec lastRecord; ///< The timestamp of the last time this log was recorded.  Used by the telemetry system.
      34              : 
      35              :    ///The type of the input message
      36              :    struct messageT : public fbMessage
      37              :    {
      38              :       ///Construct from components
      39            1 :       messageT( const double & atime,         ///< [in] acquisition time deltas
      40              :                 const double & atime_jitter,  ///< [in] jitter in acquisition time deltas
      41              :                 const double & wtime,         ///< [in] acquisition time deltas
      42              :                 const double & wtime_jitter,  ///< [in] jitter in acquisition time deltas
      43              :                 const double & mawtime,       ///< [in] acquisition time deltas
      44              :                 const double & mawtime_jitter ///< [in] jitter in acquisition time deltas
      45              :               )
      46            1 :       {
      47            1 :          auto fp = CreateTelem_fgtimings_fb(builder, atime, atime_jitter, wtime, wtime_jitter, mawtime, mawtime_jitter);
      48            1 :          builder.Finish(fp);
      49            1 :       }
      50              : 
      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)), static_cast<size_t>(len));
      58            2 :       return VerifyTelem_fgtimings_fbBuffer(verifier);
      59              :    }
      60              : 
      61              :    ///Get the message formatte for human consumption.
      62            0 :    static std::string msgString( void * msgBuffer,  /**< [in] Buffer containing the flatbuffer serialized message.*/
      63              :                                  flatlogs::msgLenT len  /**< [in] [unused] length of msgBuffer.*/
      64              :                                )
      65              :    {
      66              :       static_cast<void>(len);
      67              : 
      68              :       char buf[64];
      69              : 
      70            0 :       auto fbs = GetTelem_fgtimings_fb(msgBuffer);
      71              : 
      72            0 :       std::string msg = "[fgtimes]";
      73              : 
      74            0 :       msg += " acq: ";
      75              : 
      76            0 :       snprintf(buf, sizeof(buf), "%0.10e", fbs->atime());
      77            0 :       msg += buf;
      78            0 :       msg += " +/- ";
      79            0 :       snprintf(buf, sizeof(buf), "%0.5e", fbs->atime_jitter());
      80            0 :       msg += buf;
      81              : 
      82            0 :       msg += " wrt: ";
      83              : 
      84            0 :       snprintf(buf, sizeof(buf), "%0.10e", fbs->wtime());
      85            0 :       msg += buf;
      86            0 :       msg += " +/- ";
      87            0 :       snprintf(buf, sizeof(buf), "%0.5e", fbs->wtime_jitter());
      88            0 :       msg += buf;
      89              : 
      90            0 :       msg += " wma: ";
      91              : 
      92            0 :       snprintf(buf, sizeof(buf), "%0.10e", fbs->wmatime());
      93            0 :       msg += buf;
      94            0 :       msg += " +/- ";
      95            0 :       snprintf(buf, sizeof(buf), "%0.5e", fbs->wmatime_jitter());
      96            0 :       msg += buf;
      97              : 
      98            0 :       return msg;
      99              : 
     100            0 :    }
     101              : 
     102            0 :    static double atime( void * msgBuffer )
     103              :    {
     104            0 :       auto fbs = GetTelem_fgtimings_fb(msgBuffer);
     105            0 :       return fbs->atime();
     106              :    }
     107              : 
     108            0 :    static double atime_jitter( void * msgBuffer )
     109              :    {
     110            0 :       auto fbs = GetTelem_fgtimings_fb(msgBuffer);
     111            0 :       return fbs->atime_jitter();
     112              :    }
     113              : 
     114            0 :    static double wtime( void * msgBuffer )
     115              :    {
     116            0 :       auto fbs = GetTelem_fgtimings_fb(msgBuffer);
     117            0 :       return fbs->wtime();
     118              :    }
     119              : 
     120            0 :    static double wtime_jitter( void * msgBuffer )
     121              :    {
     122            0 :       auto fbs = GetTelem_fgtimings_fb(msgBuffer);
     123            0 :       return fbs->wtime_jitter();
     124              :    }
     125              : 
     126            0 :    static double wmatime( void * msgBuffer )
     127              :    {
     128            0 :       auto fbs = GetTelem_fgtimings_fb(msgBuffer);
     129            0 :       return fbs->wmatime();
     130              :    }
     131              : 
     132            0 :    static double wmatime_jitter( void * msgBuffer )
     133              :    {
     134            0 :       auto fbs = GetTelem_fgtimings_fb(msgBuffer);
     135            0 :       return fbs->wmatime_jitter();
     136              :    }
     137              : 
     138              :    /// Get the logMetaDetail for a member by name
     139              :    /**
     140              :      * \returns the a logMetaDetail filled in with the appropriate details
     141              :      * \returns an empty logMetaDetail if member not recognized
     142              :      */
     143            1 :    static logMetaDetail getAccessor( const std::string & member /**< [in] the name of the member */ )
     144              :    {
     145            1 :       if(member == "atime") return logMetaDetail({"ACQ TIME", logMeta::valTypes::Double, logMeta::metaTypes::Continuous, reinterpret_cast<void*>(&atime)});
     146            1 :       else if(member == "atime_jitter") return logMetaDetail({"ACQ JITTER", logMeta::valTypes::Double, logMeta::metaTypes::Continuous, reinterpret_cast<void*>(&atime_jitter)});
     147            1 :       else if(member == "wtime") return logMetaDetail({"WRT TIME", logMeta::valTypes::Double, logMeta::metaTypes::Continuous, reinterpret_cast<void*>(&wtime)});
     148            1 :       else if(member == "wtime_jitter") return logMetaDetail({"WRT JITTER", logMeta::valTypes::Double, logMeta::metaTypes::Continuous, reinterpret_cast<void*>(&wtime_jitter)});
     149            1 :       else if(member == "wmatime") return logMetaDetail({"WRT-ACQ TIME", logMeta::valTypes::Double, logMeta::metaTypes::Continuous, reinterpret_cast<void*>(&wmatime)});
     150            1 :       else if(member == "wmatime_jitter") return logMetaDetail({"WRT-ACQ JITTER", logMeta::valTypes::Double, logMeta::metaTypes::Continuous, reinterpret_cast<void*>(&wmatime_jitter)});
     151              : 
     152              :       else
     153              :       {
     154            1 :          std::cerr << "No member " << member << " in telem_fgtimings\n";
     155            1 :          return logMetaDetail();
     156              :       }
     157              :    }
     158              : 
     159              : }; //telem_fgtimings
     160              : 
     161              : 
     162              : 
     163              : } //namespace logger
     164              : } //namespace MagAOX
     165              : 
     166              : #endif //logger_types_telem_fgtimings_hpp
     167              : 
        

Generated by: LCOV version 2.0-1