vorad/vorad.H

Go to the documentation of this file.

// Copyright (C) 2004 Nitin Jyoti
// Copyright (C) 2004 Pablo Mejia


#ifndef CAJUN_VORAD_H
#define CAJUN_VORAD_H

#define F2M                     (0.3048)
#define MAX_ERROR_COUNT         32      //only bad pkts/data

#include <inttypes.h>

namespace cajun
{
        class input_buffer_t;

        class vorad_t
        {
        public:
                vorad_t (int fd_);
                ~vorad_t ();

                enum vorad_message_enum
                {
                        VORAD_STARTUP_MSG       =       81,
                        VORAD_TARGET_MSG        =       82,
                        VORAD_CALIB_MSG         =       83
                };

                // All Eaton RADAR specific structures.
                struct vorad_targetinfo
                {
                        // Range        3-4     int     LSB = 0.1 ft
                        uint8_t m_range[2];
                        // Relative Vel 5-6     int     LSB = 0.1 ft/sec
                        uint8_t m_velocity[2];
                        // Azimuth      7       char    LSB = 0.002 radians
                        int8_t  m_azimuth;
                        // Magnitude    8       uchar   LSB = -0.543 dB
                        uint8_t m_magnitude;
                        // Lock         9       bmb  bit mapped MofN reporting
                        uint8_t m_lock;
                public:
                        int range() const
                        {
                          return((m_range[1] << 8) | m_range[0]);
                        } // Vorad units, as unsigned
                        double range_in_m() const
                        {
                                return(range()*0.1*F2M);
                        } // range in feet
                        int velocity() const
                        {
                                return(((int8_t)m_velocity[1] << 8) | m_velocity[0]);
                        } // Vorad units, as signed (>0 if receding)
                        double velocity_in_mps() const
                        {
                                return(velocity()*0.1*F2M);
                        } // velocity in feet per second.
                        double azimuthrad() const
                        {
                                return(m_azimuth*0.002);
                        } // azimuth in radians
                        double magnitudedb() const
                        {
                                return(m_magnitude*(-0.543));
                        } // magnitude in dB
                        void dump() const;
                };

                struct vorad_targetdrop
                {
                        uint8_t         m_targetdropped[7];
                public:
                        void dump() const;
                };

                struct vorad_field
                {
                        uint8_t m_targetid;//ID number 1-255
                                           // 0 indicates a target drop
                        union { // one of two formats
                                vorad_targetinfo        m_targetinfo;
                                vorad_targetdrop        m_targetsdropped;
                        };
                public:
                        void dump() const;
                };

                struct vorad_target_msg
                {
                        uint8_t         m_msgnum;       // message num
                        uint8_t         m_sequence;     // message sequence
                        uint8_t         m_targetcount;  // number of targets
                        vorad_field     m_targets[7];   // up to 7 targets
                        // 7 is MAX_RADAR_TGTS which is defined also in
                        // data_type.H. A duplication? do u care?
                public:
                        void dump() const;
                };
                // End Eaton RADAR structs

                class observer_t
                {
                public:
                        enum vorad_message_t
                        {
                                STATUS_FULL_BUFFER,
                                STATUS_RESET
                        };

                        virtual ~observer_t () {}
                        virtual void publish_status (double tstamp,
                                                     unsigned status) {}
                        virtual void radarData (vorad_target_msg *ptrMsg) {}
                };

                void register_observer (observer_t *observer)
                {
                        m_observer = observer;
                }

                void    handle_input (void);
                bool    is_valid_vorad_data(unsigned char const *beg,
                                            unsigned char const *end);
                int     decode (unsigned char const *beg,
                                unsigned char const *end);

        protected:
                int m_fd;
                long m_errorcounter;
                input_buffer_t *m_ib;
                observer_t *m_observer;
        };
};


#endif

---