Imar.hpp

Go to the documentation of this file.

#ifndef _IMAR_HPP_
#define _IMAR_HPP_

#include <iostream>
#include <Eigen/Geometry> 
#include <unsupported/Eigen/FFT> 
#include <boost/circular_buffer.hpp> 
namespace imu_imar
{
   
    enum CONSTS {
        NUMAXIS = 3, 
        PKG_SIZE = 50, 
        FFT_WINDOWS_SIZE = 64 
    };

    enum DATAGRAN_CONST {
        SYNC_WORD = 0x7E, 
        POLY = 0x8408
    };

    typedef struct {
        unsigned char data[2];
    }UINT16; 
    typedef struct {
        bool synchronized; 
        unsigned char counter; 
        int size;   
        int read;  
        int write;    
        unsigned char data[(2*imu_imar::PKG_SIZE) + 1];  /* vector of elements */
    } CircularBuffer;
    
    typedef struct {
        unsigned char counter; 
        unsigned int microseconds; 
        int length; 
//      unsigned char ibit[8]; /** Init Build in Test (IBIT) information check info **/
        float acc[imu_imar::NUMAXIS]; 
        float gyro[imu_imar::NUMAXIS]; 
        float euler[imu_imar::NUMAXIS]; 
        UINT16 crc; 
    } ImuData;
    


    class iVRU_BB
    {
        
        
        
        private:
            int fd;
            CircularBuffer myBuffer;
            ImuData myIMU;
            boost::circular_buffer<float> cbAccX;
            boost::circular_buffer<float> cbAccY;
            boost::circular_buffer<float> cbAccZ;
            Eigen::Matrix <double,imu_imar::NUMAXIS,1> velocity;
            Eigen::Matrix <double,imu_imar::NUMAXIS,1> displacement;
            
        public: 
            
            iVRU_BB();
            
            ~iVRU_BB();
            
            void welcome();
            
            bool open_port (const char* name);

            bool init_serial (const char *name, const int bauds);
            
            
            bool write_serial(char* command, int nbytes);
            
            
            bool read_serial(unsigned char * bufferpr, int nbytes);

            bool close_port ();
            
            int getDescriptor();
            
            
            int cbIsFull();
            
            int cbIsEmpty();
            
            bool cbIsSynchronized();
            
            
            void cbWritePckg(int nbytes, unsigned char * values);
            
            bool cbSynchronize ();
            
            bool cbCopyPckg(unsigned char *pckg, int len);
            
            bool cbReadValues();
            
            void cbPrintValues();
            
            int cbNumberElements();
            
            int getPacketCounter();
            
            Eigen::Matrix <double,imu_imar::NUMAXIS,1> getAccelerometers();
            
            Eigen::Matrix <double,imu_imar::NUMAXIS,1> getGyroscopes();
            
            
            Eigen::Quaternion <double> getAttitude();
            
            
            void cbCalculateAccIntegration (const float omega);
            
            Eigen::Matrix <double,imu_imar::NUMAXIS,1> getVelocity();
            
            Eigen::Matrix <double,imu_imar::NUMAXIS,1> getPosition();
            
            unsigned short crc16(unsigned char *data_p, int length);
            
            unsigned int Crc16_0(unsigned char const * pByte, unsigned Size);
            
            void cbReset();
            
    };

} // end namespace 

#endif // _IMAR_HPP_