LCOV - code coverage report
Current view: top level - libMagAOX/logger/types - telem_telpos.hpp (source / functions) Coverage Total Hit
Test: MagAOX Lines: 31.0 % 58 18
Test Date: 2026-01-03 21:03:39 Functions: 27.3 % 11 3

            Line data    Source code
       1              : /** \file telem_telpos.hpp
       2              :   * \brief The MagAO-X logger telem_telpos log type.
       3              :   * \author Jared R. Males (jaredmales@gmail.com)
       4              :   *
       5              :   * \ingroup logger_types_files
       6              :   *
       7              :   * History:
       8              :   * - 2018-09-06 created by JRM
       9              :   */
      10              : #ifndef logger_types_telem_telpos_hpp
      11              : #define logger_types_telem_telpos_hpp
      12              : 
      13              : #include "generated/telem_telpos_generated.h"
      14              : #include "flatbuffer_log.hpp"
      15              : 
      16              : #include <cmath>
      17              : 
      18              : namespace MagAOX
      19              : {
      20              : namespace logger
      21              : {
      22              : 
      23              : 
      24              : /// Log entry recording the build-time git state.
      25              : /** \ingroup logger_types
      26              :   */
      27              : struct telem_telpos : public flatbuffer_log
      28              : {
      29              :    ///The event code
      30              :    static const flatlogs::eventCodeT eventCode = eventCodes::TELEM_TELPOS;
      31              : 
      32              :    ///The default level
      33              :    static const flatlogs::logPrioT defaultLevel = flatlogs::logPrio::LOG_TELEM;
      34              : 
      35              :    static timespec lastRecord; ///< The time of the last time this log was recorded.  Used by the telemetry system.
      36              : 
      37              :    enum member{ em_epoch, em_ra, em_dec, em_el, em_ha, em_am, em_rotoff};
      38              : 
      39              :    ///The type of the input message
      40              :    struct messageT : public fbMessage
      41              :    {
      42              :       ///Construct from components
      43            1 :       messageT( const double & epoch, ///<[in] epoch
      44              :                 const double & ra,    ///<[in] right ascension
      45              :                 const double & dec,   ///<[in] declination
      46              :                 const double & el,    ///<[in] elevation
      47              :                 const double & ha,    ///<[in] hour angle
      48              :                 const double & am,    ///<[in] air mass
      49              :                 const double & rotoff ///<[in] rotoff
      50              :               )
      51            1 :       {
      52            1 :          auto fp = CreateTelem_telpos_fb(builder, epoch, ra, dec, el, ha, am, rotoff);
      53            1 :          builder.Finish(fp);
      54            1 :       }
      55              : 
      56              :    };
      57              : 
      58              : 
      59            1 :    static bool verify( flatlogs::bufferPtrT & logBuff,  ///< [in] Buffer containing the flatbuffer serialized message.
      60              :                        flatlogs::msgLenT len            ///< [in] length of msgBuffer.
      61              :                      )
      62              :    {
      63            1 :       auto verifier = flatbuffers::Verifier( static_cast<uint8_t*>(flatlogs::logHeader::messageBuffer(logBuff)), static_cast<size_t>(len));
      64            2 :       return VerifyTelem_telpos_fbBuffer(verifier);
      65              :    }
      66              : 
      67              :    ///Get the message formatte for human consumption.
      68            0 :    static std::string msgString( void * msgBuffer,  /**< [in] Buffer containing the flatbuffer serialized message.*/
      69              :                                  flatlogs::msgLenT len  /**< [in] [unused] length of msgBuffer.*/
      70              :                                )
      71              :    {
      72              :       static_cast<void>(len);
      73              : 
      74            0 :       auto fbs = GetTelem_telpos_fb(msgBuffer);
      75              : 
      76            0 :       std::string msg = "[telpos] ";
      77              : 
      78            0 :       msg += "ep: ";
      79            0 :       msg += std::to_string(fbs->epoch()) + " ";
      80              : 
      81            0 :       msg += "ra: ";
      82            0 :       msg += std::to_string(fbs->ra()) + " ";
      83              : 
      84            0 :       msg += "dec: ";
      85            0 :       msg += std::to_string(fbs->dec()) + " ";
      86              : 
      87            0 :       msg += "el: ";
      88            0 :       msg += std::to_string(fbs->el()) + " ";
      89              : 
      90            0 :       msg += "ha: ";
      91            0 :       msg += std::to_string(fbs->ha()) + " ";
      92              : 
      93            0 :       msg += "am: ";
      94            0 :       msg += std::to_string(fbs->am()) + " ";
      95              : 
      96            0 :       msg += "ro: ";
      97            0 :       msg += std::to_string(fbs->rotoff());
      98              : 
      99            0 :       return msg;
     100              : 
     101            0 :    }
     102              : 
     103            0 :    static double epoch( void * msgBuffer )
     104              :    {
     105            0 :       auto fbs = GetTelem_telpos_fb(msgBuffer);
     106            0 :       return fbs->epoch();
     107              :    }
     108              : 
     109            0 :    static double ra( void * msgBuffer )
     110              :    {
     111            0 :       auto fbs = GetTelem_telpos_fb(msgBuffer);
     112            0 :       return fbs->ra();
     113              :    }
     114              : 
     115            0 :    static double dec( void * msgBuffer )
     116              :    {
     117            0 :       auto fbs = GetTelem_telpos_fb(msgBuffer);
     118            0 :       return fbs->dec();
     119              :    }
     120              : 
     121            0 :    static double el( void * msgBuffer )
     122              :    {
     123            0 :       auto fbs = GetTelem_telpos_fb(msgBuffer);
     124            0 :       return fbs->el();
     125              :    }
     126              : 
     127            0 :    static double ha( void * msgBuffer )
     128              :    {
     129            0 :       auto fbs = GetTelem_telpos_fb(msgBuffer);
     130            0 :       return fbs->ha();
     131              :    }
     132              : 
     133            0 :    static double am( void * msgBuffer )
     134              :    {
     135            0 :       auto fbs = GetTelem_telpos_fb(msgBuffer);
     136            0 :       return fbs->am();
     137              :    }
     138              : 
     139            0 :    static double ro( void * msgBuffer )
     140              :    {
     141            0 :       auto fbs = GetTelem_telpos_fb(msgBuffer);
     142            0 :       return fbs->rotoff();
     143              :    }
     144              : 
     145              : 
     146              :    /// Get the logMetaDetail for a member by name
     147              :    /**
     148              :      * \returns the a logMetaDetail filled in with the appropriate details
     149              :      * \returns an empty logMetaDetail if member not recognized
     150              :      */
     151            1 :    static logMetaDetail getAccessor( const std::string & member /**< [in] the name of the member */ )
     152              :    {
     153            1 :       if(     member == "epoch") return logMetaDetail({"EPOCH", logMeta::valTypes::Double, logMeta::metaTypes::Continuous, reinterpret_cast<void*>(&epoch), false});
     154            1 :       else if(member == "ra") return logMetaDetail({"RA", "right ascension [degrees]", "%0.8f", logMeta::valTypes::Double, logMeta::metaTypes::Continuous, reinterpret_cast<void*>(&ra), false});
     155            1 :       else if(member == "dec") return logMetaDetail({"DEC", "declination [degrees]", "%0.8f", logMeta::valTypes::Double, logMeta::metaTypes::Continuous, reinterpret_cast<void*>(&dec), false});
     156            1 :       else if(member == "el") return logMetaDetail({"EL", "elevation [degrees]", "%0.8f", logMeta::valTypes::Double, logMeta::metaTypes::Continuous, reinterpret_cast<void*>(&el), false});
     157            1 :       else if(member == "ha") return logMetaDetail({"HA", "hour angle [degrees]", "%0.8f", logMeta::valTypes::Double, logMeta::metaTypes::Continuous, reinterpret_cast<void*>(&ha), false});
     158            1 :       else if(member == "am") return logMetaDetail({"AIRMASS", "airmass", "%0.2f", logMeta::valTypes::Double, logMeta::metaTypes::Continuous, reinterpret_cast<void*>(&am), false});
     159            1 :       else if(member == "ro") return logMetaDetail({"RO", "rotator offset [degrees]", "%0.8f", logMeta::valTypes::Double, logMeta::metaTypes::Continuous, reinterpret_cast<void*>(&ro), false});
     160              :       else
     161              :       {
     162            1 :          std::cerr << "No member " << member << " in telem_telpos\n";
     163            1 :          return logMetaDetail();
     164              :       }
     165              :    }
     166              : 
     167              : }; //telem_telpos
     168              : 
     169              : 
     170              : 
     171              : } //namespace logger
     172              : } //namespace MagAOX
     173              : 
     174              : #endif //logger_types_telem_telpos_hpp
     175              : 
        

Generated by: LCOV version 2.0-1